From ec7defb3dbcee1fdcc2839989bdbc4d9110a912d Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:25:31 +0000 Subject: [PATCH 001/136] docs: specify bound effects and centralized recovery --- docs/plans/0074-implementation-handoff.md | 92 ++++ ...ound-effects-and-recovery-state-machine.md | 400 ++++++++++++++++++ 2 files changed, 492 insertions(+) create mode 100644 docs/plans/0074-implementation-handoff.md create mode 100644 docs/specs/0074-bound-effects-and-recovery-state-machine.md diff --git a/docs/plans/0074-implementation-handoff.md b/docs/plans/0074-implementation-handoff.md new file mode 100644 index 000000000..3ec819dc1 --- /dev/null +++ b/docs/plans/0074-implementation-handoff.md @@ -0,0 +1,92 @@ +# AP-SPEC-074 implementation handoff + +This prompt is for a new agent working in the already-created worktree. It is not +an instruction to resume the paused AP073 implementation. The specification is +complete as a handoff document; the implementation described by it has not begun. + +## Copy/paste prompt + +```text +Make it your goal to implement AP-SPEC-074 completely: + +/Users/bordumb/workspace/repositories/auths-proof-base/auths-proof-effect-recovery/docs/specs/0074-bound-effects-and-recovery-state-machine.md + +Work only in: +/Users/bordumb/workspace/repositories/auths-proof-base/auths-proof-effect-recovery + +Branch: codex/effect-recovery-foundation +Baseline: origin/main at e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b + +Start by reading AGENTS.md, the required profile/domain abstraction boundary plan, +and the full AP-SPEC-074. Inspect the worktree and preserve any existing changes. +Write your own durable goal prompt covering the complete specification, then +implement it. Keep progress and the acceptance/evidence ledger in +docs/plans/0074-implementation-status.md. + +The goal has exactly two architectural pillars: +1. One immutable bound effect model shared by native authorization, deterministic + request compilation, human approval, admission, execution and reporting. +2. One authoritative recovery transition model and transaction contract for + reservation, provider entry, disclosure, acknowledgement and unknown outcomes. + +Finish this foundation before expanding multi-agent delegation. Do not implement +participant trees, federation, broad identity lifecycle redesign or a new token +system. Do not merge/cherry-pick the AP073 branch wholesale. The separate +codex/identity-authority-foundation worktree is paused and contains uncommitted +work; do not modify, reset, clean or commit anything there. AP073 is not a +prerequisite or part of this goal. + +Main already has the gateway's native verifier integration, closed recipe +compiler, submission step machine, attempt transitions, durable stores, lifecycle +reference contracts and deployment clock. Read these first and preserve sound +mechanisms. Do not create a third lifecycle framework. Complete P0's owner mapping, +ADR and abstraction case, then perform bounded direct cutovers through P1–P4. +Centralize shared semantic decisions; do not scatter independent clock, hash, +approval, retry or accounting fixes through routes, demos and bindings. + +The shared model must retain typed differences between acquisition, disclosure +and mutation. A provider response, receipt signature, state match and recipient +ACK establish different facts. An unknown outcome must never authorize a blind +retry, redelivery or refund. Entry permits are issued once, only after the required +durable acknowledgement; persisted facts cannot recreate lost permits. Fresh +native authority, approval, configuration and revocation checks must be ordered +with the final entry decision. Bindings expose Rust semantics rather than +reimplementing them. + +Produce actual behavior, fault-injection, concurrency, differential, installed +binding and formal/refinement evidence for the specification's invariants and +A01–A22. The first complete journey is one human and one agent: bounded acquisition, +controlled disclosure, exact approved write, independent observation and truthful +recovery. Use real local transport/process boundaries and maintained durable +adapters. Do not claim live-provider or isolation guarantees from a unit test. +Record external assumptions and unsupported rollback guarantees precisely. + +Commit coherent implementation changes along the way using Conventional Commits. +Follow the repository's GitHub-first verification policy. Generate required +artifacts locally as needed to construct the change; do not duplicate broad local +build/test/lint/formal suites without the policy's justification. Observe CI only +after the spec implementation, fixtures and documentation are complete. Then push +explicitly to origin codex/effect-recovery-foundation (never to main), open/update +a draft PR against main, observe all required hosted workflows on the exact head, +repair failures and repeat. Do not merge or deploy. + +Do not mark the goal complete for a spec, scaffold, wrapper, happy path, passing +compilation or isolated test. Finish the source cutover and required evidence. +If genuinely blocked by an external dependency, preserve the work and report the +specific incomplete criterion, evidence and smallest required intervention. +Do not weaken checks or silently narrow the scope to manufacture completion. + +At completion, report the PR, exact revision, tests/CI results, central owners, +removed duplicate paths, and remaining deployment assumptions. Do not resume +multi-agent delegation as an automatic follow-on. +``` + +## Current handoff facts + +- This worktree was created from freshly fetched `origin/main`, independently of + draft PR #212 and its uncommitted changes. +- Only AP074 specification and handoff documentation are authored here. +- No implementation, test execution, push, CI observation, PR creation or agent + dispatch is part of this documentation handoff. +- The existing AP073 goal was explicitly marked **paused** at the user's request. +- The specification distinguishes required future evidence from existing code. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md new file mode 100644 index 000000000..0fb17b262 --- /dev/null +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -0,0 +1,400 @@ +# AP-SPEC-074: Bound effects and one recovery state model + +- **Status:** Implementation specification; no completion or qualification claim. +- **Date:** 28 October 2026. +- **Baseline:** `origin/main` at `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b`. +- **Branch:** `codex/effect-recovery-foundation`. +- **Priority:** Complete this foundation before expanding multi-agent delegation. +- **Handoff:** [Implementation prompt](../plans/0074-implementation-handoff.md). +- **Normative terms:** MUST and MUST NOT are acceptance requirements. Proposed type names below do not imply that those types already exist. + +## 1. Objective and scope + +Implement two architectural changes together: + +1. **One bound effect description.** Authorization, request compilation, approval, admission, execution, recovery and reporting refer to the same immutable effect identity and its authoritative Rust representation. +2. **One recovery state owner.** Reservation, provider entry, disclosure, acknowledgement and uncertain outcomes are governed by one explicit transition model, with invariants preserved across concurrency, failure, retry and restart. + +The first complete demonstration is one human authorizing one agent to acquire a bounded resource, receive an authorized disclosure, and perform one exactly approved mutation followed by independent observation. A deterministic provider fixture must exercise actual transport and restart boundaries. Expanding participant enrollment, delegation trees, federation, identity recovery or native resource enforcement is outside this specification. + +This is a prerequisite foundation for those later features. Do not import the AP073 branch wholesale, copy its unfinished task protocol, or make this work depend on its merge. Its findings may inform adversarial cases after independent verification against this baseline. + +The work must replace competing interpretations, not add another wrapper around them. Completion requires maintained consumers to use the new owner and superseded managed execution paths to be removed. It does not require replacing sound cryptography, the native verifier, established recipes or the whole repository. + +## 2. Existing foundations and the actual gap + +This inventory is based on source at the baseline, not a claim of exhaustive review. + +| Existing surface | What is already present | Required disposition | +| --- | --- | --- | +| [`VerifiedAction`](../../core/crates/auths-verifier/src/lib.rs) | Sealed native action, selected branches and evidence satisfactions. | Retain native verification as the authority source. A signature, parsed proof or application principal must not replace it. | +| [`VerifiedCommand` and `verify_detailed`](../../product/runtime/auths-gateway/src/engine.rs) | Native verification, branch projection and closed request construction. | Consolidate downstream effect binding here; eliminate independently reconstructed security facts. | +| [`CompiledRecipe` and `ClosedProviderRequest`](../../product/runtime/auths-gateway/src/recipe.rs) | Bounded data-only request compiler, account/credential requirements, observation plan. | Retain reviewed compilation. Bind its exact result, recipe identity and installation to the effect. | +| [`submit.rs`](../../product/runtime/auths-gateway/src/submit.rs) and [`order.rs`](../../product/runtime/auths-gateway-kernel/src/order.rs) | A pure step machine already directs write admission and I/O ordering. | Extend or refactor this maintained owner. Do not create an unrelated executor alongside it. | +| [`transition.rs`](../../product/runtime/auths-gateway-kernel/src/transition.rs), [`recovery.rs`](../../product/runtime/auths-gateway-kernel/src/recovery.rs), [`outcome.rs`](../../product/runtime/auths-gateway-kernel/src/outcome.rs) | Attempt transition rules, recovery capability and truthful outcome predicates. | Preserve their invariants and formal links while making reservation, entry and disclosure explicit. | +| [`GatewayAttempts`](../../product/runtime/auths-gateway/src/store.rs) | Attempt records, atomic bounded claims, counters, file and PostgreSQL adapters. | Use one logical effect journal and one transaction contract. Do not add an independently authoritative task ledger. | +| [`auths-lifecycle`](../../product/runtime/auths-lifecycle/src/lib.rs), especially [`operation.rs`](../../product/runtime/auths-lifecycle/src/operation.rs) and [`sealed.rs`](../../product/runtime/auths-lifecycle/src/sealed.rs) | Versioned identities, preparation commitments, lifecycle relations and store acknowledgements used by reference consumers. | Compare and reuse exact mechanisms. Document why retained reference models are not a second production owner. Do not invent a third lifecycle framework. | +| AP070 [`admission.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/admission.py), [`read_executor.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/read_executor.py) and [`receipts.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/receipts.py) | Demo-owned SQLite read accounting, release decisions and receipt orchestration. | Move shared effect/recovery decisions into the Rust owner; retain presentation and provider-specific reference behavior at the appropriate boundary. | +| [`DeploymentClock`](../../product/runtime/auths-gateway/src/qualification.rs) | An existing deployment time/trust boundary. | Strengthen this contract where necessary. Do not introduce clocks in individual handlers or reinterpret signed event time. | + +Main contains AP070, not the AP071/AP073 native task read/write implementation. This specification must be implementable without files that exist only on those branches. + +Before consolidation: + +```mermaid +flowchart TB + N[Native verified action] --> W[Write command and recipe compilation] + W --> O[Gateway submission order] + O --> J[Gateway attempts and counters] + N --> D[Demo read projection] + D --> S[Python read reservation and release state] + J --> WR[Write outcome projection] + S --> RR[Read receipt projection] + L[Lifecycle reference contracts] -. separate ownership mapping .-> J +``` + +Target: + +```mermaid +flowchart TB + N[Native verified action and installed policy] --> C[Deterministic effect compiler] + C --> B[Immutable bound effect] + B --> H[Human review and approval of effect identity] + H --> A[Fresh admission checks] + B --> A + A --> R[One pure operation transition model] + R <--> J[One transactional effect journal and capacity owner] + J --> P[Durably minted one-use entry capability] + P --> X[Closed provider or recipient transport] + X --> E[Typed response, acknowledgement or uncertainty evidence] + E --> R + J --> V[Native receipt and activity projections] + V --> UI[Thin bindings and UI] +``` + +“One” means one semantic owner and one atomic admission authority per partition. It does not mean one global process, one physical database table, one mutable object passed everywhere or a single linear lifecycle for all effect kinds. + +## 3. Architectural decisions + +### 3.1 Ownership + +- The offline core continues to own canonical actions, proof validity, attenuation, assurance and evidence verification. It acquires no I/O, clock reads, live budgets or recovery store. +- The existing `auths-gateway-kernel` is the default owner of pure managed-operation transition and outcome predicates. Preserve its bounded explicit-input and translation constraints. Consolidate its existing order/transition/recovery relationships; do not keep two predicates that can independently authorize the same transition. +- `auths-gateway` owns effect compilation, sealed stage types, live admission, custody, transport and journal orchestration. Store adapters implement atomic persistence, not independent lifecycle rules. +- `auths-stores` remains the durable adapter boundary. Existing `auths-lifecycle` identities and store acknowledgement mechanisms must be assessed for reuse before adding analogous types. +- Bindings expose Rust construction, verification, transition and projection APIs. They do not independently hash an effect, decide a recovery transition or infer success. + +A different package placement requires a written ownership comparison and ADR before changing dependencies. Moving files is not an acceptance criterion. No new crate is required by this spec. + +### 3.2 Shared model, concrete protocols + +Use a closed protocol sum with typed data for **provider acquisition**, **recipient disclosure**, and **provider mutation**. These share effect identity, revision checks, accounting, durable entry and immutable evidence rules. Their specific observations and terminal claims remain distinct. + +A provider name, arbitrary operation string, callback, runtime plugin or untyped map MUST NOT select hidden authorization or recovery behavior. Provider paths, mappings and supported observations remain reviewed, digest-bound recipe data. A new gateway capability must satisfy the repository abstraction process. + +The implementation must write an abstraction case comparing at least the existing mutation path, AP070 acquisition/release path and lifecycle reference model, including divergent semantics. Compare two maintained mutation recipes with different recovery capabilities. If the normal extraction threshold is not met, an ADR must justify the narrowly identical mechanism. This is an implementation deliverable, not permission to skip evidence gates. + +### 3.3 Direct cutover + +This is prelaunch. Replace affected formats and call sites directly, reject obsolete disposable state, and remove superseded production logic. Do not add migration readers, dual journals, compatibility flags or a runtime switch between old and new semantics. Retain independent test oracles and useful historical evidence with their original scope. + +## 4. The bound effect contract + +### 4.1 Immutable description and identity + +Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. The concrete name may reuse an existing type after the ownership comparison. Each semantic field has exactly one authority and one encoding. + +| Dimension | Bound facts and trusted source | +| --- | --- | +| Operation | Operator/admission namespace, partition epoch and logical operation ID. These determine the replay/conflict lookup key. | +| Authority | Native action commitment, selected actor/branch identities, authorization context/configuration identity, authority scope and the relevant grant/evidence dependencies. | +| Scope | Engagement/task scope when present, exact resource identity, acting recipient/executor audience and holder/channel restrictions. No task-free value may silently match a task-bound one. | +| Compilation | Profile identity, recipe digest, compiler semantic version and exact noncredential transport description. | +| Installation | Connection identity, account/subject binding, credential generation, installation/configuration version and required qualification policy. | +| Information flow | For acquisition: source/projection and response limits. For disclosure: exact recipient, channel binding, source-effect relationship, permitted projection and byte ceiling. | +| Accounting | Typed reservation set: partition, counter key, unit, amount, window and any conservation relation. Read calls, bytes and write count are not interchangeable units. | +| Evidence and recovery | Approval requirements, freshness dependencies, observation/reconciliation contract and its identity. A provider idempotency declaration includes scope and retention assumptions. | + +Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. + +The replay key MUST NOT include the action/effect digest as its only differentiator: the same logical operation ID with changed binding is a conflict, not a fresh operation. Exact replays return existing state; they never mint another capability. A newly chosen operation ID cannot evade a signed approval's binding or the shared budget. + +### 4.2 Compilation and approval without circular commitments + +1. Verify the caller's canonical action under installed trust and policy. +2. Compile only that verified action and pinned installation/recipe into a candidate effect. All security-relevant provider bytes and recipient policy are now fixed. +3. Construct the canonical binding and `EffectId`, including the compiler output commitment. +4. Render review data from that same bound value. Obtain required approval over its exact identity and the approved scope/deadline. +5. Validate approval separately and construct `ApprovedEffect`. Do not include the approval signature in the value it signs. +6. Admit and execute only this approved value after fresh checks. Recompilation under changed recipe, account, configuration, recipient or payload yields a different binding and requires new authorization/approval as applicable. + +The recipe compiler cannot literally consume its own completed output. “Same description” means one authoritative semantic input and a sealed deterministic compilation result, both bound by one identity. It does not require cyclic hashes or trusting a caller-supplied compiled request. + +Broad delegated authority and exact human approval remain different facts. Approval can narrow an effect; it cannot create missing resource authority. A bounded-upfront approval is a separate typed mode with explicit scope and expiry. +For acquisition and disclosure it can approve the source/projection, recipient and +limits before the content is fetched; the exact disclosure binding is finalized +after acquisition and checked against that consent. It cannot be used to approve +a mutation that requires exact human confirmation. Its mere presence must not satisfy an exact-approval requirement. + +### 4.3 Closed transport and custody + +The private bound value contains the exact method, origin/path/query, noncredential headers, media type, body and closed observation plan. Transport accepts a stage-sealed effect capability, not a second set of URL/body/recipient parameters. Credential injection may fill only the approved credential slot for the bound connection/account/generation. Credentials themselves never enter effect serialization, public commitments, receipts, bindings or agent memory. + +Redirects, automatic retries, endpoint substitution and middleware body/header mutation cannot silently change the bound send. Deny unsupported behavior. Idempotency and correlation values are generated by the native compiler and included in the binding. Byte equality means the application request after deterministic compilation, excluding explicitly specified transport framing and secret credential insertion; it is not equality of TLS packets. + +Credential-bearing preflight, account checks, provider observations and recovery +reads must also be bound, bounded ancillary acquisition operations derived from +the approved recipe. Account for their entry and limits explicitly; they must not +be invisible I/O outside the model. Acquiring those bytes does not authorize +disclosing them to the agent. + +A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. + +### 4.4 Stage types and serialization + +The intended progression is: + +```text +VerifiedAction -> BoundEffect -> ApprovedEffect -> ReservedEffect + -> ProviderEntryPermit or DisclosureEntryPermit -> Evidence +``` + +Private constructors enforce the local boundary. Entry permits are neither cloneable nor deserializable. Persisted records are facts, not executable capabilities; restoring a record cannot reconstruct a lost send permit. A portable binding may be decoded as data but must pass native validation before obtaining any sealed type. + +Remote permits and multi-executor dispatch are outside this milestone. Do not imply that a Rust type alone prevents a malicious process from bypassing a deployment boundary. + +### 4.5 Canonicalization and privacy + +Reuse repository canonical codecs and domain-separated commitments. Freeze the selected schema, ordering, optional/absent distinction, integer range, duplicate handling and semantic identities in native fixtures before cutting over callers. No Python/TypeScript hash implementation may become an alternate authority. + +The complete effect contains private data. Its ordinary digest and correlation identifiers are not automatically safe for public receipts: low-entropy payloads can be guessed. Define separate private audit and redacted public projections. Use the existing protected-commitment mechanism where suitable; public content commitments must be hiding and scoped. Redact Debug/error output, zeroize retained sensitive buffers where supported, and put any persisted private payload/evidence behind the protected journal's access and retention policy. + +## 5. One operation and recovery model + +### 5.1 One transition owner + +Specify a total bounded reducer conceptually equivalent to: + +```text +transition(current_state, typed_command, verified_facts, transaction_time) + -> refusal | proposed_state_and_accounting_delta +``` + +The reducer has no I/O, ambient clock, provider callbacks or arbitrary JSON interpretation. The store derives authoritative state and capacity inside its transaction. It persists the reducer result, revisions, accounting delta and required audit event atomically before acknowledging the transition. Only the runtime's validated durable acknowledgement can mint an external-entry capability. + +`verified_facts` are stage-specific verified values, not caller assertions. Evidence acquisition can happen before a transaction; freshness and all relevant dependencies must still be checked at its linearization point. The operation's fixed identity and binding never change. + +Use protocol-specific typed states beneath a shared operation header. An acquisition followed by disclosure consists of linked operations with distinct authority and charges. A provider GET is not content delivery. A provider response is not observed mutation success. + +### 5.2 States and transitions + +The following names define semantics, not mandatory wire spellings: + +| Transition | Preconditions | Durable result and permission | +| --- | --- | --- | +| Admit | Exact approved effect; current authority/configuration/epoch; capacity; unused replay key. | Store binding, reservation and replay claim atomically. No external entry yet. | +| Refuse before entry | No entry grant exists; refusal is valid under the protocol. | Terminal not-entered fact. Preserve replay identity. Release only explicitly releasable capacity; spent invocation units may remain spent. | +| Grant provider entry | Reserved acquisition/mutation; fresh native authority and approval; unchanged installation; current revocation/version; exact transport binding. | Persist unique entry grant and required charge before returning one provider permit. | +| Record provider response | A matching provider entry grant exists; bounded authenticated transport evidence. | Add response fact. Never infer effect solely from HTTP status. | +| Record uncertain provider outcome | Entry grant exists but completion cannot be established. | Retain charges and unknown outcome. No automatic send retry. | +| Admit disclosure | Authorized source acquisition and protected content exist; current recipient/scope/channel and projection; disclosure capacity. | Reserve exact release bound to source, protected content commitment and recipient. No delivery yet. | +| Grant disclosure entry | Fresh release authority and authenticated recipient; exact bytes, channel and commitment; active reservation. | Persist irreversible release charge and unique grant before returning one delivery permit. | +| Record acknowledgement | Authenticated ACK matches effect, delivery instance, recipient/channel and exact protected bytes. | Add acknowledged fact; never create new delivery authority. Exact repeated ACK is idempotent. | +| Recover without ACK | Release entry may have occurred. | Retain delivery-unknown and all relevant charges. No automatic redelivery or refund. | +| Observe/reconcile | Separate current permission for bounded recovery read; exact operation/recipe/evidence binding. | Add supported evidence or leave unknown. Never issue a mutation permit. | +| Revoke | Authenticated revocation under the same ordered admission authority. | Prevent later grants; retain earlier grants, charges, identity and historical evidence. | + +Entry-granted records mean permission was durably handed out and external entry may have happened. They do not prove that a socket send occurred. If the process dies after the grant but before send, the conservative result is still unknown. A missing response cannot be converted to not-entered. + +```mermaid +stateDiagram-v2 + [*] --> Reserved: atomic admission and reservation + Reserved --> NotEntered: close before any entry grant + Reserved --> EntryGranted: persist one grant + EntryGranted --> Unknown: crash or no conclusive result + EntryGranted --> ResponseRecorded: provider transport evidence + EntryGranted --> Acknowledged: disclosure ACK + ResponseRecorded --> Observed: separate supported observation + Unknown --> Observed: sufficient reconciliation evidence + Unknown --> Acknowledged: late exact disclosure ACK +``` + +This diagram is a projection of a typed state model. `ResponseRecorded` belongs to acquisition/mutation, `Acknowledged` to disclosure. `Observed` carries a typed claim such as matching state or linked provider evidence; it is not a universal success state. A matching observation may coexist with unresolved causal attribution; it must +not erase uncertainty, release charges or imply permission to retry. Invalid +cross-protocol transitions must be unrepresentable or refused by the sole reducer. + +### 5.3 Retry and recovery contract + +For this milestone, provider-entry and disclosure-entry permits are one-use, and replay never reissues them. The model distinguishes re-running pure verification, retrying an uncommitted transaction, retrieving existing state, repeating an authorized observation, and repeating an external effect. + +- A transaction proven not committed may be attempted again under the same replay identity. +- An ambiguous commit requires loading the authoritative journal before doing anything else. Unavailable state fails closed. +- A durable reservation with no entry grant may progress only through fresh authorization and an atomic single-winner grant; reopening it does not bypass approval or capacity checks. +- Once an entry grant exists, restart must not reissue it, including when no response or ACK exists. +- Provider idempotency may improve provider guarantees but does not override the default prohibition on Auths re-entry. Any future retry mode requires an explicit versioned protocol and evidence for key scope, retention, fencing and late requests. +- Late valid response/ACK evidence can refine an unknown outcome. Revocation or expiry must not erase legitimate history or prevent recording a previously authorized delivery's exact ACK. Recording history confers no current execution authority. +- Read-only recovery requires its own bounded authority and accounting. It cannot borrow a revoked writer's proof, use an expired approval as current authority, acquire broader credentials or change the original actor attribution. + +### 5.4 Accounting + +At every committed revision, for each capacity key and unit: + +```text +available + held + consumed = allocated +held >= 0; consumed >= 0; allocated <= authorized ceiling +``` + +If capacity windows or allocation semantics use a different existing algebra, provide the exact equivalent conservation relation and proof. Never mix units or double-count one operation in multiple categories. Unknown effects retain their held/consumed allocation. Read acquisition count, provider attempts, response-byte reservation, disclosure bytes and mutation units have explicit charging points. + +The reducer owns reserve/consume/release transitions. Store adapters cannot silently release capacity on timeout, lease expiry, cancellation, garbage collection or process death. Only an explicit protocol transition with evidence of no entry may release a releasable reservation. Conservative over-accounting is permitted and must be visible; accidental refunds are not. + +### 5.5 Revocation, time and configuration ordering + +Entry grants and revocation must have one documented linearization order. A revocation committed first blocks the grant; a grant committed first may still be exercised. Do not promise recall of already released data or an unfenced remote request. Disclosure has a later, independent gate even after provider acquisition was granted. + +Use the existing deployment clock boundary and sample transaction time after acquiring the relevant lock/transaction. Bound lock duration and native verification work. Distinguish signed event time, evidence observation time, verifier evaluation time and monotonic elapsed time. Re-evaluation does not refresh old evidence. + +Re-run the full native verifier, or use a mechanically justified equivalent dependency check, at the final authorization boundary. Checking only action/grant expiry is insufficient when identity/status/assurance/approval/observation evidence can age independently. Bind the selected branches and evidence to the projected effect: another valid threshold subset cannot silently license previously derived facts. + +Connection, trust, recipe, policy, qualification and admission epoch changes must be ordered with entry or fenced under a demonstrated version protocol. A mutable value checked before waiting for the lock is insufficient. Exact human approval must remain eligible at entry. If durable consent has a distinct validity/revocation contract, make that a separate mode with explicit evidence; never discard approval dependencies accidentally. + +## 6. Journal and persistence contract + +There must be one logical journal owner for operation identity, reservation, entry grants, protocol outcomes and replay tombstones. Multiple physical records are acceptable only when their safety-critical changes commit atomically. An effect must not acquire two independent mutable truths in a task ledger and an attempt ledger. + +For both file and PostgreSQL adapters, specify and exercise: + +- lock/CAS scope, expected revision, epoch and conflict behavior; +- atomic operation creation plus all counter updates; +- atomic entry grant plus its audit event and consumed/held accounting; +- file/data/directory synchronization or database commit acknowledgement required before capability publication; +- torn-write, partial-batch, connection-loss and ambiguous-commit recovery; +- decoding bounds, illegal-state rejection and schema mismatch refusal; +- replay/tombstone retention through the full authority and late-evidence horizon; +- bounded garbage collection that cannot resurrect an expired claim or erase unresolved accounting. + +Existing file and PostgreSQL behavior must not regress. In-memory adapters are test tools and do not establish durability. File conformance establishes the stated local-filesystem assumptions, not distributed fencing or power-loss behavior on every platform. + +Whole-store rollback is outside ordinary crash recovery. Keep existing commissioning/generation-floor defenses, bind operations to the admitted epoch, and fail closed when an installed anti-rollback check fails. Where an independent monotonic anchor is absent, explicitly state that restoring all protected state is outside the guarantee. Do not claim that a revision stored in the same restored database detects its own rollback. Building a new consensus service is outside this specification. + +Persist sensitive reconstruction data only if necessary and protected. If private content is intentionally not retained, recovery may remain unresolved; it must not refetch or redeliver to manufacture certainty. + +## 7. Central implementation surfaces + +The implementation should expose a small set of Rust-owned operations, with exact names chosen during the source mapping: + +| Surface | Contract | +| --- | --- | +| Compile/review | Produce canonical bound effect and human review projection from verified action and pinned installation. No reservation or I/O. | +| Approve/validate approval | Bind exact effect or explicit bounded consent. No entry permission. | +| Admit | Atomic binding/replay/reservation transaction; return existing state on exact replay. | +| Grant entry | Fresh ordered authorization and one durable provider/disclosure grant; return one-use capability only after acknowledgement validation. | +| Record evidence | Validate exact response, ACK or observation binding and apply the sole transition relation. | +| Recover/inspect | Return truthful current facts and permitted recovery actions. Never implicitly execute a write or deliver content. | +| Project receipt/activity | Native redacted projection of journal facts with evidence provenance and limitations. | + +Centralize clocks, canonicalization, effect comparisons, charge transitions and receipt claims at these owners. Do not scatter fixes across Python presenters, HTTP routes, CLI handlers or recipe branches. UI and SDKs must consume the same native review and state projection, including unknown and not-entered distinctions. + +For the AP070 read demonstration, remove independent Python decisions for the shared contract in the same cutover. Provider-specific reference code may remain outside the shared gateway; production managed I/O must use approved data-only capabilities. Inventory every retained weaker application-owned path and label its claim accurately. Do not turn a demo adapter into a runtime callback loaded by the gateway. + +## 8. Hard limits and stable failures + +Before the first behavioral cutover, commit a limit/encoding table naming the existing constant or new justified finite bound for every public collection and byte buffer. Preserve current tighter limits, including native proof/action bounds, 16,384-byte compiled write bodies, 34 counter entries and the 64-step gateway driver bound unless an explicitly reviewed requirement changes them. + +Cover: effect metadata; payload/proof/context bytes; header/path sizes; resource and recipient counts; reservation keys; evidence dependencies; per-operation journal events; ACKs; observation attempts; lock/transaction deadlines; recovery scans; private retained bytes; and public receipt size. Decode and reject over-limit inputs before unbounded allocation. Do not solve exhaustion by silently deleting replay or unknown-outcome records. + +Errors distinguish malformed/noncanonical input, unsupported schema/protocol, unauthorized effect, expired/stale evidence, changed binding, replay, conflicting operation, exhausted capacity, invalid transition, unavailable/corrupt store and unresolved outcome. Map them consistently across Rust and bindings without exposing proof bodies, provider content or credentials. Preserve existing codes where semantics are unchanged; version intentional changes. + +## 9. Required invariants + +| ID | Invariant | +| --- | --- | +| E01 | Every external request and disclosure derives exclusively from one native-verified, compiled and approved bound effect. | +| E02 | Changing any security-relevant binding dimension is rejected or creates a newly authorized effect; no stage reconstructs a weaker interpretation. | +| E03 | Same operation key plus same binding is replay; same key plus different binding is conflict. Neither creates another entry. | +| E04 | Human approval, native resource authority and live admission are separate required facts. | +| E05 | Bindings and UI consume native canonical identities and projections; public data does not disclose private content or reusable authority. | +| R01 | One reducer owns allowed state transitions and accounting; every maintained managed path calls it. | +| R02 | Durable reservation and the entry grant precede their corresponding external boundaries; failed/ambiguous persistence returns no capability. | +| R03 | At most one entry capability is issued per effect boundary; permit loss, replay and restart cannot mint another. | +| R04 | Accounting is conserved under concurrency, errors, revocation, restart and unknown outcomes. | +| R05 | Acquisition, disclosure, provider response, acknowledgement and observation remain distinct facts. | +| R06 | Unknown cannot become not-entered, refunded or retryable from elapsed time or missing evidence. | +| R07 | Revocation, configuration and entry follow the stated transaction/fencing order; time is evaluated at that boundary. | +| R08 | Evidence is immutable once recorded; late evidence may refine uncertainty only for the exact original operation. | +| R09 | Recovery has explicit current read-only authority and preserves original effect attribution. | +| R10 | Restored state and malformed/obsolete records cannot bypass the declared epoch, retention or durability assumptions. | + +## 10. Executable acceptance matrix + +All rows require reproducible artifacts, expected journal state, expected external calls, actual result, exact revision and limitations. Source code or a passing compilation alone is not behavioral evidence. + +| Case | Required scenario and assertion | +| --- | --- | +| A01 | Compile/review/approve/execute the same mutation. Assert exact request bytes and one identity at every boundary. | +| A02 | Independently mutate action, actor, scope, recipient, resource, recipe, URL/body/header, account, credential generation, verifier configuration, epoch and approval. Refuse before the applicable custody/entry boundary. | +| A03 | Replay identical operation concurrently and after restart; alter its effect with the same ID; try a new ID with the old exact approval. At most one grant, explicit replay/conflict, conserved counters. | +| A04 | Race independent operations for the final count/byte/sum capacity. Exactly the permitted total succeeds on both durable adapters. | +| A05 | Crash before commit, after reservation, after entry persistence but before send, during send, after response/ACK receipt but before persistence, and after persistence but before returning to caller. Reopen and verify state, charges and no duplicate effect. | +| A06 | Inject file sync/rename failure, partial batch and database ambiguous commit/CAS conflicts. No unacknowledged capability; deterministic bounded recovery. | +| A07 | Acquire content then revoke before disclosure. Provider entry may be recorded; recipient receives no bytes. Charges reflect the separate boundaries. | +| A08 | Lose disclosure ACK after actual send; crash/reopen and retry. No automatic redelivery; bytes stay charged; exact late ACK refines history. | +| A09 | Replay/substitute ACK for another operation, channel, recipient, content, instance or source effect. Refuse without changing history/accounting. | +| A10 | Provider timeout, response loss, denied response, successful HTTP response and matching read-back produce different truthful claims. A match alone is not causal proof. | +| A11 | Reconciliation finds zero, multiple, unrelated or incomplete matches. Outcome remains unresolved. A supported exact link adds evidence without a new write. | +| A12 | Race revocation and connection/configuration changes with entry and disclosure. Histories match the documented linearization rule. | +| A13 | Advance time while waiting for the lock; independently expire human evidence, observer evidence and resource authority. Re-evaluation does not refresh signed event time. | +| A14 | A threshold proof remains authorized but its selected branches/evidence change. Earlier projected authority cannot be silently reused. | +| A15 | Recovery actor differs from original actor; original permission is expired/revoked. Only separately authorized bounded observation is possible; attribution remains unchanged. | +| A16 | Cross-task, cross-recipe and cross-partition substitutions use otherwise valid proofs and identical resource names. No mixed authority or shared-state aliasing. | +| A17 | Capture logs, errors, public receipts and binding output with sentinel secrets/private content. No sensitive bytes or guessable public content commitments escape. | +| A18 | Canonical valid, malformed, duplicate, noncanonical and limit/limit-plus-one cases agree across Rust and every affected public binding. | +| A19 | Differential corpus covers two mutation recipes with distinct recovery capabilities, plus acquisition/disclosure, against retained references. No provider-specific branch enters the shared owner. | +| A20 | Model-generated event sequences and concurrent histories exercise every transition and illegal edge. Formal/refinement artifacts identify the actual shipping pure predicates and assumptions. | +| A21 | Replay retention, terminal tombstones, stale cache/configuration and supported rollback-floor failures cannot resurrect entry authority. Unsupported whole-store rollback is explicitly excluded. | +| A22 | Installed packages and native runtime execute the complete single-human/single-agent read, disclosure, exact write and observation journey; UI distinguishes grant, response, ACK, observation and unknown. | + +Use external call counters and process failpoints, not only mocked return values or tests asserting the implementation's own intermediate flags. Exercise real local sockets, process restart and the maintained PostgreSQL fixture. Provider-specific live qualification remains a separate claim; no cloud credential should be necessary for the local foundation journey. + +## 11. Formal and performance evidence + +Preserve current linked gateway order/transition/recovery evidence. Update translated/generated Rust-to-Lean obligations and Kani/property coverage when their source or semantics change. Required properties include exact-binding preservation, single grant, conservation, no unknown-to-retry transition, immutable evidence and revocation ordering. Do not label a separately handwritten model as a proof of shipping Rust. + +Publish a bounded mapping from the pure transition proof to the runtime/store adapter assumptions. Filesystem durability, database isolation, authenticated recipient behavior and provider observations remain explicit assumptions tested through conformance/fault injection. + +Measure native verification, compilation, transaction/lock duration, memory bounds and recovery scan costs for each representative path. Optimization must retain the same semantics and differential evidence. A second verification under a lock must have a finite work/deadline bound; do not replace full dependency validation with a partial expiry shortcut merely to improve latency. + +## 12. Implementation order and exit gates + +| Phase | Deliverable | Exit gate | +| --- | --- | --- | +| P0: map and decide | Baseline source/consumer inventory; ownership ADR and abstraction case; canonical field, limit and state tables; retain/replace list. | Every existing invariant and production/reference owner accounted for. No implementation built on an unresolved competing owner. | +| P1: bind one mutation | Native immutable effect, review/approval, deterministic request compilation and thin binding entry points. | E01–E05 on one maintained mutation path; adversarial binding corpus authored; direct cutover removes duplicate reconstruction. | +| P2: central durable mutation | Sole reducer/journal for reservations, entry, response, unknown and observation, with file/PostgreSQL adapters. | R01–R10 for mutation; restart/concurrency/fault evidence implemented; no dual task/attempt authority. | +| P3: acquisition and disclosure | Typed read/release protocol in the same owner, explicit source/recipient binding and ACK handling; thin AP070 consumer. | Independent read/disclosure charges and permissions; ACK loss/revocation/replay cases implemented; Python stops deciding shared transitions. | +| P4: close integration and evidence | Second recipe differential cases, installed bindings, full local journey, native projections, formal links and final hosted checks. | A01–A22 addressed with exact-revision evidence, documented assumptions and no unsupported claims. | + +Commit coherent changes along the way. Keep a durable acceptance ledger separating implemented, source-tested, executed, externally qualified and blocked. Do not mark a phase complete merely because its types exist or the happy path works. + +Observe CI only after the specification's implementation is complete, as requested by the user. Follow the repository's GitHub-first policy: construct necessary generated artifacts locally; do not run duplicate broad local suites by default. Once implementation, fixtures and documentation are complete, push the finished branch, inspect required hosted workflows on that exact revision, repair failures, and repeat until the required evidence is resolved. Report external blockers rather than weakening checks or pretending a skipped job passed. + +The foundation is not complete until required behavioral and hosted evidence passes. Delaying CI observation is not a waiver of verification. No merge or deployment is authorized by this spec. + +## 13. Completion and handoff boundary + +Done means both central contracts own the maintained paths, obsolete managed interpretations are removed, interfaces and bindings are updated, source-linked formal and operational evidence are current, and the acceptance ledger contains actual results. The result must be a reviewable implementation with a concise explanation of changed behavior, tests and remaining deployment assumptions. + +Only after this foundation is closed should multi-agent delegation add participant trees and ancestor budget allocation on top. Those features must consume the established effect and recovery contracts instead of creating their own parallel journals, approval identities or retry rules. + +## References + +- [Repository contract](../../AGENTS.md). +- [Profile and domain abstraction boundary](../target-state/PROFILE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md). +- [AP-SPEC-026: reservation and execution semantics](0026-reservation-and-execution-state-semantics.md). +- [AP-SPEC-057: exact-action evidence program](0057-evidence-program-for-the-exact-action-boundary.md). +- [AP-SPEC-063: generalized gateway](0063-generalized-gateway.md). +- [AP-SPEC-066: gateway qualification](0066-production-gateway-polish-and-recipe-qualification.md). +- [AP-SPEC-070: employee read delegation](0070-google-employee-agent-delegation-demo.md). +- [ADR 0012: credential-isolated gateway](../adr/0012-declarative-credential-isolated-gateway-boundary.md). +- [ADR 0013: recipe capabilities and budgets](../adr/0013-recipe-capabilities-and-sum-budget.md). +- [Existing gateway abstraction case](../research/domains/abstraction-cases/0007-declarative-credential-isolated-request.md). From 43832adc14dc77db1ebfda1cbf40b193be0fb261 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:31:50 +0000 Subject: [PATCH 002/136] docs(gateway): define AP074 ownership and acceptance ledger --- ...017-bound-effect-and-recovery-ownership.md | 63 ++++++++++ docs/plans/0074-implementation-status.md | 88 ++++++++++++++ .../0009-bound-effect-and-recovery.md | 110 ++++++++++++++++++ 3 files changed, 261 insertions(+) create mode 100644 docs/adr/0017-bound-effect-and-recovery-ownership.md create mode 100644 docs/plans/0074-implementation-status.md create mode 100644 docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md new file mode 100644 index 000000000..17bb9273f --- /dev/null +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -0,0 +1,63 @@ +# ADR 0017: One bound effect and gateway recovery owner + +- Date: 28 October 2026 +- Status: Implementation decision for AP-SPEC-074; evidence gates remain open + +The gateway already owns production provider writes. AP070 separately decides +read admission, release and conservative accounting in Python/SQLite. The +lifecycle package has useful preparation and durable-acknowledgement contracts, +but its profile states include partial effects and proven non-effect with +different recovery semantics. None can be treated as interchangeable merely +because each has a journal. + +Keep pure managed transitions in `auths-gateway-kernel::transition`, orchestration +in `auths-gateway::submit`, and the logical journal in `auths-gateway::store`. +Extend those owners; do not introduce a parallel executor or task ledger. +`auths-stores` implements durable PostgreSQL mechanisms. The existing file +adapter stays beside the gateway until moving it has a concrete dependency +benefit. Store adapters never decide provider truth or refund policy. + +The gateway owns the canonical bound effect, built from the native sealed action +and closed recipe output. It includes selected branch/evidence identity, trust, +scope, installation, typed charges and protocol. Exact approval signs that +identity after compilation; the signature is not an input to its own identity. +The stored effect is data. Only a successful new durable entry transition yields +a non-cloneable, non-deserializable, consumed transport capability. + +Retain lifecycle identity/commitment helpers only where their exact contract +matches. `PreparationBindingV1` is not reused as the effect: its optional +connection/evidence and single principal do not encode disclosure/source/channel, +selected native branches, exact compiler output or typed reservation units. +`ProviderCallAuthorizationV1::from_durable(&DurableTransitionV1)` illustrates +acknowledgement validation but a borrowed acknowledgement can be reused. AP074 +must consume the newly applied acknowledgement exactly once. Do not change +reference consumers' lifecycle meaning to make these APIs fit. + +The extraction is limited to identity preservation, finite typed reservation +arithmetic, single grant and immutable evidence. This is a domain-independent +product mechanism; the smaller-than-three-production-consumer exception is +justified by these exact properties, not inferred provider similarity. Provider +result interpretation remains in closed reviewed recipe declarations and +independent references. The [comparison case](../research/domains/abstraction-cases/0009-bound-effect-and-recovery.md) +defines divergences and the evidence still required before promotion is complete. + +File and PostgreSQL admission must order configuration/revocation with entry. +Read-and-CAS of just the attempt does not fence a concurrently changed connection. +The transaction derives current state, samples the deployment clock after lock +acquisition, validates full native authority and pinned dependencies, and commits +the grant and charges before acknowledgement. A committed revocation blocks later +grants; an earlier grant may still be exercised. Process-local in-flight counters +alone do not establish the multi-process order. + +Acquisition, disclosure and mutation are closed typed alternatives. Ancillary +credential/account/preflight/observation reads are linked bounded acquisitions. +Each disclosure has its own recipient authority, source binding and charge. +An ACK records recipient evidence and never creates another delivery grant. +State-match observation may coexist with unknown causation. + +Cut over directly and reject obsolete disposable journal formats. No legacy +decoder, conversion, dual-write path or compatibility switch. Preserve rollback +floors and PostgreSQL transaction rollback; these are current safety semantics. +Retain reference implementations and original formal evidence only with accurate +scope. Acceptance requires A01–A22, updated source-linked proofs and hosted CI; +this ADR itself is not evidence that those gates passed. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md new file mode 100644 index 000000000..c714b8e53 --- /dev/null +++ b/docs/plans/0074-implementation-status.md @@ -0,0 +1,88 @@ +# AP-SPEC-074 implementation and evidence ledger + +## Durable goal + +Implement all of [AP-SPEC-074](../specs/0074-bound-effects-and-recovery-state-machine.md) +in this checkout, on `codex/effect-recovery-foundation`. Finish the immutable +native bound effect and the gateway's sole recovery/transaction owner, including +mutation, bounded acquisition, separate recipient disclosure, exact approval, +fresh entry authorization, immutable evidence and truthful native projections. +Cut maintained consumers over directly; remove competing managed decisions. +Preserve the native verifier, reviewed recipe compiler, conservative recovery, +durable adapter guarantees and source-linked formal claims. + +Complete P0–P4 and A01–A22 with actual transport, process restart, file and +PostgreSQL concurrency/fault evidence, differential recipes, installed bindings, +formal/refinement links and bounded performance measurements. Commit coherent +changes. Finish source, fixtures and documentation before pushing explicitly to +`origin codex/effect-recovery-foundation`, opening a draft PR against main and +observing required hosted workflows on the exact head. Repair failures; do not +merge or deploy. Local generation needed to construct artifacts is permitted; +do not duplicate hosted build/test/lint/formal gates before the first push. + +Never touch the paused AP073 checkout or import its unfinished implementation. +Do not expand participant trees, federation, token systems or agent delegation. +No stage is complete merely because types, documentation or a happy path exist. + +## Baseline and working record + +- Implementation started 28 October 2026 from clean HEAD + `ec7defb3dbcee1fdcc2839989bdbc4d9110a912d` (specification/handoff commits over + the specified main baseline `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b`). +- Read repository contract, mandatory abstraction plan and full specification. +- No AP073 files inspected or changed. No subagents dispatched. +- Existing source inspected: native sealed action, gateway verifier/compiler, + submission driver, transition/recovery leaves, file/PostgreSQL attempt store, + lifecycle preparation/acknowledgement contracts, AP070 admission/executor/receipt. +- Verification: no tests, builds, lint, formal gates or hosted workflows run yet. + +## Phase gates + +| Phase | State | Outstanding gate | +| --- | --- | --- | +| P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | +| P1 | Pending | Native binding, approval and complete first mutation cutover | +| P2 | Pending | Explicit reservation/grant reducer, atomic fencing, both adapters | +| P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | +| P4 | Pending | Differential/local journey, installed bindings, formal links, CI | + +## Acceptance ledger + +`Authored` means scenario source exists, not that it passed. `Executed` requires +the exact tested revision and a reproducible result. External qualification is a +separate claim. No AP074 acceptance case is currently executed or qualified. + +| Case | Required evidence | Implementation / authored / executed | Limitation or next work | +| --- | --- | --- | --- | +| A01 | Same bound identity and exact request across review/approval/send | Pending / no / no | Cut over mutation | +| A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | +| A03 | Concurrent/restart replay, conflict, approval reuse | Pending / no / no | Full binding comparison | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Pending / no / no | Atomic journal admission | +| A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | +| A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | +| A08 | ACK loss, restart, no redelivery, late ACK | Pending / no / no | Typed ACK protocol | +| A09 | ACK substitution in every dimension | Pending / no / no | Authenticated exact ACK | +| A10 | Timeout/denial/response/state-match distinction | Pending / no / no | Native projection | +| A11 | Missing/multiple/unrelated/incomplete reconciliation | Pending / no / no | Bounded independent observation | +| A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | +| A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | +| A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | +| A15 | Recovery actor differs; original authority revoked | Pending / no / no | Separate recovery authority | +| A16 | Cross-task/recipe/partition substitution | Pending / no / no | Scope and epoch binding | +| A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | +| A18 | Canonical/malformed/duplicate/limit binding corpus | Pending / no / no | Native codecs/thin wrappers | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | +| A20 | Generated histories and shipping predicate refinement | Pending / no / no | Update linked artifacts | +| A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | +| A22 | Installed single-human/single-agent full journey/UI | Pending / no / no | Native runtime and local sockets | + +## Deployment assumptions retained + +Durability relies on acknowledged filesystem sync/rename and PostgreSQL commits. +Neither an in-memory test nor a Rust permit establishes malicious-process +isolation. Provider state matching does not establish exclusive causation. +Recipient authentication is a transport assumption. Whole-store rollback is +outside the guarantee without an independent monotonic anchor; a restored +database cannot attest to its own freshness. No new live-provider qualification +or deployment claim is made by AP074 source work. diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md new file mode 100644 index 000000000..c719420d3 --- /dev/null +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -0,0 +1,110 @@ +# Case 0009: Bound effect identity and durable recovery + +Status: AP074 implementation contract; behavioral and performance evidence pending. +Owner: product gateway/kernel, per [ADR 0017](../../../adr/0017-bound-effect-and-recovery-ownership.md). + +## Baseline consumers and dispositions + +| Surface | Current semantics | Disposition | +| --- | --- | --- | +| Native `VerifiedAction` | Canonical action, proof/context/plan, selected branches and evidence | Retain sole native authority source | +| Gateway `verify_detailed` / `VerifiedCommand` | Native projection, bounds, compiler output | Consolidate immutable effect here | +| `recipe.rs` / kernel `construct` | Closed deterministic bytes, credential slot, observation plan | Retain compiler; bind entire output | +| `submit.rs` / kernel `order` | Write ordering, credential/preflight reads, replay observation | Extend current driver; make all external entries explicit | +| Gateway store / kernel `transition` | Claim and counters atomic; `Attempting` conflates reservation and entry | Replace conflation with explicit durable grant | +| Kernel `recovery` / `outcome` | Response/state match/provider link are distinct; no lost-claim retry | Retain truth and no-retry semantics | +| File attempt adapter | Private files, flock, fsync/rename, batch rollback, CAS | Retain durability; add bounded transactional validation/fencing | +| PostgreSQL gateway records | Atomic batch, byte CAS, commit acknowledgement | Retain mechanism; extend shared transaction boundary | +| Lifecycle `operation` / `sealed` | Preparation commitments, validated store ACK, profile-specific lifecycle | Reference semantics; no second managed gateway owner | +| AP070 `AdmissionStore` / `ProviderAttemptLedger` | SQLite task counters, challenge/release decisions, per-GET records | Remove shared decisions in native cutover | +| AP070 `execute_read` / `ReceiptStore` | Provider-specific fetch, release orchestration, Python receipt claims | Thin consumer of native stages and projections | +| TS `gateway.ts`, Python native runtime, gateway app/admin | Socket/binding routes and views | Expose native construction and state; no local effect hashes | +| AP070 Drive adapter | Metadata/content GETs and provenance checks | Retain independent provider reference; managed I/O uses closed recipe | +| Gateway observer / audit / harness / commissioning | Signed observations, audit facts, local fixtures, bounded operator authority | Update identities and stages atomically; do not bypass commissioning bounds | + +## Comparison and extraction classification + +| Dimension | Stripe refund | Airtable update | AP070 read/disclosure | Lifecycle reference | +| --- | --- | --- | --- | --- | +| Exact action | Verified MCP refund fields | Verified MCP record fields | Verified API read scope | Concrete profile command | +| Request | POST form, derived idempotency | PATCH JSON, no idempotency | Metadata/content GET then recipient bytes | Domain-defined | +| Recovery locator | Response-derived refund ID | Verified record ID | Source effect + protected content + recipient channel | Domain-defined | +| Unknown write recovery | No locator without response | Exact echo at verified locator may add evidence | No automatic refetch/redelivery | May support concrete non-effect proof | +| Approval | Exact compiled mutation | Exact compiled mutation | Bounded upfront consent then exact release binding | Profile-specific | +| Accounting | Count and currency-partitioned sum | Count | Calls, provider attempts/response bytes, disclosure bytes | Reservations/obligations | +| Outcome | HTTP response is not refund proof | Matching state is not causation | Acquisition is not delivery; ACK is recipient fact | Proven partial/applied/not-applied | +| Shared subset | Immutable identity, atomic claim, single grant, immutable evidence | Same | Same | ACK validation pattern only | + +This is an identical-mechanism extraction only for the last row. Provider +semantics and concrete approvals are divergent. No provider tag, callback or +untyped map selects a transition. Smaller primitives alone cannot atomically +couple replay identity, admission capacity and grant publication; the reducer +and journal transaction therefore share one explicit contract. + +The retained oracles are Stripe's reference integration, the Airtable recipe +fixtures and independently expressed AP070 read/release scenarios. Differential +tests must compare observable commands, refusals, charges and evidence, not just +two calls to the new implementation. Source paths include +`examples/stripe-refund-approval/recipe.json`, `demos/airtable-gateway/recipe.json` +and `demos/google-employee-delegation/broker/`. + +## Encoding, limits and state contract + +Canonical effect encoding is native-owned and versioned; duplicate/unknown +fields, noncanonical encodings and unsupported versions fail closed. Private +effect identity is domain separated from public receipt identity. Exact approval +excludes its signature from the value signed. Replay key is namespace, epoch, +logical operation; effect identity is compared after lookup, never used to evade +that lookup. Optional task-free scope has an explicit tag distinct from task scope. + +| Surface | Existing bound retained / AP074 bound to enforce | +| --- | --- | +| Proof / action | Gateway 4 MiB / 64 KiB; native configured bounds also apply | +| Trusted context | Native configured bound; hard maximum 16 MiB, default 2 MiB | +| Effect canonical metadata including compiled output | 65,536 bytes; reject before decoding | +| Namespace / logical operation | Existing canonical ASCII 64 / 128 bytes | +| Resource / recipient / channel / scope label | One per operation, each at most 512 UTF-8 bytes | +| Compiler write body | Existing 16,384 bytes | +| Recipe source / lock | Existing 65,536 bytes each | +| Path / template | Existing 16 segments, 64 nodes, depth 6; bounded final URL 8,192 bytes | +| Headers | Existing recipe maximum two provider headers; total compiled headers at most 8, names 64 and values 1,024 bytes | +| Selected branches/evidence | Native configured collection bounds; total effect encoding bound also applies | +| Reservations | Existing maximum 34 counters; typed units and exact window | +| Provider response / private retained bytes | 65,536 bytes per operation; content not retained by default | +| Pre-entry observations | Existing 4, each native maximum 4,096 bytes | +| Journal record / atomic batch | Existing 262,144 bytes / 64 entries | +| Events / ACK | 64 events per operation / 4,096 canonical bytes per ACK | +| Observation attempts | At most 16 explicitly admitted linked operations | +| Transaction lock deadline | 5 seconds; sample time after lock; refuse on deadline | +| Native verification work | Native configured work-unit limit plus transaction deadline | +| Driver | Existing 64 steps | +| Transport | Existing 15-second maximum; no redirects or write retries | +| Claim contention / file recovery | Existing 32 claim rounds / 8 recovery rounds | +| Recovery scan / public receipt | 1,024 records per page / 16,384 bytes | + +Tighter existing limits win. New limits above are implementation requirements, +not claims that baseline code enforces them. Bounds must be checked before +allocation, including persisted files (baseline `fs::read` checks too late). + +The reducer permits reserve → refuse-before-entry or reserve → unique grant. +Provider acquisition/mutation may then record response or unknown; disclosure +may record exact ACK or unknown. Late exact evidence is additive/idempotent. +No unknown→not-entered, refund, new grant or automatic retry edge exists. +Independent observation adds a typed fact without replacing response/ACK or +original actor. Conserved capacity is available + held + consumed = allocated; +unknown keeps charges. Pre-entry refusal only releases declared releasable units. + +## Cutover and evidence + +Replace affected formats and call sites in one bounded PR. No production +compatibility path, migration or dual journal. Reference models remain explicitly +test-only. Formal work must update translated shipping predicates and refinement +links, not claim a hand-written model proves runtime code. Adapter assumptions +include lock/commit durability, clock trust, recipient authentication and provider +observation integrity; whole-store rollback without an external anchor is excluded. + +Required executable/formal properties are E01–E05 and R01–R10. Measurements must +cover verification, compilation, transaction/lock time, bounded memory and scans +for both recipes and read/disclosure. No measurements have yet been executed. +Actual results and exact revisions belong in the +[acceptance ledger](../../../plans/0074-implementation-status.md). From 005dfd4202b74ac2d639ff1f4388e4e14767cf3a Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:42:10 +0000 Subject: [PATCH 003/136] feat(gateway): bind native mutation compilation and exact approval --- docs/plans/0074-implementation-status.md | 24 +- product/runtime/auths-gateway/src/effect.rs | 906 ++++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 146 +++ product/runtime/auths-gateway/src/engine.rs | 4 + product/runtime/auths-gateway/src/lib.rs | 1 + .../auths-gateway/src/observed_tests.rs | 3 + .../auths-gateway/src/scenario_tests.rs | 2 + 7 files changed, 1081 insertions(+), 5 deletions(-) create mode 100644 product/runtime/auths-gateway/src/effect.rs create mode 100644 product/runtime/auths-gateway/src/effect_native_tests.rs diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c714b8e53..ea0e3493c 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -14,9 +14,11 @@ durable adapter guarantees and source-linked formal claims. Complete P0–P4 and A01–A22 with actual transport, process restart, file and PostgreSQL concurrency/fault evidence, differential recipes, installed bindings, formal/refinement links and bounded performance measurements. Commit coherent -changes. Finish source, fixtures and documentation before pushing explicitly to -`origin codex/effect-recovery-foundation`, opening a draft PR against main and -observing required hosted workflows on the exact head. Repair failures; do not +changes. The user's subsequent instruction on 28 October overrides the initial +push timing: commit the current slice, push explicitly to +`origin codex/effect-recovery-foundation`, open a new draft PR against main, then +continue with incremental commits. Finish source, fixtures and documentation +before observing required hosted workflows on the exact head. Repair failures; do not merge or deploy. Local generation needed to construct artifacts is permitted; do not duplicate hosted build/test/lint/formal gates before the first push. @@ -34,14 +36,26 @@ No stage is complete merely because types, documentation or a happy path exist. - Existing source inspected: native sealed action, gateway verifier/compiler, submission driver, transition/recovery leaves, file/PostgreSQL attempt store, lifecycle preparation/acknowledgement contracts, AP070 admission/executor/receipt. -- Verification: no tests, builds, lint, formal gates or hosted workflows run yet. +- P0 committed as `43832adc`. +- P1 source: canonical private binding, native evidence-selection commitment, + effect-free mutation compilation and separate exact Ed25519 human approval. + Native signature validation does not replace resource authority or live entry. +- Source tests authored for identity mutations, canonical/duplicate/limit cases, + approval substitution/expiry and a real native signed-proof compilation path. +- A targeted native fixture-generation test was started with + `AUTHS_UPDATE_FIXTURES=1`; compilation/generation is pending at this checkpoint. + This local run constructs the required canonical artifact; it is not a broad + pre-push verification run. No hosted workflows observed or formal gates run. +- Existing submission still uses the baseline path. P1 is not closed until the + installed review/approval/admission path replaces it. No new effect can yet be + submitted, and the new sealed compilation API grants no execution authority. ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | -| P1 | Pending | Native binding, approval and complete first mutation cutover | +| P1 | In progress | Finish installed first mutation cutover and native fixtures | | P2 | Pending | Explicit reservation/grant reducer, atomic fencing, both adapters | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs new file mode 100644 index 000000000..5b7d9f5bf --- /dev/null +++ b/product/runtime/auths-gateway/src/effect.rs @@ -0,0 +1,906 @@ +//! Canonical private effect identity and sealed, effect-free compilation. +//! +//! Decoding an [`EffectBinding`] produces audit data, never authority. Only +//! native verification plus the installed recipe and connection can construct +//! a [`BoundEffect`]. Neither type grants custody, provider entry or disclosure. + +use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered, verify_detailed}; +use crate::recipe::ObservationTemplate; +use crate::{ + ClosedActionRead, ClosedProviderRequest, CompiledRecipe, GatewayConnectionDescriptor, + LogicalOperationId, OperatorNamespace, QualificationPolicy, +}; +use auths_connections::ConnectionRecord; +use auths_model::{PortableVerificationResult, Timestamp, TrustedContext, VerificationResources}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use ed25519_dalek::{Signature, VerifyingKey}; +use serde::{Deserialize, Serialize}; +use std::fmt; +use zeroize::Zeroizing; + +/// Only accepted effect binding schema. Old disposable state is rejected. +pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/1"; +/// Maximum private canonical binding or compiler projection bytes. +pub const MAX_EFFECT_BYTES: usize = 65_536; +/// Maximum reservations in one effect, preserving the gateway counter bound. +pub const MAX_EFFECT_RESERVATIONS: usize = 34; +const COMPILER: &str = "auths.gateway-effect-compiler/1"; +const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; +const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; +/// Maximum encoded exact human approval, checked before decoding. +pub const MAX_EFFECT_APPROVAL_BYTES: usize = 4_096; +/// Exact approval cannot remain eligible for more than one hour. +pub const MAX_EFFECT_APPROVAL_SECONDS: u64 = 3_600; + +/// Private audit identity. Do not publish it as a hiding content commitment. +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct EffectId([u8; 32]); + +impl EffectId { + /// Returns private identity bytes for approval and protected journal use. + #[must_use] + pub const fn as_bytes(&self) -> &[u8; 32] { + &self.0 + } +} + +impl fmt::Debug for EffectId { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("EffectId([private])") + } +} + +/// Failure contains neither private content nor caller-supplied text. +#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)] +pub enum EffectBindingError { + /// Empty, oversized, malformed, noncanonical or internally invalid data. + #[error("invalid effect binding")] + Invalid, + /// The schema or compiler semantics are unsupported. + #[error("unsupported effect binding version")] + Unsupported, +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum Scope { + Unscoped, + Task { commitment: [u8; 32] }, +} + +#[derive(Clone, Copy, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Unit { + MutationCount, + MutationSum, + AcquisitionCount, + ResponseBytes, + DisclosureBytes, +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +struct Reservation { + key: [u8; 32], + unit: Unit, + amount: u64, + ceiling: u64, + window_index: u64, + window_seconds: u64, +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum Protocol { + Mutation { + request: [u8; 32], + }, + Acquisition { + request: [u8; 32], + projection: [u8; 32], + maximum_response_bytes: u64, + }, + Disclosure { + source_effect: [u8; 32], + protected_content: [u8; 32], + recipient: String, + channel: [u8; 32], + delivery_instance: [u8; 32], + projection: [u8; 32], + maximum_bytes: u64, + }, +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +struct BindingWire { + schema: String, + namespace: String, + partition: String, + epoch: u64, + operation: String, + action: [u8; 32], + native_authority: [u8; 32], + scope: Scope, + recipe: [u8; 32], + compiler: String, + connection: [u8; 32], + credential_generation: u64, + qualification_policy: String, + reservations: Vec, + protocol: Protocol, +} + +/// Immutable validated private binding. Its canonical form is native JCS JSON; +/// all integer fields are bounded to the exact JSON integer range. Decoding is +/// data validation only and cannot manufacture a sealed effect or send permit. +#[derive(Clone, Eq, PartialEq)] +pub struct EffectBinding { + wire: BindingWire, + id: EffectId, +} + +impl fmt::Debug for EffectBinding { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("EffectBinding { private: [redacted] }") + } +} + +fn commitment(domain: &str, bytes: &[u8]) -> Result<[u8; 32], EffectBindingError> { + auths_codec::domain_commitment(domain, bytes) + .map(|digest| *digest.as_bytes()) + .map_err(|_| EffectBindingError::Invalid) +} + +fn canonical(value: &T) -> Result>, EffectBindingError> { + let bytes = Zeroizing::new( + serde_json_canonicalizer::to_vec(value).map_err(|_| EffectBindingError::Invalid)?, + ); + if bytes.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + Ok(bytes) +} + +impl EffectBinding { + fn new(wire: BindingWire) -> Result { + validate(&wire)?; + let bytes = canonical(&wire)?; + let id = EffectId(commitment(EFFECT_BINDING_SCHEMA, &bytes)?); + Ok(Self { wire, id }) + } + + /// Decodes a canonical binding, rejecting duplicate/unknown fields and + /// alternate encodings. The total byte limit is checked before allocation. + /// + /// # Errors + /// Returns a closed invalid/unsupported error; never echoes input. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let wire: BindingWire = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + let binding = Self::new(wire)?; + if binding.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(binding) + } + + /// Encodes private audit data. The returned buffer is erased on drop. + /// This is not a public receipt or an executable capability. + /// + /// # Errors + /// Returns `Invalid` if the canonical representation cannot be produced. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + canonical(&self.wire) + } + + /// Identity approved and compared within the protected boundary. + #[must_use] + pub const fn id(&self) -> EffectId { + self.id + } + + /// Whether both bindings name the same logical replay key. A true result + /// with different identities is a conflict, never a new operation. + #[must_use] + pub fn same_operation(&self, other: &Self) -> bool { + self.wire.namespace == other.wire.namespace + && self.wire.partition == other.wire.partition + && self.wire.epoch == other.wire.epoch + && self.wire.operation == other.wire.operation + } +} + +fn label(value: &str) -> bool { + !value.is_empty() && value.len() <= 512 && !value.chars().any(char::is_control) +} + +fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { + if wire.schema != EFFECT_BINDING_SCHEMA || wire.compiler != COMPILER { + return Err(EffectBindingError::Unsupported); + } + if OperatorNamespace::parse(&wire.namespace).is_err() + || LogicalOperationId::parse(&wire.operation).is_err() + || !label(&wire.partition) + || !(1..=MAX_SAFE_INTEGER).contains(&wire.epoch) + || !(1..=MAX_SAFE_INTEGER).contains(&wire.credential_generation) + || !matches!(wire.qualification_policy.as_str(), "required" | "optional") + || wire.reservations.len() > MAX_EFFECT_RESERVATIONS + { + return Err(EffectBindingError::Invalid); + } + let mut previous = None; + for reservation in &wire.reservations { + let key = (reservation.key, reservation.unit); + if previous.is_some_and(|previous| previous >= key) + || reservation.ceiling == 0 + || reservation.amount > reservation.ceiling + || reservation.ceiling > MAX_SAFE_INTEGER + || reservation.window_index > MAX_SAFE_INTEGER + || !(1..=crate::MAX_WINDOW_SECONDS).contains(&reservation.window_seconds) + { + return Err(EffectBindingError::Invalid); + } + let unit_allowed = match &wire.protocol { + Protocol::Mutation { .. } => { + matches!(reservation.unit, Unit::MutationCount | Unit::MutationSum) + } + Protocol::Acquisition { .. } => matches!( + reservation.unit, + Unit::AcquisitionCount | Unit::ResponseBytes + ), + Protocol::Disclosure { .. } => reservation.unit == Unit::DisclosureBytes, + }; + if !unit_allowed + || (matches!( + reservation.unit, + Unit::MutationCount | Unit::AcquisitionCount + ) && reservation.amount != 1) + { + return Err(EffectBindingError::Invalid); + } + previous = Some(key); + } + match &wire.protocol { + Protocol::Mutation { .. } => {} + Protocol::Acquisition { + maximum_response_bytes, + .. + } => { + if !(1..=65_536).contains(maximum_response_bytes) { + return Err(EffectBindingError::Invalid); + } + } + Protocol::Disclosure { + recipient, + maximum_bytes, + .. + } => { + if !label(recipient) || *maximum_bytes > 65_536 { + return Err(EffectBindingError::Invalid); + } + } + } + Ok(()) +} + +/// Sealed native compilation result. It owns both the private binding and the +/// exact immutable compiler output. There is no public constructor, clone or +/// deserializer. Compiling this value does not approve it or grant entry. +pub struct BoundEffect { + binding: EffectBinding, + command: VerifiedCommand, +} + +impl fmt::Debug for BoundEffect { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("BoundEffect { private: [redacted] }") + } +} + +impl BoundEffect { + /// Returns immutable audit/approval data, never entry authority. + #[must_use] + pub const fn binding(&self) -> &EffectBinding { + &self.binding + } + + /// Returns the exact noncredential request for an authorized private + /// review. This can contain private content and must not be logged. + #[must_use] + pub const fn private_request(&self) -> &ClosedProviderRequest { + &self.command.request + } + + /// Constructs the exact private review statement for an installed human + /// approver. Its signature is deliberately excluded from effect identity. + /// + /// # Errors + /// Refuses an invalid key, time range or approval lifetime. + pub fn approval_request( + &self, + approver: [u8; 32], + not_before: u64, + expires_at: u64, + ) -> Result { + let request = EffectApprovalRequest { + schema: APPROVAL_SCHEMA.to_owned(), + effect: *self.binding.id().as_bytes(), + approver, + not_before, + expires_at, + }; + request.validate()?; + Ok(request) + } + + /// Validates exact approval separately from native resource authority. + /// The approver key comes from installed human policy, never the envelope. + /// This effect remains non-executable until fresh transactional admission. + /// + /// # Errors + /// Refuses changed identity, untrusted signer, invalid signature or time. + pub fn approve( + self, + approval: ExactEffectApproval, + installed_approver: &[u8; 32], + now: u64, + ) -> Result { + approval.verify(self.binding.id(), installed_approver, now)?; + Ok(ApprovedEffect { + effect: self, + approval, + }) + } +} + +/// Native exact-effect approval statement. Signing this private projection +/// approves no other operation, installation, request or recipient. It does not +/// supply resource authority. Debug deliberately omits the effect commitment. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct EffectApprovalRequest { + schema: String, + effect: [u8; 32], + approver: [u8; 32], + not_before: u64, + expires_at: u64, +} + +impl fmt::Debug for EffectApprovalRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("EffectApprovalRequest { private: [redacted] }") + } +} + +impl EffectApprovalRequest { + fn validate(&self) -> Result<(), EffectBindingError> { + if self.schema != APPROVAL_SCHEMA { + return Err(EffectBindingError::Unsupported); + } + let key = + VerifyingKey::from_bytes(&self.approver).map_err(|_| EffectBindingError::Invalid)?; + if key.is_weak() + || self.expires_at > MAX_SAFE_INTEGER + || self.expires_at <= self.not_before + || self.expires_at - self.not_before > MAX_EFFECT_APPROVAL_SECONDS + { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + /// Returns the native domain-separated 32-byte message to sign using + /// Ed25519. Callers must display the associated bound effect before signing; + /// a signature does not prove that a human actually inspected the display. + /// + /// # Errors + /// Refuses invalid statement fields or unsupported semantics. + pub fn signing_message(&self) -> Result<[u8; 32], EffectBindingError> { + self.validate()?; + commitment(APPROVAL_SCHEMA, &canonical(self)?) + } + + /// Attaches signature bytes without claiming their validity. Validation + /// happens when the bound effect is approved against installed policy. + #[must_use] + pub fn with_signature(self, signature: [u8; 64]) -> ExactEffectApproval { + ExactEffectApproval { + request: self, + signature_b64: Base64UrlUnpadded::encode_string(&signature), + } + } +} + +/// Portable approval evidence, not a send token. Replaying this evidence can +/// never recreate a durable entry permit. Only exact approval is supported by +/// this type; bounded acquisition consent will use its own typed contract. +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct ExactEffectApproval { + request: EffectApprovalRequest, + signature_b64: String, +} + +impl fmt::Debug for ExactEffectApproval { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("ExactEffectApproval { private: [redacted] }") + } +} + +impl ExactEffectApproval { + /// Decodes exact canonical approval data within the fixed byte limit. + /// + /// # Errors + /// Refuses malformed/duplicate/noncanonical/oversized evidence. Successful + /// decoding does not authenticate the signer or establish authorization. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_APPROVAL_BYTES { + return Err(EffectBindingError::Invalid); + } + let approval: Self = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + approval.request.validate()?; + approval.signature()?; + if approval.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(approval) + } + + /// Encodes private approval evidence for the protected channel/journal. + /// + /// # Errors + /// Refuses an oversized or unencodable envelope. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + let bytes = canonical(self)?; + if bytes.len() > MAX_EFFECT_APPROVAL_BYTES { + return Err(EffectBindingError::Invalid); + } + Ok(bytes) + } + + fn signature(&self) -> Result { + let mut bytes = [0_u8; 64]; + let decoded = Base64UrlUnpadded::decode(&self.signature_b64, &mut bytes) + .map_err(|_| EffectBindingError::Invalid)?; + if decoded.len() != 64 || Base64UrlUnpadded::encode_string(decoded) != self.signature_b64 { + return Err(EffectBindingError::Invalid); + } + Ok(Signature::from_bytes(&bytes)) + } + + fn verify( + &self, + effect: EffectId, + installed: &[u8; 32], + now: u64, + ) -> Result<(), EffectBindingError> { + self.request.validate()?; + if self.request.effect != *effect.as_bytes() + || self.request.approver != *installed + || now < self.request.not_before + || now >= self.request.expires_at + { + return Err(EffectBindingError::Invalid); + } + VerifyingKey::from_bytes(installed) + .map_err(|_| EffectBindingError::Invalid)? + .verify_strict(&self.request.signing_message()?, &self.signature()?) + .map_err(|_| EffectBindingError::Invalid) + } +} + +/// Native authority and human approval are separate sealed facts. This stage +/// is neither cloneable nor deserializable and still grants no external entry. +pub struct ApprovedEffect { + effect: BoundEffect, + approval: ExactEffectApproval, +} + +impl ApprovedEffect { + /// Immutable effect reviewed by the approver. + #[must_use] + pub const fn effect(&self) -> &BoundEffect { + &self.effect + } + + /// Rechecks the original signed statement at a transaction's sampled time. + /// This never changes or extends its signed validity interval. + /// + /// # Errors + /// Refuses expired approval or a changed installed approver policy. + pub fn validate_approval( + &self, + installed_approver: &[u8; 32], + now: u64, + ) -> Result<(), EffectBindingError> { + self.approval + .verify(self.effect.binding.id(), installed_approver, now) + } +} + +/// Pinned deployment inputs for effect-free compilation. The caller must be +/// the installation boundary, not an untrusted application request. Epoch is +/// the admission partition epoch, independent of credential/config generations. +pub struct EffectInstallation<'a> { + /// Reviewed, installed recipe. + pub recipe: &'a CompiledRecipe, + /// Installed native trust and configuration. + pub context: &'a TrustedContext, + /// Current operator-approved connection; no secret bytes are copied. + pub connection: &'a ConnectionRecord, + /// Stable admission partition within the operator namespace. + pub partition: &'a str, + /// Independently commissioned partition epoch. + pub epoch: u64, + /// Installed recipe qualification requirement. + pub qualification: QualificationPolicy, +} + +/// Verifies natively and compiles one mutation into an immutable bound effect. +/// No I/O, reservation, approval, credential acquisition or entry is performed. +/// `now` is the caller's explicit evaluation input, not an authenticated event. +/// +/// # Errors +/// Returns native/profile refusals or a closed installation/binding refusal. +pub fn compile_mutation_effect( + installed: &EffectInstallation<'_>, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) + .map_err(|_| not_entered("gateway.effect.installation"))?; + let command = verify_detailed(installed.recipe, installed.context, now, proof, action)?; + bind_mutation(installed, command).map_err(|_| not_entered("gateway.effect.invalid-binding")) +} + +fn bind_mutation( + installed: &EffectInstallation<'_>, + command: VerifiedCommand, +) -> Result { + let request = &command.request; + let mut reservations = Vec::new(); + if let Some(bound) = &command.bound { + for count in &bound.counts { + reservations.push(Reservation { + key: count.key, + unit: Unit::MutationCount, + amount: 1, + ceiling: count.capacity, + window_index: bound.window_index, + window_seconds: bound.window_seconds, + }); + } + for sum in &bound.sums { + reservations.push(Reservation { + key: sum.key, + unit: Unit::MutationSum, + amount: bound.argument, + ceiling: sum.capacity, + window_index: bound.window_index, + window_seconds: bound.window_seconds, + }); + } + } + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + let connection = Zeroizing::new( + installed + .connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + let binding = EffectBinding::new(BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: request.namespace().as_str().to_owned(), + partition: installed.partition.to_owned(), + epoch: installed.epoch, + operation: request.operation_id().as_str().to_owned(), + action: *request.action_commitment(), + native_authority: command.native_authority, + scope: Scope::Unscoped, + recipe: *installed.recipe.digest(), + compiler: COMPILER.to_owned(), + connection: commitment("auths.effect-installation/1", &connection)?, + credential_generation: installed.connection.credential_generation().get(), + qualification_policy: installed.qualification.as_str().to_owned(), + reservations, + protocol: Protocol::Mutation { + request: request_commitment(request)?, + }, + })?; + Ok(BoundEffect { binding, command }) +} + +/// Preserve all selected branches and evidence through the existing native +/// codec. Evaluation time and work counters are not authority identities: the +/// full verifier is rerun at a new time, without changing signed event times. +pub(crate) fn native_authority_commitment( + result: &PortableVerificationResult, + context: &TrustedContext, +) -> Result<[u8; 32], EffectBindingError> { + let normalized = context + .for_request( + context.expected_audience().clone(), + context.expected_challenge(), + Timestamp::new(0), + ) + .map_err(|_| EffectBindingError::Invalid)?; + let context_digest = + auths_codec::context_digest(&normalized).map_err(|_| EffectBindingError::Invalid)?; + let projection = PortableVerificationResult::new( + result.decision(), + result.stage(), + result.code(), + result.proof_digest(), + result.action_digest(), + context_digest, + result.plan_id(), + result.authorized_branches().to_vec(), + result.assurance().to_vec(), + result.assurance_satisfactions().to_vec(), + VerificationResources::new(0, 0, 0, 0, 0, 0, 0), + result.registry_manifest(), + result.required_configuration(), + result.local_configuration(), + ) + .with_observation_satisfactions(result.observation_satisfactions().to_vec()) + .with_approval_satisfactions(result.approval_satisfactions().to_vec()); + let bytes = Zeroizing::new( + auths_codec::encode_verification_result(&projection) + .map_err(|_| EffectBindingError::Invalid)?, + ); + commitment("auths.effect-native-authority/1", &bytes) +} + +#[derive(Serialize)] +struct ReadWire<'a> { + url: &'a str, + headers: Vec<(&'a str, &'a str)>, + maximum_response_bytes: usize, +} + +fn read_wire(read: &ClosedActionRead) -> ReadWire<'_> { + ReadWire { + url: read.url(), + headers: read + .headers() + .iter() + .map(|header| (header.name(), header.value())) + .collect(), + maximum_response_bytes: read.maximum_response_bytes(), + } +} + +#[derive(Serialize)] +struct RequestWire<'a> { + method: &'a str, + url: &'a str, + media_type: &'a str, + body: &'a str, + headers: Vec<(&'a str, &'a str)>, + credential: &'a crate::CredentialRequirement, + idempotency: Option<&'a str>, + echo: Option<&'a str>, + observation: Option<&'a ObservationTemplate>, + pre_entry: Option>, + relative_ceiling: Option>, +} + +fn request_commitment(request: &ClosedProviderRequest) -> Result<[u8; 32], EffectBindingError> { + let wire = RequestWire { + method: request.method().as_str(), + url: request.url(), + media_type: request.content_type(), + body: std::str::from_utf8(request.body()).map_err(|_| EffectBindingError::Invalid)?, + headers: request + .headers() + .iter() + .map(|header| (header.name(), header.value())) + .collect(), + credential: request.credential_requirement(), + idempotency: request.idempotency_key(), + echo: request.echo_token(), + observation: request.observation_template(), + pre_entry: request.pre_entry_read().map(read_wire), + relative_ceiling: request.relative_ceiling_read().map(read_wire), + }; + let bytes = canonical(&wire)?; + commitment("auths.effect-transport/1", &bytes) +} + +#[cfg(test)] +mod tests { + use super::*; + use ed25519_dalek::{Signer as _, SigningKey}; + + fn wire() -> BindingWire { + BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: "synthetic".to_owned(), + partition: "private-synthetic-partition".to_owned(), + epoch: 1, + operation: "operation-1".to_owned(), + action: [1; 32], + native_authority: [2; 32], + scope: Scope::Unscoped, + recipe: [3; 32], + compiler: COMPILER.to_owned(), + connection: [4; 32], + credential_generation: 1, + qualification_policy: "required".to_owned(), + reservations: vec![Reservation { + key: [5; 32], + unit: Unit::MutationCount, + amount: 1, + ceiling: 2, + window_index: 0, + window_seconds: 60, + }], + protocol: Protocol::Mutation { request: [6; 32] }, + } + } + + #[test] + fn canonical_roundtrip_is_data_only_and_debug_is_private() { + let binding = EffectBinding::new(wire()).expect("binding"); + let bytes = binding.to_private_bytes().expect("encode"); + assert_eq!( + EffectBinding::from_private_bytes(&bytes).expect("decode"), + binding + ); + let printed = format!("{binding:?} {:?}", binding.id()); + assert!(!printed.contains("private-synthetic-partition")); + assert!(!printed.contains(&hex::encode(binding.id().as_bytes()))); + } + + #[test] + fn reject_alternate_encodings_duplicates_and_unknown_versions() { + let binding = EffectBinding::new(wire()).expect("binding"); + let bytes = binding.to_private_bytes().expect("encode"); + let mut padded = bytes.to_vec(); + padded.push(b' '); + assert_eq!( + EffectBinding::from_private_bytes(&padded), + Err(EffectBindingError::Invalid) + ); + let text = std::str::from_utf8(&bytes).expect("json"); + for invalid in [ + text.replacen("{", "{\"epoch\":1,", 1), + text.replacen("{", "{\"unknown\":1,", 1), + text.replace("\"epoch\":1", "\"epoch\":1.0"), + text.replace("\"epoch\":1", "\"epoch\":0"), + ] { + assert_eq!( + EffectBinding::from_private_bytes(invalid.as_bytes()), + Err(EffectBindingError::Invalid) + ); + } + let mut obsolete = wire(); + obsolete.schema = "auths.bound-effect/0".to_owned(); + assert_eq!( + EffectBinding::new(obsolete), + Err(EffectBindingError::Unsupported) + ); + assert_eq!( + EffectBinding::from_private_bytes(&vec![b' '; MAX_EFFECT_BYTES + 1]), + Err(EffectBindingError::Invalid) + ); + } + + #[test] + fn every_binding_dimension_changes_identity_without_evading_replay_key() { + let original = EffectBinding::new(wire()).expect("binding"); + for dimension in 0..12 { + let mut changed = wire(); + match dimension { + 0 => changed.action[0] ^= 1, + 1 => changed.native_authority[0] ^= 1, + 2 => { + changed.scope = Scope::Task { + commitment: [7; 32], + } + } + 3 => changed.recipe[0] ^= 1, + 4 => changed.connection[0] ^= 1, + 5 => changed.credential_generation += 1, + 6 => changed.qualification_policy = "optional".to_owned(), + 7 => changed.reservations[0].key[0] ^= 1, + 8 => changed.reservations[0].ceiling += 1, + 9 => changed.reservations[0].window_index += 1, + 10 => changed.reservations[0].window_seconds += 1, + _ => changed.protocol = Protocol::Mutation { request: [8; 32] }, + } + let changed = EffectBinding::new(changed).expect("changed binding"); + assert!(original.same_operation(&changed), "dimension {dimension}"); + assert_ne!(original.id(), changed.id(), "dimension {dimension}"); + } + for dimension in 0..4 { + let mut changed = wire(); + match dimension { + 0 => changed.namespace.push('2'), + 1 => changed.partition.push('2'), + 2 => changed.epoch += 1, + _ => changed.operation.push('2'), + } + let changed = EffectBinding::new(changed).expect("new operation"); + assert!(!original.same_operation(&changed)); + assert_ne!(original.id(), changed.id()); + } + } + + #[test] + fn reservations_reject_duplicates_mixed_protocols_and_limits() { + let mut changed = wire(); + changed.reservations.push(changed.reservations[0].clone()); + assert_eq!( + EffectBinding::new(changed), + Err(EffectBindingError::Invalid) + ); + let mut changed = wire(); + changed.reservations[0].unit = Unit::DisclosureBytes; + assert_eq!( + EffectBinding::new(changed), + Err(EffectBindingError::Invalid) + ); + let mut changed = wire(); + changed.reservations = (0..MAX_EFFECT_RESERVATIONS) + .map(|index| { + let mut entry = wire().reservations.remove(0); + entry.key[0] = u8::try_from(index).expect("bounded index"); + entry + }) + .collect(); + assert!(EffectBinding::new(changed.clone()).is_ok()); + let mut excess = changed.reservations[0].clone(); + excess.key = [255; 32]; + changed.reservations.push(excess); + assert_eq!( + EffectBinding::new(changed), + Err(EffectBindingError::Invalid) + ); + let mut changed = wire(); + changed.epoch = MAX_SAFE_INTEGER; + assert!(EffectBinding::new(changed.clone()).is_ok()); + changed.epoch += 1; + assert_eq!( + EffectBinding::new(changed), + Err(EffectBindingError::Invalid) + ); + } + + #[test] + fn exact_approval_cannot_change_identity_signer_or_signed_event_time() { + let key = SigningKey::from_bytes(&[19; 32]); + let trusted = key.verifying_key().to_bytes(); + let effect = EffectBinding::new(wire()).expect("binding").id(); + let request = EffectApprovalRequest { + schema: APPROVAL_SCHEMA.to_owned(), + effect: *effect.as_bytes(), + approver: trusted, + not_before: 100, + expires_at: 200, + }; + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approval = request.with_signature(signature); + let encoded = approval.to_private_bytes().expect("encode"); + let approval = ExactEffectApproval::from_private_bytes(&encoded).expect("decode"); + assert!(approval.verify(effect, &trusted, 100).is_ok()); + assert!(approval.verify(effect, &trusted, 199).is_ok()); + assert!(approval.verify(effect, &trusted, 99).is_err()); + assert!(approval.verify(effect, &trusted, 200).is_err()); + assert!(approval.verify(EffectId([99; 32]), &trusted, 150).is_err()); + let other_key = SigningKey::from_bytes(&[20; 32]).verifying_key().to_bytes(); + assert!(approval.verify(effect, &other_key, 150).is_err()); + let mut altered = approval.clone(); + altered.request.expires_at += 1; + assert!(altered.verify(effect, &trusted, 150).is_err()); + assert!(!format!("{approval:?}").contains(&approval.signature_b64)); + } +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs new file mode 100644 index 000000000..8fe51c3a0 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -0,0 +1,146 @@ +//! AP074 compilation tests using native signed proof fixtures. These establish +//! compilation/approval behavior only; journal and transport evidence is separate. + +use super::*; +use crate::effect::{EffectBinding, EffectInstallation, compile_mutation_effect}; +use auths_connections::{ + ConnectionAlias, ConnectionId, ConnectionProfile, ConnectionRecord, ConnectionState, + ProviderKind, SemanticId, +}; +use ed25519_dalek::{Signer as _, SigningKey}; + +fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { + ConnectionRecord::new( + ProviderKind::parse("airtable").expect("provider"), + ConnectionAlias::parse("synthetic").expect("alias"), + ConnectionId::parse("conn_AAAAAAAAAAAAAAAAAAAAAA").expect("connection ID"), + SemanticId::parse("auths.gateway-operation/1").expect("contract"), + SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), + crate::GatewayConnectionDescriptor::approve(recipe, "Authorization") + .expect("descriptor") + .to_bytes() + .expect("descriptor bytes"), + [4; 32], + [5; 32], + std::num::NonZeroU64::MIN, + ConnectionState::Active, + vec!["gateway".to_owned()], + vec![ + ConnectionProfile::new(SemanticId::parse("auths.mcp").expect("profile"), 2) + .expect("profile"), + ], + NOW - 100, + NOW - 100, + None, + ) + .expect("connection") +} + +#[test] +fn native_compilation_approval_and_reverification_keep_exact_request() { + let root = signer(h::ROOT_SEED); + let agent = signer(0x22); + let observer = signer(h::OBSERVER_SEED); + let recipe = recipe( + &json!({ + "replacement": {"type": "enum", "variants": ["private-sentinel-Approved", "Pending"]} + }), + &json!({"verified": []}), + ); + let context = context(&root, &observer.principal, None); + let connection = connection(&recipe); + let arguments = json!({ + "operation_id": "bound-native-1", "operator_namespace": NAMESPACE, + "recipe_digest": recipe.digest_hex(), "record_id": RECORD, + "replacement": "private-sentinel-Approved" + }) + .as_object() + .expect("arguments") + .clone(); + let grant = grant(&root, &agent, None); + let submission = submission(&root, &agent, &grant, &arguments, &[]); + let installed = EffectInstallation { + recipe: &recipe, + context: &context, + connection: &connection, + partition: "synthetic-partition", + epoch: 1, + qualification: crate::QualificationPolicy::Optional, + }; + let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) + .expect("native effect"); + let later = compile_mutation_effect(&installed, NOW + 1, &submission.proof, &submission.action) + .expect("fresh native effect"); + assert_eq!( + effect.binding(), + later.binding(), + "evaluation time is not signed event time" + ); + let expected = recipe + .closed_request_from_arguments(&arguments, submission.commitment) + .expect("compiler output"); + assert_eq!(effect.private_request().body(), expected.body()); + assert_eq!(effect.private_request().url(), expected.url()); + assert_eq!(effect.private_request().headers(), expected.headers()); + let bytes = effect.binding().to_private_bytes().expect("binding bytes"); + assert_eq!( + &EffectBinding::from_private_bytes(&bytes).expect("binding data"), + effect.binding() + ); + assert!( + !String::from_utf8(bytes.to_vec()) + .expect("json") + .contains("private-sentinel") + ); + assert!(!format!("{effect:?}").contains("private-sentinel")); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let review = effect + .approval_request(public, NOW, NOW + 30) + .expect("review"); + let signature = key + .sign(&review.signing_message().expect("native message")) + .to_bytes(); + let approval = review.with_signature(signature); + let fixture = serde_json::to_vec_pretty(&json!({ + "schema": "auths.effect-fixture/1", + "scope": "native compilation and exact approval; no entry or durability claim", + "effect_id_hex": hex::encode(effect.binding().id().as_bytes()), + "binding_canonical": std::str::from_utf8(&bytes).expect("binding UTF-8"), + "approval_canonical": std::str::from_utf8(&approval.to_private_bytes().expect("approval bytes")).expect("approval UTF-8"), + "approver_public_key_hex": hex::encode(public), + "request_method": expected.method().as_str(), + "request_url": expected.url(), + "request_body": std::str::from_utf8(expected.body()).expect("request UTF-8"), + "evaluated_at": NOW, + "approval_expires_at": NOW + 30, + })).expect("fixture JSON"); + let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/effect-binding.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { + std::fs::write(&fixture_path, &fixture).expect("write native fixture"); + } + assert_eq!( + std::fs::read(&fixture_path).expect("native fixture"), + fixture + ); + let approved = effect + .approve(approval.clone(), &public, NOW) + .expect("exact approval"); + assert_eq!(approved.effect().private_request().body(), expected.body()); + assert!(approved.validate_approval(&public, NOW + 29).is_ok()); + assert!(approved.validate_approval(&public, NOW + 30).is_err()); + let changed_installation = EffectInstallation { + epoch: 2, + ..installed + }; + let changed = compile_mutation_effect( + &changed_installation, + NOW, + &submission.proof, + &submission.action, + ) + .expect("changed epoch"); + assert!(changed.approve(approval, &public, NOW).is_err()); + assert!(compile_mutation_effect(&changed_installation, NOW, &[], &submission.action).is_err()); +} diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 3d0370443..4f6bfbfad 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1613,6 +1613,8 @@ pub(crate) fn verify_command( /// need of its authorized branches. #[derive(Clone, Debug)] pub(crate) struct VerifiedCommand { + /// Stable native branch/evidence selection and installed trust identity. + pub(crate) native_authority: [u8; 32], /// Exact actors of action IDs already sealed by the native verifier. #[cfg(unix)] pub(crate) actors: Vec, @@ -1696,6 +1698,8 @@ pub(crate) fn verify_detailed( .map_err(|_| not_entered("gateway.policy.proof-unavailable"))?; let observer_refusal = crate::separation::check_proof_observers(proof_cbor, action).err(); Ok(VerifiedCommand { + native_authority: crate::effect::native_authority_commitment(sealed.portable(), context) + .map_err(|_| not_entered("gateway.effect.native-authority"))?, #[cfg(unix)] actors: branches.actors, request, diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index bba869b55..72c1f2b19 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -23,6 +23,7 @@ pub use engine::{ mod connection; mod credential_journal; mod echo_verify; +pub mod effect; mod engine; mod execution_witness; pub use execution_witness::GatewayExecutionWitness; diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index c7dc0899d..dbee2cd64 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -51,6 +51,9 @@ mod bounds_tests; const NOW: u64 = 1_790_000_000; +#[path = "effect_native_tests.rs"] +mod effect_native_tests; + fn window(from: u64, until: u64) -> ValidityWindow { h::window(from, until).expect("window") } diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index c2c147152..aa66ada4d 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -328,6 +328,8 @@ pub(crate) fn admitted( .closed_request_from_arguments(&arguments, commitment) .map_err(|error| crate::engine::not_entered(error.code()))?; Ok(VerifiedCommand { + // This corpus deliberately enters after native verification. + native_authority: [0; 32], #[cfg(unix)] actors: Vec::new(), request, From ca407640499f8326b132413de1b3ed53a3b9bfa0 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:44:21 +0000 Subject: [PATCH 004/136] test(gateway): freeze native bound-effect approval fixture --- bindings/fixtures/gateway/effect-binding.json | 13 +++++++++++++ docs/plans/0074-implementation-status.md | 15 +++++++++++---- .../auths-gateway/src/effect_native_tests.rs | 2 +- 3 files changed, 25 insertions(+), 5 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-binding.json diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json new file mode 100644 index 000000000..02ae0baa2 --- /dev/null +++ b/bindings/fixtures/gateway/effect-binding.json @@ -0,0 +1,13 @@ +{ + "schema": "auths.effect-fixture/1", + "scope": "native compilation and exact approval; no entry or durability claim", + "effect_id_hex": "dcc67ab66bf0a0228ef5ca9f4b1b73486c179a166b3232e6b754c0c2ce90c3a6", + "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"compiler\":\"auths.gateway-effect-compiler/1\",\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/1\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[220,198,122,182,107,240,160,34,142,245,202,159,75,27,115,72,108,23,154,22,107,50,50,230,183,84,192,194,206,144,195,166],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"gWTY_M_iYTYQ7TjwNwG9h-9W3kGRgUFW0K8YdLpKXZBdtdmWumu5xEjPLVWhx74vlIvrastFVrhwTKUyEHEUCA\"}", + "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", + "request_method": "PATCH", + "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", + "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-Approved\",\"auths_echo\":\"auths-e1-e38d866bf40628b9f92313a8dc13515ad20b2b63498935834e2c6c3435545424\"}}", + "evaluated_at": 1790000000, + "approval_expires_at": 1790000030 +} \ No newline at end of file diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index ea0e3493c..95843c0cf 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -42,8 +42,15 @@ No stage is complete merely because types, documentation or a happy path exist. Native signature validation does not replace resource authority or live entry. - Source tests authored for identity mutations, canonical/duplicate/limit cases, approval substitution/expiry and a real native signed-proof compilation path. -- A targeted native fixture-generation test was started with - `AUTHS_UPDATE_FIXTURES=1`; compilation/generation is pending at this checkpoint. +- Draft PR: https://github.com/auths-dev/auths-proof/pull/213, initially pushed at + `005dfd42`. GitHub connector PR creation lacked permission; authenticated `gh` + created the draft. No workflow results have been inspected. +- The targeted native fixture-generation test completed with one passing test + after correcting an invalid empty precondition declaration in the test recipe. + Command: `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact observed_tests::effect_native_tests::native_compilation_approval_and_reverification_keep_exact_request`. + Artifact: `bindings/fixtures/gateway/effect-binding.json`. This run used + `005dfd42` plus the committed null-precondition fixture correction; its scope + is compilation, canonical round-trip and exact approval, not A01 completion. This local run constructs the required canonical artifact; it is not a broad pre-push verification run. No hosted workflows observed or formal gates run. - Existing submission still uses the baseline path. P1 is not closed until the @@ -68,7 +75,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | Case | Required evidence | Implementation / authored / executed | Limitation or next work | | --- | --- | --- | --- | -| A01 | Same bound identity and exact request across review/approval/send | Pending / no / no | Cut over mutation | +| A01 | Same bound identity and exact request across review/approval/send | Partial / partial / compilation-only | Execution cutover pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Pending / no / no | Full binding comparison | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Pending / no / no | Atomic journal admission | @@ -85,7 +92,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A15 | Recovery actor differs; original authority revoked | Pending / no / no | Separate recovery authority | | A16 | Cross-task/recipe/partition substitution | Pending / no / no | Scope and epoch binding | | A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | -| A18 | Canonical/malformed/duplicate/limit binding corpus | Pending / no / no | Native codecs/thin wrappers | +| A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | | A20 | Generated histories and shipping predicate refinement | Pending / no / no | Update linked artifacts | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 8fe51c3a0..e292f9cd0 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -45,7 +45,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { &json!({ "replacement": {"type": "enum", "variants": ["private-sentinel-Approved", "Pending"]} }), - &json!({"verified": []}), + &Value::Null, ); let context = context(&root, &observer.principal, None); let connection = connection(&recipe); From 464f0b2a8a7442ee3a17b144e9ea3a376337f8fa Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:47:40 +0000 Subject: [PATCH 005/136] feat(gateway): revalidate original effect authority and approval policy --- bindings/fixtures/gateway/effect-binding.json | 6 +- docs/plans/0074-implementation-status.md | 7 ++ product/runtime/auths-gateway/src/effect.rs | 76 ++++++++++++++++++- .../auths-gateway/src/effect_native_tests.rs | 26 ++++++- 4 files changed, 106 insertions(+), 9 deletions(-) diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 02ae0baa2..3ee816000 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -1,9 +1,9 @@ { "schema": "auths.effect-fixture/1", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "dcc67ab66bf0a0228ef5ca9f4b1b73486c179a166b3232e6b754c0c2ce90c3a6", - "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"compiler\":\"auths.gateway-effect-compiler/1\",\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/1\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[220,198,122,182,107,240,160,34,142,245,202,159,75,27,115,72,108,23,154,22,107,50,50,230,183,84,192,194,206,144,195,166],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"gWTY_M_iYTYQ7TjwNwG9h-9W3kGRgUFW0K8YdLpKXZBdtdmWumu5xEjPLVWhx74vlIvrastFVrhwTKUyEHEUCA\"}", + "effect_id_hex": "ddc0f0224d94e452ef06a63695be6aedad36f9947f8677432b0976526d41214b", + "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/1\",\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/1\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"tVxnMe0bJwPg9P6NV4a7zGDPy_cgsSXWP5XQIz8J2H2Tur2m38UZUpCuYYThRKKQlyuzEHmjsQnMtT1MlhjrCQ\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 95843c0cf..86328bee0 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -56,6 +56,13 @@ No stage is complete merely because types, documentation or a happy path exist. - Existing submission still uses the baseline path. P1 is not closed until the installed review/approval/admission path replaces it. No new effect can yet be submitted, and the new sealed compilation API grants no execution authority. +- Added entry validation over the retained original proof/action. It re-runs the + full verifier, compares the complete newly compiled binding, and checks the + original human approval at the supplied transaction time. The installed exact + approver policy is itself in the effect identity. The same native fixture + generation test passes after this change, including independently expiring + resource authority while human approval remains current. Transactional wiring + and fencing are still pending; this API alone makes no linearization claim. ## Phase gates diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 5b7d9f5bf..b29c57b26 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -111,6 +111,12 @@ enum Protocol { }, } +#[derive(Clone, Copy, Deserialize, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum ApprovalPolicy { + Exact { approver: [u8; 32] }, +} + #[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] #[serde(deny_unknown_fields)] struct BindingWire { @@ -127,6 +133,7 @@ struct BindingWire { connection: [u8; 32], credential_generation: u64, qualification_policy: String, + approval_policy: ApprovalPolicy, reservations: Vec, protocol: Protocol, } @@ -232,6 +239,10 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { { return Err(EffectBindingError::Invalid); } + let ApprovalPolicy::Exact { approver } = wire.approval_policy; + if VerifyingKey::from_bytes(&approver).map_or(true, |key| key.is_weak()) { + return Err(EffectBindingError::Invalid); + } let mut previous = None; for reservation in &wire.reservations { let key = (reservation.key, reservation.unit); @@ -293,6 +304,8 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { pub struct BoundEffect { binding: EffectBinding, command: VerifiedCommand, + proof: Zeroizing>, + action: Zeroizing>, } impl fmt::Debug for BoundEffect { @@ -326,6 +339,9 @@ impl BoundEffect { not_before: u64, expires_at: u64, ) -> Result { + if self.binding.wire.approval_policy != (ApprovalPolicy::Exact { approver }) { + return Err(EffectBindingError::Invalid); + } let request = EffectApprovalRequest { schema: APPROVAL_SCHEMA.to_owned(), effect: *self.binding.id().as_bytes(), @@ -349,6 +365,13 @@ impl BoundEffect { installed_approver: &[u8; 32], now: u64, ) -> Result { + if self.binding.wire.approval_policy + != (ApprovalPolicy::Exact { + approver: *installed_approver, + }) + { + return Err(EffectBindingError::Invalid); + } approval.verify(self.binding.id(), installed_approver, now)?; Ok(ApprovedEffect { effect: self, @@ -521,6 +544,30 @@ impl ApprovedEffect { self.approval .verify(self.effect.binding.id(), installed_approver, now) } + + /// Re-runs the full native verifier on this effect's retained original + /// proof/action and recompiles against current installation inputs. Every + /// selected branch, evidence dependency, request and charge must still + /// produce the original binding. This is the semantic check the admission + /// transaction must call after acquiring its lock and sampling time; calling + /// it earlier alone does not fence revocation or configuration changes. + /// + /// # Errors + /// Returns native refusal, changed binding or expired/untrusted approval. + pub fn validate_for_entry( + &self, + installed: &EffectInstallation<'_>, + now: u64, + ) -> Result<(), GatewaySubmitResult> { + self.validate_approval(&installed.approver, now) + .map_err(|_| not_entered("gateway.effect.approval"))?; + let fresh = + compile_mutation_effect(installed, now, &self.effect.proof, &self.effect.action)?; + if fresh.binding != self.effect.binding { + return Err(not_entered("gateway.effect.binding-changed")); + } + Ok(()) + } } /// Pinned deployment inputs for effect-free compilation. The caller must be @@ -539,6 +586,8 @@ pub struct EffectInstallation<'a> { pub epoch: u64, /// Installed recipe qualification requirement. pub qualification: QualificationPolicy, + /// Exact human approver key pinned independently by installation policy. + pub approver: [u8; 32], } /// Verifies natively and compiles one mutation into an immutable bound effect. @@ -556,12 +605,15 @@ pub fn compile_mutation_effect( GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) .map_err(|_| not_entered("gateway.effect.installation"))?; let command = verify_detailed(installed.recipe, installed.context, now, proof, action)?; - bind_mutation(installed, command).map_err(|_| not_entered("gateway.effect.invalid-binding")) + bind_mutation(installed, command, proof, action) + .map_err(|_| not_entered("gateway.effect.invalid-binding")) } fn bind_mutation( installed: &EffectInstallation<'_>, command: VerifiedCommand, + proof: &[u8], + action: &[u8], ) -> Result { let request = &command.request; let mut reservations = Vec::new(); @@ -608,12 +660,20 @@ fn bind_mutation( connection: commitment("auths.effect-installation/1", &connection)?, credential_generation: installed.connection.credential_generation().get(), qualification_policy: installed.qualification.as_str().to_owned(), + approval_policy: ApprovalPolicy::Exact { + approver: installed.approver, + }, reservations, protocol: Protocol::Mutation { request: request_commitment(request)?, }, })?; - Ok(BoundEffect { binding, command }) + Ok(BoundEffect { + binding, + command, + proof: Zeroizing::new(proof.to_vec()), + action: Zeroizing::new(action.to_vec()), + }) } /// Preserve all selected branches and evidence through the existing native @@ -733,6 +793,9 @@ mod tests { connection: [4; 32], credential_generation: 1, qualification_policy: "required".to_owned(), + approval_policy: ApprovalPolicy::Exact { + approver: SigningKey::from_bytes(&[19; 32]).verifying_key().to_bytes(), + }, reservations: vec![Reservation { key: [5; 32], unit: Unit::MutationCount, @@ -795,7 +858,7 @@ mod tests { #[test] fn every_binding_dimension_changes_identity_without_evading_replay_key() { let original = EffectBinding::new(wire()).expect("binding"); - for dimension in 0..12 { + for dimension in 0..13 { let mut changed = wire(); match dimension { 0 => changed.action[0] ^= 1, @@ -813,7 +876,12 @@ mod tests { 8 => changed.reservations[0].ceiling += 1, 9 => changed.reservations[0].window_index += 1, 10 => changed.reservations[0].window_seconds += 1, - _ => changed.protocol = Protocol::Mutation { request: [8; 32] }, + 11 => changed.protocol = Protocol::Mutation { request: [8; 32] }, + _ => { + changed.approval_policy = ApprovalPolicy::Exact { + approver: SigningKey::from_bytes(&[20; 32]).verifying_key().to_bytes(), + } + } } let changed = EffectBinding::new(changed).expect("changed binding"); assert!(original.same_operation(&changed), "dimension {dimension}"); diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index e292f9cd0..3b433c9c5 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -59,6 +59,8 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .clone(); let grant = grant(&root, &agent, None); let submission = submission(&root, &agent, &grant, &arguments, &[]); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); let installed = EffectInstallation { recipe: &recipe, context: &context, @@ -66,6 +68,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { partition: "synthetic-partition", epoch: 1, qualification: crate::QualificationPolicy::Optional, + approver: public, }; let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) .expect("native effect"); @@ -93,8 +96,6 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .contains("private-sentinel") ); assert!(!format!("{effect:?}").contains("private-sentinel")); - let key = SigningKey::from_bytes(&[29; 32]); - let public = key.verifying_key().to_bytes(); let review = effect .approval_request(public, NOW, NOW + 30) .expect("review"); @@ -130,6 +131,27 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { assert_eq!(approved.effect().private_request().body(), expected.body()); assert!(approved.validate_approval(&public, NOW + 29).is_ok()); assert!(approved.validate_approval(&public, NOW + 30).is_err()); + assert!(approved.validate_for_entry(&installed, NOW + 29).is_ok()); + assert!(approved.validate_for_entry(&installed, NOW + 30).is_err()); + let late_request = later + .approval_request(public, NOW + 3_570, NOW + 3_605) + .expect("approval spanning native action expiry"); + let late_signature = key + .sign(&late_request.signing_message().expect("message")) + .to_bytes(); + let late = later + .approve( + late_request.with_signature(late_signature), + &public, + NOW + 3_570, + ) + .expect("late approval"); + assert!(late.validate_for_entry(&installed, NOW + 3_599).is_ok()); + assert!(late.validate_approval(&public, NOW + 3_601).is_ok()); + assert!( + late.validate_for_entry(&installed, NOW + 3_601).is_err(), + "a current human approval must not revive expired native resource authority" + ); let changed_installation = EffectInstallation { epoch: 2, ..installed From 57503566703ce6a218634c35ef16dbd4ec3efb77 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:50:23 +0000 Subject: [PATCH 006/136] feat(gateway): render private review from the sealed bound effect --- docs/plans/0074-implementation-status.md | 30 +++++++++ .../0009-bound-effect-and-recovery.md | 2 + product/runtime/auths-gateway/src/effect.rs | 62 +++++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 13 ++++ product/runtime/auths-gateway/src/engine.rs | 11 +++- 5 files changed, 117 insertions(+), 1 deletion(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 86328bee0..79ef7f9e1 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -63,6 +63,36 @@ No stage is complete merely because types, documentation or a happy path exist. generation test passes after this change, including independently expiring resource authority while human approval remains current. Transactional wiring and fencing are still pending; this API alone makes no linearization claim. +- Native private review now renders the sealed command through the same + projection as offline recipe review. It carries the exact effect identity and + canonical binding; no binding/UI request reconstruction is needed. Review + data explicitly contains private content and has a separate 128 KiB limit. + +## Immediate implementation continuation + +1. Complete the installed policy and IPC review/approve/submit cutover. The new + `effect` module currently owns native compile/approve/revalidate operations, + but `GatewayEngine::submit`, `SubmitIo`, the application socket and clients + still use the baseline proof/action submission. Replace that path with the + approved effect; do not leave a bypass or an optional compatibility mode. +2. Store the complete immutable binding in the existing attempt journal, with + replay keyed independently of the effect digest. Reuse the approved effect's + single owned command for send and reporting; reject changed binding as conflict. +3. Refactor the existing transition/order owner to distinguish reservation from + durable entry. The current `Attempting` state must not remain the authority + for both. Validate full native authority and exact approval after acquiring + the store transaction lock; fence connection/configuration against the same + transaction. Publish consumed permits only after durable acknowledgement. +4. Then finish acquisition/disclosure/ACK and AP070 direct cutover, installed + bindings, adapter fault/concurrency/process evidence and formal links. +5. Regenerate semantic closure and all affected canonical/formal artifacts once + source stabilizes. Required hosted workflows have deliberately not been + observed yet. The draft's current CI is not completion evidence. + +The native artifact-generation run last passed for the source subsequently +committed in `464f0b2a`. The private-review projection changes have source tests +authored but have not been executed locally. All unfulfilled AP074 gates remain +open, and the goal remains active. ## Phase gates diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index c719420d3..6047bf86e 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -74,6 +74,8 @@ that lookup. Optional task-free scope has an explicit tag distinct from task sco | Pre-entry observations | Existing 4, each native maximum 4,096 bytes | | Journal record / atomic batch | Existing 262,144 bytes / 64 entries | | Events / ACK | 64 events per operation / 4,096 canonical bytes per ACK | +| Exact human approval | 4,096 canonical bytes; at most 3,600 seconds, with exclusive expiry | +| Private human review | 131,072 bytes including exact request and binding; never a public receipt | | Observation attempts | At most 16 explicitly admitted linked operations | | Transaction lock deadline | 5 seconds; sample time after lock; refuse on deadline | | Native verification work | Native configured work-unit limit plus transaction deadline | diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index b29c57b26..2382ac2f6 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -31,6 +31,9 @@ const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; pub const MAX_EFFECT_APPROVAL_BYTES: usize = 4_096; /// Exact approval cannot remain eligible for more than one hour. pub const MAX_EFFECT_APPROVAL_SECONDS: u64 = 3_600; +/// Private human review can contain the exact body and full binding. Public +/// activity/receipt projections have a different, smaller disclosure contract. +pub const MAX_PRIVATE_EFFECT_REVIEW_BYTES: usize = 131_072; /// Private audit identity. Do not publish it as a hiding content commitment. #[derive(Clone, Copy, Eq, PartialEq)] @@ -308,6 +311,43 @@ pub struct BoundEffect { action: Zeroizing>, } +/// Human review produced entirely by native code from the sealed effect. +/// It includes private request content and must travel only on the authorized +/// review channel. It is not suitable for public receipts or support logs. +#[cfg(unix)] +#[derive(Serialize)] +pub struct PrivateEffectReview { + schema: &'static str, + effect_id_hex: String, + binding_canonical: String, + native: crate::GatewaySubmissionReview, +} + +#[cfg(unix)] +impl fmt::Debug for PrivateEffectReview { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("PrivateEffectReview { private: [redacted] }") + } +} + +#[cfg(unix)] +impl PrivateEffectReview { + /// Encodes the native private review; consumers display it without + /// reconstructing identity, provider bytes or authority facts themselves. + /// + /// # Errors + /// Refuses an encoding failure or a review above the fixed byte limit. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + let bytes = Zeroizing::new( + serde_json_canonicalizer::to_vec(self).map_err(|_| EffectBindingError::Invalid)?, + ); + if bytes.len() > MAX_PRIVATE_EFFECT_REVIEW_BYTES { + return Err(EffectBindingError::Invalid); + } + Ok(bytes) + } +} + impl fmt::Debug for BoundEffect { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("BoundEffect { private: [redacted] }") @@ -328,6 +368,28 @@ impl BoundEffect { &self.command.request } + /// Renders the exact immutable effect reviewed before human approval. + /// This never reads a provider, leases credentials or reserves capacity. + /// + /// # Errors + /// Returns a closed projection/encoding refusal without private input. + #[cfg(unix)] + pub fn private_review(&self) -> Result { + let binding = self + .binding + .to_private_bytes() + .map_err(|_| not_entered("gateway.effect.invalid-binding"))?; + let binding_canonical = std::str::from_utf8(&binding) + .map_err(|_| not_entered("gateway.effect.invalid-binding"))? + .to_owned(); + Ok(PrivateEffectReview { + schema: "auths.private-effect-review/1", + effect_id_hex: hex::encode(self.binding.id().as_bytes()), + binding_canonical, + native: crate::engine::review_command(&self.command)?, + }) + } + /// Constructs the exact private review statement for an installed human /// approver. Its signature is deliberately excluded from effect identity. /// diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 3b433c9c5..723ea41c9 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -86,6 +86,19 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { assert_eq!(effect.private_request().url(), expected.url()); assert_eq!(effect.private_request().headers(), expected.headers()); let bytes = effect.binding().to_private_bytes().expect("binding bytes"); + let private_review = effect.private_review().expect("native private review"); + let review_bytes = private_review.to_private_bytes().expect("review JSON"); + let review_json: Value = serde_json::from_slice(&review_bytes).expect("review JSON"); + assert_eq!( + review_json["effect_id_hex"], + hex::encode(effect.binding().id().as_bytes()) + ); + assert_eq!( + review_json["native"]["request"]["body"], + std::str::from_utf8(expected.body()).expect("body") + ); + assert_eq!(review_json["native"]["request"]["url"], expected.url()); + assert!(!format!("{private_review:?}").contains("private-sentinel")); assert_eq!( &EffectBinding::from_private_bytes(&bytes).expect("binding data"), effect.binding() diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 4f6bfbfad..96843f0c9 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -171,6 +171,15 @@ pub fn review_submission( action: &[u8], ) -> Result { let command = verify_detailed(recipe, context, now, proof, action)?; + review_command(&command) +} + +/// Both installed effect review and the offline reference projection render +/// the native command's compiler output, without a second request compiler. +#[cfg(unix)] +pub(crate) fn review_command( + command: &VerifiedCommand, +) -> Result { let request = &command.request; Ok(GatewaySubmissionReview { schema: "auths.gateway-submission-review/1", @@ -180,7 +189,7 @@ pub fn review_submission( .map(|actor| actor.as_str().to_owned()) .collect(), action_commitment: hex::encode(request.action_commitment()), - arguments: command.arguments, + arguments: command.arguments.clone(), request: GatewayRequestReview { method: request.method().as_str().to_owned(), url: request.url().to_owned(), From c75e16babc19dfce7cc6f1efdb6286337b2f2ba0 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 01:59:20 +0000 Subject: [PATCH 007/136] docs(gateway): harden AP074 deployment and composition contracts --- ...017-bound-effect-and-recovery-ownership.md | 28 +++++ docs/plans/0074-implementation-status.md | 8 ++ ...ound-effects-and-recovery-state-machine.md | 112 ++++++++++++++++++ 3 files changed, 148 insertions(+) diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 17bb9273f..ea341787f 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -49,6 +49,34 @@ the grant and charges before acknowledgement. A committed revocation blocks late grants; an earlier grant may still be exercised. Process-local in-flight counters alone do not establish the multi-process order. +Before the durable mutation cutover, this ADR must record the implemented file +lock and PostgreSQL transaction scopes, lock order, versioned dependency records, +configuration/revocation writer participation, after-lock clock sampling, +verification deadlines and durable acknowledgement. This adapter design is +still open. The present attempt CAS and connection reload do not satisfy it. +Cross-store state requires demonstrated fencing; unsupported atomicity fails +closed. Capacity reserved earlier is checked for intact conservation at grant, +not allocated a second time. + +The installed gateway boundary must exclude untrusted agents from provider +credentials, journal mutation, operator channels and alternate managed transport. +Keep an interface inventory and exercise it from a separate restricted process. +Rust sealed values do not establish process isolation, and independent provider +writers or a malicious trusted host/operator are outside this containment claim. + +Native review must implement a versioned recipe-bound completeness contract. +Missing mandatory fields or an unsupported renderer prevents approval; signing +an effect digest alone does not establish complete presentation. Domain profiles +own the meanings and units of mandatory fields. Faithful presentation makes no +claim about human comprehension. + +Recovery exposes bounded observation work, retained charges and escalation. +Administrative annotations are not provider evidence; no administrative path can +convert post-grant uncertainty into non-entry or silently release capacity. +Future delegated scope and ancestor charges feed this same admission authority, +under atomicity or demonstrated fencing, without a second task/effect journal. +This is an integration boundary only; AP073 remains outside the implementation. + Acquisition, disclosure and mutation are closed typed alternatives. Ancillary credential/account/preflight/observation reads are linked bounded acquisitions. Each disclosure has its own recipient authority, source binding and charge. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 79ef7f9e1..fb45ade23 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -70,6 +70,14 @@ No stage is complete merely because types, documentation or a happy path exist. ## Immediate implementation continuation +The specification hardening pass adds explicit deployment non-bypassability, +versioned review completeness, adapter-specific fencing, six compositional +safety obligations, bounded operational recovery and a future AP073 composition +boundary. These strengthen A01/A02/A04/A06/A11–A13/A15–A18/A20–A22 without +claiming new executed evidence. The existing review and revalidation APIs do +not yet meet review-completeness or transactional-fencing gates. The adapter +mechanism remains an explicit open decision in ADR 0017 before P2 cutover. + 1. Complete the installed policy and IPC review/approve/submit cutover. The new `effect` module currently owns native compile/approve/revalidate operations, but `GatewayEngine::submit`, `SubmitIo`, the application socket and clients diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 0fb17b262..0465f5e02 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -98,6 +98,31 @@ The implementation must write an abstraction case comparing at least the existin This is prelaunch. Replace affected formats and call sites directly, reject obsolete disposable state, and remove superseded production logic. Do not add migration readers, dual journals, compatibility flags or a runtime switch between old and new semantics. Retain independent test oracles and useful historical evidence with their original scope. +### 3.4 Managed deployment and non-bypassability + +Every managed effect MUST pass through bound-effect admission and durable entry. +Inventory application sockets, SDKs, CLI/admin interfaces, credential-bearing +ancillary reads, transport adapters and retained reference paths. No interface +available to the agent may bypass these gates or substitute caller-controlled +transport bytes. An operator commissioning path must satisfy the same effect +binding, approval and entry protocol in addition to its commissioning authority. + +State the deployment threat model: an untrusted agent process is outside the +credential, private review, journal and operator boundaries. The trusted host, +gateway operator, custody service and configured transport enforce those +boundaries. Enumerate credential access, filesystem/process permissions, +authenticated channels and network restrictions needed for the claim. Possession +of unrelated provider credentials, a malicious host/operator, and independent +external writers are not contained by a Rust capability type. Application-owned +reference paths must not be reachable with managed credentials or presented as +managed execution. + +Installed acceptance evidence must run a hostile agent in a separate restricted +process and exercise every inventoried application-facing route, including +malformed/obsolete frames and direct credential/provider access attempts. Record +the actual isolation and egress controls exercised; a negative test alone does +not prove non-bypassability under unspecified deployment conditions. + ## 4. The bound effect contract ### 4.1 Immutable description and identity @@ -136,6 +161,24 @@ limits before the content is fetched; the exact disclosure binding is finalized after acquisition and checked against that consent. It cannot be used to approve a mutation that requires exact human confirmation. Its mere presence must not satisfy an exact-approval requirement. +Each approvable operation MUST declare a versioned review contract, bound through +the approved recipe/compiler semantics and effect identity. It names all +security-critical fields, their types/units and required presentation, including +the destination, action consequences, relevant limits and uncertainty. Domain +profiles define domain-specific fields: a financial profile may require amount, +currency, merchant identity, recurrence and settlement consequences. The shared +gateway must not infer such semantics from provider names or arbitrary prose. + +Native code projects those fields from the same sealed effect. Unsupported +review versions, absent fields, truncation that hides meaning, or an incapable +renderer MUST prevent approval. Untrusted labels/content cannot replace trusted +field names or obscure destinations, units or consequences. The approval channel +must authenticate the approver and associate the displayed projection with the +exact signed effect; an agent's assertion that review occurred is insufficient. +Test rendering failures, substituted labels and changed review semantics. This +establishes faithful, complete presentation under the declared contract, not a +proof that the human understood it. + ### 4.3 Closed transport and custody The private bound value contains the exact method, origin/path/query, noncredential headers, media type, body and closed observation plan. Transport accepts a stage-sealed effect capability, not a second set of URL/body/recipient parameters. Credential injection may fill only the approved credential slot for the bound connection/account/generation. Credentials themselves never enter effect serialization, public commitments, receipts, bindings or agent memory. @@ -235,6 +278,20 @@ For this milestone, provider-entry and disclosure-entry permits are one-use, and - Late valid response/ACK evidence can refine an unknown outcome. Revocation or expiry must not erase legitimate history or prevent recording a previously authorized delivery's exact ACK. Recording history confers no current execution authority. - Read-only recovery requires its own bounded authority and accounting. It cannot borrow a revoked writer's proof, use an expired approval as current authority, acquire broader credentials or change the original actor attribution. +Unresolved effects also have an operational contract. Declare finite observation +attempt/byte/time limits, evidence freshness, and escalation conditions. Expose +the uncertainty, retained charges, last evidence and permitted next actions in +native operator projections. Exhaustion or unavailable evidence leaves the +effect unresolved and charged; it does not schedule an implicit retry, redelivery +or refund. Recovery may remain unresolved indefinitely. + +Administrative annotations must remain distinguishable from verified provider +evidence. Any administrative resolution that changes evidence or accounting must +be an explicit, separately authorized command accepted by the sole reducer under +a declared evidence rule. An operator assertion cannot establish non-entry after +a grant or override the conservation/no-retry rules. Measure bounded recovery +work and the cases actually resolvable, as well as refusal safety. + ### 5.4 Accounting At every committed revision, for each capacity key and unit: @@ -258,6 +315,15 @@ Re-run the full native verifier, or use a mechanically justified equivalent depe Connection, trust, recipe, policy, qualification and admission epoch changes must be ordered with entry or fenced under a demonstrated version protocol. A mutable value checked before waiting for the lock is insufficient. Exact human approval must remain eligible at entry. If durable consent has a distinct validity/revocation contract, make that a separate mode with explicit evidence; never discard approval dependencies accidentally. +At the entry grant's serialization point, the atomic decision requires current +native authority, eligible approval, current configuration and revocation state, +an intact sufficient reservation with conserved accounting, and no previous +grant for that operation's external-entry boundary. Already reserved capacity +must not be charged again as a new allocation. The full check and durable grant +must observe one consistent authoritative state, or an explicitly justified +equivalent fencing protocol. One durable grant does not prove exactly-once +provider execution, settlement or exclusive causation. + ## 6. Journal and persistence contract There must be one logical journal owner for operation identity, reservation, entry grants, protocol outcomes and replay tombstones. Multiple physical records are acceptable only when their safety-critical changes commit atomically. An effect must not acquire two independent mutable truths in a task ledger and an attempt ledger. @@ -273,6 +339,16 @@ For both file and PostgreSQL adapters, specify and exercise: - replay/tombstone retention through the full authority and late-evidence horizon; - bounded garbage collection that cannot resurrect an expired claim or erase unresolved accounting. +Before P2's behavioral cutover, the ownership ADR must name each adapter's exact +lock/transaction scope, acquisition order, authoritative dependency versions, +configuration/revocation writers, isolation/CAS behavior, clock sampling point, +finite work/deadline bound and acknowledgement boundary. It must explain why a +writer in another process cannot change a checked dependency before the grant +without detection or ordered exclusion. Independently stored configuration or +credentials require an explicit fencing/version contract; an attempt-only CAS +or process-local in-flight counter is insufficient. Unsupported cross-store +atomicity must fail closed, not become an undocumented deployment assumption. + Existing file and PostgreSQL behavior must not regress. In-memory adapters are test tools and do not establish durability. File conformance establishes the stated local-filesystem assumptions, not distributed fencing or power-loss behavior on every platform. Whole-store rollback is outside ordinary crash recovery. Keep existing commissioning/generation-floor defenses, bind operations to the admitted epoch, and fail closed when an installed anti-rollback check fails. Where an independent monotonic anchor is absent, explicitly state that restoring all protected state is outside the guarantee. Do not claim that a revision stored in the same restored database detects its own rollback. Building a new consensus service is outside this specification. @@ -325,6 +401,22 @@ Errors distinguish malformed/noncanonical input, unsupported schema/protocol, un | R09 | Recovery has explicit current read-only authority and preserves original effect attribution. | | R10 | Restored state and malformed/obsolete records cannot bypass the declared epoch, retention or durability assumptions. | +The implementation must map these invariants to six system properties: + +| Property | Conditional guarantee | +| --- | --- | +| Authority preservation | Every external entry follows a grant with valid current native authority and eligible approval at its ordered grant point. | +| Effect preservation | Every request/disclosure is the exact compiled and approved effect, including its review contract and allowed credential insertion. | +| Single-grant safety | Each logical operation and external-entry boundary has at most one grant; persisted state cannot remint its permit. | +| Capacity conservation | Concurrent admission, crashes and recovery cannot create authorized capacity or silently refund unknown effects. | +| Revocation ordering | A committed revocation prevents every later grant within its defined scope; earlier grants retain the documented semantics. | +| Evidence soundness | Recorded and displayed claims imply no more than their authenticated evidence establishes. | + +For each property, name the shipping pure predicates, runtime enforcement, +adapter assumptions and model-generated/integration histories that support it. +These are required proof/evidence obligations, not a claim of an already proved +whole-system theorem. Formal claims must state their assumptions and source link. + ## 10. Executable acceptance matrix All rows require reproducible artifacts, expected journal state, expected external calls, actual result, exact revision and limitations. Source code or a passing compilation alone is not behavioral evidence. @@ -354,6 +446,17 @@ All rows require reproducible artifacts, expected journal state, expected extern | A21 | Replay retention, terminal tombstones, stale cache/configuration and supported rollback-floor failures cannot resurrect entry authority. Unsupported whole-store rollback is explicitly excluded. | | A22 | Installed packages and native runtime execute the complete single-human/single-agent read, disclosure, exact write and observation journey; UI distinguishes grant, response, ACK, observation and unknown. | +The same rows additionally require the following hardening cases; these are +part of their exit gates, not optional follow-up work: + +| Cases | Additional adversarial evidence | +| --- | --- | +| A01, A02, A18, A22 | Unsupported review contract, omitted/truncated mandatory field, misleading untrusted label, changed units/destination/consequences and substituted review/signing channel. No approval of an incomplete or mismatched review. | +| A04, A06, A12, A13 | Independent processes race dependency changes against the final grant on both adapters, including state in distinct physical records. Histories satisfy the named fencing mechanism; existing reservations are not charged twice. | +| A11, A15, A22 | Exhaust reconciliation attempts/bytes/time; age its evidence; make authority/store unavailable. Retained charges and escalation remain visible; administrative annotations cannot manufacture non-entry or retry authority. | +| A16, A20 | Scope/participant and charge inputs cannot create a second admission authority. Exercise the current unscoped/single-agent boundary and reject unsupported delegation representations; no AP073 implementation is required. | +| A17, A21, A22 | Hostile isolated agent exercises the complete interface inventory, obsolete endpoints and alternate credential/transport routes. Assert no unauthorized managed provider calls and document the actual isolation assumptions. | + Use external call counters and process failpoints, not only mocked return values or tests asserting the implementation's own intermediate flags. Exercise real local sockets, process restart and the maintained PostgreSQL fixture. Provider-specific live qualification remains a separate claim; no cloud credential should be necessary for the local foundation journey. ## 11. Formal and performance evidence @@ -386,6 +489,15 @@ Done means both central contracts own the maintained paths, obsolete managed int Only after this foundation is closed should multi-agent delegation add participant trees and ancestor budget allocation on top. Those features must consume the established effect and recovery contracts instead of creating their own parallel journals, approval identities or retry rules. +Future AP073 composition must bind the exact participant/executor identity, +task partition/epoch, native authority chain and selected dependencies, scope and +typed ancestor/task charges into the effect. These are inputs to AP074's single +admission authority, never a second independent task approval or mutable effect +journal. Any cross-domain charge/admission update must commit atomically or use +an explicitly justified fencing protocol. Reject unsupported delegated scopes +until that integration is implemented. This contract neither imports AP073 code +nor authorizes work on its paused checkout. + ## References - [Repository contract](../../AGENTS.md). From 7c79532af8f9b7bdd1e1f7eb2aa12ab9cedcc940 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 02:06:32 +0000 Subject: [PATCH 008/136] feat(gateway): require operator-installed effect approval policy --- .../workflows/gateway-operator-package.yml | 3 +- bindings/fixtures/gateway/effect-policy.json | 1 + compliance.toml | 2 +- .../gateway/tools/operator-simulation.py | 4 +- .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 22 ++- docs/plans/0074-implementation-status.md | 29 +++- .../0009-bound-effect-and-recovery.md | 1 + examples/stripe-refund-approval/journey.py | 3 + .../typescript/journey.ts | 7 +- .../auths-gateway/src/bin/auths-gateway.rs | 59 +++++++- .../src/commissioning_session.rs | 1 + .../src/commissioning_session/tests.rs | 1 + product/runtime/auths-gateway/src/effect.rs | 133 ++++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 30 ++-- product/runtime/auths-gateway/src/engine.rs | 57 ++++++++ product/runtime/auths-gateway/src/operator.rs | 38 ++++- .../auths-gateway/src/qualification.rs | 12 ++ .../auths-gateway/tests/admin_capacity.rs | 5 + .../auths-gateway/tests/isolated_process.rs | 5 + .../auths-gateway/tests/operator_plane.rs | 10 ++ .../auths-gateway/tests/qualification_gate.rs | 5 + .../auths-gateway/tests/socket_paths.rs | 5 + .../auths-gateway/tests/support_bundle.rs | 5 + qualification/reference/author_operator.py | 6 +- qualification/reference/custody_fault.py | 2 +- qualification/reference/family_harness.py | 2 + qualification/reference/production_journey.py | 5 + qualification/reference/production_setup.py | 4 +- qualification/simulation/live/airtable.py | 4 +- qualification/simulation/live/stripe.py | 4 +- 30 files changed, 430 insertions(+), 35 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-policy.json diff --git a/.github/workflows/gateway-operator-package.yml b/.github/workflows/gateway-operator-package.yml index 49024f6b0..0f74a8a71 100644 --- a/.github/workflows/gateway-operator-package.yml +++ b/.github/workflows/gateway-operator-package.yml @@ -77,8 +77,9 @@ jobs: cp bindings/fixtures/gateway/airtable/profile.lock.json target/operator-simulation-kit/ cp core/fixtures/v1/denied/untrusted-root.context.cbor target/operator-simulation-kit/trusted.context.cbor cp bindings/fixtures/gateway/custody-hostile.json target/operator-simulation-kit/ + cp bindings/fixtures/gateway/effect-policy.json target/operator-simulation-kit/ cd target/operator-simulation-kit - sha256sum operator-simulation.py recipe.json profile.lock.json trusted.context.cbor custody-hostile.json > SHA256SUMS + sha256sum operator-simulation.py recipe.json profile.lock.json trusted.context.cbor custody-hostile.json effect-policy.json > SHA256SUMS - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 with: name: gateway-operator-simulation-kit diff --git a/bindings/fixtures/gateway/effect-policy.json b/bindings/fixtures/gateway/effect-policy.json new file mode 100644 index 000000000..5680be4f2 --- /dev/null +++ b/bindings/fixtures/gateway/effect-policy.json @@ -0,0 +1 @@ +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"epoch":1,"partition":"synthetic-partition","schema":"auths.effect-policy/1"} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index ddac0718c..ef589aff8 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/5", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/1", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/3", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/3", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] diff --git a/deployment/gateway/tools/operator-simulation.py b/deployment/gateway/tools/operator-simulation.py index 590a156bf..a1d80bcba 100644 --- a/deployment/gateway/tools/operator-simulation.py +++ b/deployment/gateway/tools/operator-simulation.py @@ -84,7 +84,7 @@ def json(self, label, args, **kwargs): return json.loads(self.run(label, args, **kwargs)) def install(self, state, store=None, join=False, secret=None, extra=(), label="install"): - args = ["install", "--state-dir", state, "--recipe", self.inputs / "recipe.json", + args = ["install", "--effect-policy", self.inputs / "effect-policy.json", "--state-dir", state, "--recipe", self.inputs / "recipe.json", "--profile-lock", self.inputs / "profile.lock.json", "--trusted-context", self.inputs / "trusted.context.cbor", "--approve-digest", self.digest, "--provider", "airtable", @@ -174,7 +174,7 @@ def exercise(self): private_tree(first, self.uid, self.gid) self.json("offline-support", ["support-bundle", "--state-dir", first]) # These are shipped builds: neither test transport nor plaintext production is allowed. - args = ["install", "--state-dir", self.work / "production", "--recipe", + args = ["install", "--effect-policy", self.inputs / "effect-policy.json", "--state-dir", self.work / "production", "--recipe", self.inputs / "recipe.json", "--profile-lock", self.inputs / "profile.lock.json", "--trusted-context", self.inputs / "trusted.context.cbor", "--approve-digest", self.digest, "--provider", "airtable", "--alias", "simulation", diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index b5c69dffa..dfb02ebc4 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -18,8 +18,24 @@ A production deployment keeps three principals apart. | Operator | The gateway host, its admin socket, and the provider credentials | A signed operator attestation at install | | Observer | The key that signs what the gateway saw, in qualified custody | Observer anchors of the trusted context | +AP074 installations require an explicit effect policy. Generate its canonical +bytes with native code and the human approver's public Ed25519 key: + +```text +auths-gateway effect-policy --partition --epoch 1 \ + --approver-public-key <64-hex-public-key> > effect-policy.json +``` + +The policy contains no signing key. Protect it as operator configuration. Never +choose a new epoch merely because a journal is missing. The same policy must be +passed to `operator-request` and `install`; the operator signature binds its +partition, epoch and approver. Installation schema `/6` and operator attestation +schema `/2` reject the obsolete formats; reinstall disposable prelaunch state. +This configuration is a foundation for exact-effect approval, not evidence that +transactional entry fencing has been completed. + A production installation names its operator only through a signed -`auths.gateway-operator-attestation/1` statement. `operator-request` prints +`auths.gateway-operator-attestation/2` statement. `operator-request` prints the statement for the installation and the preimage the operator's own signer signs; the operator assembles the statement, the base64url signature, and at most four control-evidence objects into a file of at most 16 KiB, @@ -27,10 +43,10 @@ readable only by its owner: ```text auths-gateway operator-request --recipe recipe.json --profile-lock profile.lock.json \ - --trusted-context trusted.context.cbor --provider --alias \ + --trusted-context trusted.context.cbor --effect-policy effect-policy.json --provider --alias \ --deployment production --operator-principal \ --principal-method did-key-v1 --verification-method --signature-suite ed25519-v1 -auths-gateway install --deployment production --operator-attestation operator-attestation.json ... +auths-gateway install --deployment production --effect-policy effect-policy.json --operator-attestation operator-attestation.json ... ``` `install` and every `serve` start verify the attestation as the kernel diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index fb45ade23..2876b1a94 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -67,6 +67,26 @@ No stage is complete merely because types, documentation or a happy path exist. projection as offline recipe review. It carries the exact effect identity and canonical binding; no binding/UI request reconstruction is needed. Review data explicitly contains private content and has a separate 128 KiB limit. +- Spec hardening committed and pushed as `c75e16ba`: deployment containment, + review completeness, concrete fencing requirements, compositional properties, + operational recovery and the future delegation boundary. +- Required operator `EffectPolicy` now pins partition, epoch and approver. The + engine constructor validates it; installation `/6` and operator attestation + `/2` require and authenticate it. Native `effect-policy` emits canonical + configuration; `install` and `operator-request` require `--effect-policy`. + `GatewayEngine::compile_effect` reads the installed connection and deployment + clock without provider I/O, custody or reservation. Entry fencing and replacing + the baseline submission path remain pending. +- Native fixture generation passed again while producing `effect-policy.json`, + including the private-review assertions previously authored but unexecuted. + Policy refusal and operator-attestation substitution cases are authored, not + yet executed. No hosted workflows have been observed. +- Maintained install callers now pass explicit policy input. Synthetic operator + rehearsal uses the native synthetic fixture; live rehearsal and example + journeys require operator-selected policy files. The production reference + journey requires `AUTHS_QUALIFICATION_EFFECT_POLICY` before infrastructure or + provider work. Live approval-channel integration remains pending; no synthetic + approver is installed implicitly into a live journey. ## Immediate implementation continuation @@ -97,10 +117,11 @@ mechanism remains an explicit open decision in ADR 0017 before P2 cutover. source stabilizes. Required hosted workflows have deliberately not been observed yet. The draft's current CI is not completion evidence. -The native artifact-generation run last passed for the source subsequently -committed in `464f0b2a`. The private-review projection changes have source tests -authored but have not been executed locally. All unfulfilled AP074 gates remain -open, and the goal remains active. +The native artifact-generation run last passed for `c75e16ba` plus the installed +policy source/fixture changes recorded above. It covers native compilation, +canonical policy/binding, private review and exact approval/revalidation, not +installed transport or transactional admission. All unfulfilled AP074 gates +remain open, and the goal remains active. ## Phase gates diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 6047bf86e..6c31e65e4 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -75,6 +75,7 @@ that lookup. Optional task-free scope has an explicit tag distinct from task sco | Journal record / atomic batch | Existing 262,144 bytes / 64 entries | | Events / ACK | 64 events per operation / 4,096 canonical bytes per ACK | | Exact human approval | 4,096 canonical bytes; at most 3,600 seconds, with exclusive expiry | +| Installed effect policy | `MAX_EFFECT_POLICY_BYTES`: 4,096 canonical bytes before decoding; partition at most 512 bytes; explicit nonzero safe-integer epoch; valid nonweak Ed25519 approver | | Private human review | 131,072 bytes including exact request and binding; never a public receipt | | Observation attempts | At most 16 explicitly admitted linked operations | | Transaction lock deadline | 5 seconds; sample time after lock; refuse on deadline | diff --git a/examples/stripe-refund-approval/journey.py b/examples/stripe-refund-approval/journey.py index 53baaeca4..d1a21c340 100644 --- a/examples/stripe-refund-approval/journey.py +++ b/examples/stripe-refund-approval/journey.py @@ -463,6 +463,7 @@ def revoke_installed_connection(gateway: str, journey: "Journey", loopback: List def main() -> int: parser = argparse.ArgumentParser() parser.add_argument("--gateway", required=True, help="auths-gateway binary") + parser.add_argument("--effect-policy", type=Path, required=True, help="Operator-installed human approval policy") parser.add_argument("--summary", type=Path, help="write the timing and result summary here") parser.add_argument("--stripe-test-mode", action="store_true") parser.add_argument("--payment-intent", default="pi_mock_journey") @@ -577,6 +578,8 @@ def install(state_dir: Path, key: str) -> subprocess.CompletedProcess[str]: return journey.run( args.gateway, "install", + "--effect-policy", + str(args.effect_policy.resolve()), "--state-dir", str(state_dir), "--recipe", diff --git a/examples/stripe-refund-approval/typescript/journey.ts b/examples/stripe-refund-approval/typescript/journey.ts index 0b5e980b0..48c1682ce 100644 --- a/examples/stripe-refund-approval/typescript/journey.ts +++ b/examples/stripe-refund-approval/typescript/journey.ts @@ -52,7 +52,7 @@ import { writeFileSync, } from "node:fs"; import { platform } from "node:os"; -import { join } from "node:path"; +import { join, resolve } from "node:path"; import { createInterface } from "node:readline"; import { fileURLToPath } from "node:url"; import { parseArgs } from "node:util"; @@ -384,6 +384,7 @@ async function main(): Promise { const { values } = parseArgs({ options: { gateway: { type: "string" }, + "effect-policy": { type: "string" }, summary: { type: "string" }, python: { type: "string", default: "python3" }, "stripe-test-mode": { type: "boolean", default: false }, @@ -394,6 +395,8 @@ async function main(): Promise { }, }); if (values.gateway === undefined) throw new Error("--gateway PATH/TO/auths-gateway is required"); + const effectPolicy = values["effect-policy"]; + if (effectPolicy === undefined) throw new Error("--effect-policy PATH is required"); const live = values["stripe-test-mode"]!; const paymentIntent = values["payment-intent"]!; const rejectedPaymentIntent = values["rejected-payment-intent"]!; @@ -462,7 +465,7 @@ async function main(): Promise { const install = (stateDir: string, key: string): SpawnSyncReturns => { mkdirSync(stateDir, { mode: 0o700 }); return journey.run(journey.gateway, [ - "install", "--state-dir", stateDir, "--recipe", "recipe.json", + "install", "--effect-policy", resolve(effectPolicy), "--state-dir", stateDir, "--recipe", "recipe.json", "--profile-lock", "profile.lock.json", "--trusted-context", join(journey.state, "trust", "gateway.context.cbor"), "--approve-digest", facts.recipe_digest, "--provider", "stripe", "--alias", "refunds", diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 5483ccda9..782dcde03 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -77,7 +77,7 @@ mod unix { }; use zeroize::{Zeroize as _, Zeroizing}; - const MANIFEST_SCHEMA: &str = "auths.gateway-installation/5"; + const MANIFEST_SCHEMA: &str = "auths.gateway-installation/6"; /// The directory of the state directory that holds the signed /// qualification inputs the operator imported. const QUALIFICATION_DIRECTORY: &str = "qualification"; @@ -157,6 +157,16 @@ mod unix { reason = "one command is parsed per process" )] enum Command { + /// Emit canonical operator configuration for exact effect approval. + /// Supply only the human approver's public key, never a signing key. + EffectPolicy { + #[arg(long)] + partition: String, + #[arg(long)] + epoch: u64, + #[arg(long)] + approver_public_key: String, + }, /// Operator-only install; credential bytes enter through stdin. The /// first host inserts the shared connection record; each further host /// joins it with `--join` and the same secret. @@ -169,6 +179,9 @@ mod unix { profile_lock: PathBuf, #[arg(long)] trusted_context: PathBuf, + /// Canonical operator-selected effect policy (partition, epoch, approver). + #[arg(long)] + effect_policy: PathBuf, #[arg(long)] approve_digest: String, #[arg(long)] @@ -459,6 +472,9 @@ mod unix { profile_lock: PathBuf, #[arg(long)] trusted_context: PathBuf, + /// Canonical operator-selected effect policy (partition, epoch, approver). + #[arg(long)] + effect_policy: PathBuf, #[arg(long)] provider: String, #[arg(long)] @@ -701,6 +717,7 @@ mod unix { recipe_digest: String, profile_lock_sha256: String, trusted_context_sha256: String, + effect_policy: auths_gateway::effect::EffectPolicy, provider: String, alias: String, deployment: Deployment, @@ -926,6 +943,7 @@ mod unix { recipe_digest: self.recipe_digest.clone(), profile_lock_sha256: self.profile_lock_sha256.clone(), trusted_context_sha256: self.trusted_context_sha256.clone(), + effect_policy: self.effect_policy.clone(), provider: self.provider.clone(), alias: self.alias.clone(), deployment: self.deployment.label().to_owned(), @@ -1228,6 +1246,7 @@ mod unix { recipe_path: PathBuf, lock_path: PathBuf, context_path: PathBuf, + effect_policy_path: PathBuf, approved: String, provider_text: String, alias_text: String, @@ -1255,6 +1274,7 @@ mod unix { let source = read_bounded(&recipe_path, 65_536)?; let lock = read_bounded(&lock_path, 65_536)?; let trust = read_bounded(&context_path, 4 * 1024 * 1024)?; + let effect_policy = read_effect_policy(&effect_policy_path)?; let context = auths_codec::decode_verifier_context(&trust) .map_err(|_| "gateway.install.invalid-trusted-context")?; check_anchor_aliasing(&context).map_err(PrincipalSeparationError::code)?; @@ -1282,6 +1302,7 @@ mod unix { recipe_digest: approved, profile_lock_sha256: digest(&lock), trusted_context_sha256: digest(&trust), + effect_policy, provider: provider_text, alias: alias_text, deployment, @@ -1840,11 +1861,20 @@ mod unix { } } + fn read_effect_policy( + path: &Path, + ) -> Result { + let bytes = read_bounded(path, auths_gateway::effect::MAX_EFFECT_POLICY_BYTES)?; + auths_gateway::effect::EffectPolicy::from_private_bytes(&bytes) + .map_err(|_| "gateway.install.invalid-effect-policy") + } + fn installation(state_dir: &Path) -> Result { let manifest_bytes = read_bounded(&state_dir.join("installation.json"), 4_096)?; let manifest: Installation = serde_json::from_slice(&manifest_bytes) .map_err(|_| "gateway.serve.invalid-installation")?; - if manifest.schema != MANIFEST_SCHEMA + if manifest.effect_policy.to_private_bytes().is_err() + || manifest.schema != MANIFEST_SCHEMA || serde_json_canonicalizer::to_vec(&manifest) .map_err(|_| "gateway.serve.invalid-installation")? != manifest_bytes @@ -1967,6 +1997,7 @@ mod unix { recipe, approved, &trust, + manifest.effect_policy.clone(), ProviderKind::parse(manifest.provider.clone()) .map_err(|_| "gateway.serve.invalid-provider")?, ConnectionAlias::parse(manifest.alias.clone()) @@ -3208,6 +3239,7 @@ mod unix { recipe_path: &Path, lock_path: &Path, context_path: &Path, + effect_policy_path: &Path, provider: String, alias: String, deployment: Deployment, @@ -3231,6 +3263,7 @@ mod unix { recipe_digest: recipe.digest_hex(), profile_lock_sha256: digest(&lock), trusted_context_sha256: digest(&trust), + effect_policy: read_effect_policy(effect_policy_path)?, provider, alias, deployment: deployment.label().to_owned(), @@ -3530,11 +3563,30 @@ mod unix { )] pub async fn run() -> Result<(), Failure> { match Cli::parse().command { + Command::EffectPolicy { + partition, + epoch, + approver_public_key, + } => { + let mut approver = [0_u8; 32]; + hex::decode_to_slice(&approver_public_key, &mut approver) + .map_err(|_| "gateway.install.invalid-effect-policy")?; + let policy = auths_gateway::effect::EffectPolicy::new(partition, epoch, approver) + .map_err(|_| "gateway.install.invalid-effect-policy")?; + let bytes = policy + .to_private_bytes() + .map_err(|_| "gateway.install.invalid-effect-policy")?; + std::io::stdout() + .write_all(&bytes) + .map_err(|_| "gateway.output")?; + Ok(()) + } Command::Install { state_dir, recipe, profile_lock, trusted_context, + effect_policy, approve_digest, provider, alias, @@ -3568,6 +3620,7 @@ mod unix { recipe, profile_lock, trusted_context, + effect_policy, approve_digest, provider, alias, @@ -3798,6 +3851,7 @@ mod unix { recipe, profile_lock, trusted_context, + effect_policy, provider, alias, deployment, @@ -3809,6 +3863,7 @@ mod unix { &recipe, &profile_lock, &trusted_context, + &effect_policy, provider, alias, deployment, diff --git a/product/runtime/auths-gateway/src/commissioning_session.rs b/product/runtime/auths-gateway/src/commissioning_session.rs index 9e0d02aa7..d1a30d7e0 100644 --- a/product/runtime/auths-gateway/src/commissioning_session.rs +++ b/product/runtime/auths-gateway/src/commissioning_session.rs @@ -91,6 +91,7 @@ impl GatewayEngine { recipe_digest: self.recipe.digest_hex(), profile_lock_sha256: tuple.profile_lock_sha256.to_hex(), trusted_context_sha256: self.trusted_context_sha256.to_hex(), + effect_policy: self.effect_policy.clone(), provider: self.connection.provider().as_str().to_owned(), alias: self.connection.alias().as_str().to_owned(), deployment: "production".to_owned(), diff --git a/product/runtime/auths-gateway/src/commissioning_session/tests.rs b/product/runtime/auths-gateway/src/commissioning_session/tests.rs index 0a27f81ac..86c870ff9 100644 --- a/product/runtime/auths-gateway/src/commissioning_session/tests.rs +++ b/product/runtime/auths-gateway/src/commissioning_session/tests.rs @@ -161,6 +161,7 @@ impl Setup { .profile_lock_sha256 .to_hex(), trusted_context_sha256: engine.trusted_context_sha256.to_hex(), + effect_policy: engine.effect_policy.clone(), provider: engine.connection.provider().as_str().to_owned(), alias: engine.connection.alias().as_str().to_owned(), deployment: "production".to_owned(), diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 2382ac2f6..e7058f817 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -34,6 +34,104 @@ pub const MAX_EFFECT_APPROVAL_SECONDS: u64 = 3_600; /// Private human review can contain the exact body and full binding. Public /// activity/receipt projections have a different, smaller disclosure contract. pub const MAX_PRIVATE_EFFECT_REVIEW_BYTES: usize = 131_072; +/// Maximum canonical operator effect policy, checked before decoding. +pub const MAX_EFFECT_POLICY_BYTES: usize = 4_096; + +/// Operator-installed replay partition and human approval authority. This is +/// configuration, never authority supplied by an application submission. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct EffectPolicy { + schema: String, + partition: String, + epoch: u64, + approver: [u8; 32], +} + +impl fmt::Debug for EffectPolicy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("EffectPolicy { private: [redacted] }") + } +} + +impl EffectPolicy { + /// Constructs the operator's policy. Epoch changes require deliberate + /// operator action; they must never be inferred from a missing journal. + /// + /// # Errors + /// Refuses invalid partitions, epochs and weak or malformed approver keys. + pub fn new( + partition: String, + epoch: u64, + approver: [u8; 32], + ) -> Result { + let policy = Self { + schema: "auths.effect-policy/1".to_owned(), + partition, + epoch, + approver, + }; + policy.validate()?; + Ok(policy) + } + + pub(crate) fn validate(&self) -> Result<(), EffectBindingError> { + if self.schema != "auths.effect-policy/1" { + return Err(EffectBindingError::Unsupported); + } + if !label(&self.partition) + || !(1..=MAX_SAFE_INTEGER).contains(&self.epoch) + || VerifyingKey::from_bytes(&self.approver).map_or(true, |key| key.is_weak()) + { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + /// Reads a canonical operator policy, with a 4 KiB limit before decoding. + /// + /// # Errors + /// Refuses obsolete, malformed, noncanonical or oversized policy files. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_POLICY_BYTES { + return Err(EffectBindingError::Invalid); + } + let policy: Self = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + policy.validate()?; + if policy.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(policy) + } + + /// Canonical private operator configuration, suitable for installation. + /// + /// # Errors + /// Refuses invalid policy data or an encoding failure. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + self.validate()?; + canonical(self) + } + + pub(crate) fn installation<'a>( + &'a self, + recipe: &'a CompiledRecipe, + context: &'a TrustedContext, + connection: &'a ConnectionRecord, + qualification: QualificationPolicy, + ) -> EffectInstallation<'a> { + EffectInstallation { + recipe, + context, + connection, + partition: &self.partition, + epoch: self.epoch, + qualification, + approver: self.approver, + } + } +} /// Private audit identity. Do not publish it as a hiding content commitment. #[derive(Clone, Copy, Eq, PartialEq)] @@ -840,6 +938,41 @@ mod tests { use super::*; use ed25519_dalek::{Signer as _, SigningKey}; + #[test] + fn installed_policy_is_canonical_bounded_and_never_defaults_authority() { + let public = SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(); + let policy = EffectPolicy::new("partition".to_owned(), 1, public).expect("policy"); + let encoded = policy.to_private_bytes().expect("canonical policy"); + assert_eq!( + EffectPolicy::from_private_bytes(&encoded).expect("policy"), + policy + ); + assert!(EffectPolicy::new(String::new(), 1, public).is_err()); + assert!(EffectPolicy::new("p".repeat(513), 1, public).is_err()); + assert!(EffectPolicy::new("partition".to_owned(), 0, public).is_err()); + assert!(EffectPolicy::new("partition".to_owned(), MAX_SAFE_INTEGER + 1, public).is_err()); + assert!(EffectPolicy::new("partition".to_owned(), 1, [0; 32]).is_err()); + assert!(EffectPolicy::from_private_bytes(&vec![b' '; 4_097]).is_err()); + let mut spaced = encoded.to_vec(); + spaced.push(b'\n'); + assert!(EffectPolicy::from_private_bytes(&spaced).is_err()); + let mut duplicate = encoded.to_vec(); + duplicate.pop(); + duplicate.extend_from_slice(b",\"epoch\":1}"); + assert!(EffectPolicy::from_private_bytes(&duplicate).is_err()); + for field in ["schema", "partition", "epoch", "approver"] { + let mut omitted = serde_json::to_value(&policy).expect("value"); + omitted.as_object_mut().expect("object").remove(field); + assert!(EffectPolicy::from_private_bytes(&canonical(&omitted).expect("JSON")).is_err()); + } + let mut obsolete = serde_json::to_value(&policy).expect("value"); + obsolete["schema"] = serde_json::json!("auths.effect-policy/0"); + assert_eq!( + EffectPolicy::from_private_bytes(&canonical(&obsolete).expect("JSON")), + Err(EffectBindingError::Unsupported) + ); + } + fn wire() -> BindingWire { BindingWire { schema: EFFECT_BINDING_SCHEMA.to_owned(), diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 723ea41c9..d787cf90a 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -2,7 +2,7 @@ //! compilation/approval behavior only; journal and transport evidence is separate. use super::*; -use crate::effect::{EffectBinding, EffectInstallation, compile_mutation_effect}; +use crate::effect::{EffectBinding, EffectInstallation, EffectPolicy, compile_mutation_effect}; use auths_connections::{ ConnectionAlias, ConnectionId, ConnectionProfile, ConnectionRecord, ConnectionState, ProviderKind, SemanticId, @@ -61,15 +61,19 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { let submission = submission(&root, &agent, &grant, &arguments, &[]); let key = SigningKey::from_bytes(&[29; 32]); let public = key.verifying_key().to_bytes(); - let installed = EffectInstallation { - recipe: &recipe, - context: &context, - connection: &connection, - partition: "synthetic-partition", - epoch: 1, - qualification: crate::QualificationPolicy::Optional, - approver: public, - }; + let policy = EffectPolicy::new("synthetic-partition".to_owned(), 1, public) + .expect("installed effect policy"); + let policy_bytes = policy.to_private_bytes().expect("policy bytes"); + assert_eq!( + EffectPolicy::from_private_bytes(&policy_bytes).expect("policy"), + policy + ); + let installed = policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + ); let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) .expect("native effect"); let later = compile_mutation_effect(&installed, NOW + 1, &submission.proof, &submission.action) @@ -131,9 +135,15 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { })).expect("fixture JSON"); let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/effect-binding.json"); + let policy_path = fixture_path.with_file_name("effect-policy.json"); if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { std::fs::write(&fixture_path, &fixture).expect("write native fixture"); + std::fs::write(&policy_path, &policy_bytes).expect("write native policy fixture"); } + assert_eq!( + std::fs::read(&policy_path).expect("policy fixture"), + *policy_bytes + ); assert_eq!( std::fs::read(&fixture_path).expect("native fixture"), fixture diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 96843f0c9..702c098e9 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -67,6 +67,9 @@ pub enum GatewayEngineConfigurationError { /// Independently installed trust is missing or unbounded. #[error("gateway trusted context is missing or unbounded")] InvalidTrust, + /// The independently installed effect policy is malformed or obsolete. + #[error("gateway effect policy is invalid")] + InvalidEffectPolicy, /// The installed recipe differs from the operator-approved digest. #[error("gateway recipe approval digest mismatch")] UnapprovedRecipe, @@ -329,6 +332,7 @@ pub struct GatewayAdminStatus { /// compare-and-swap without waiting for any submission or provider call. pub struct GatewayEngine { recipe: CompiledRecipe, + effect_policy: crate::effect::EffectPolicy, trusted_context: TrustedContext, #[cfg(unix)] trusted_context_sha256: auths_recipe_qualification::Sha256Digest, @@ -384,6 +388,7 @@ impl GatewayEngine { recipe: CompiledRecipe, approved_digest: [u8; 32], trusted_context_cbor: &[u8], + effect_policy: crate::effect::EffectPolicy, provider: ProviderKind, alias: ConnectionAlias, workload_id: String, @@ -391,6 +396,9 @@ impl GatewayEngine { credentials: Arc, attempts: GatewayAttempts, ) -> Result { + effect_policy + .validate() + .map_err(|_| GatewayEngineConfigurationError::InvalidEffectPolicy)?; if trusted_context_cbor.is_empty() || trusted_context_cbor.len() > MAX_CONTEXT_BYTES { return Err(GatewayEngineConfigurationError::InvalidTrust); } @@ -401,6 +409,7 @@ impl GatewayEngine { } Ok(Self { recipe, + effect_policy, trusted_context, #[cfg(unix)] trusted_context_sha256: { @@ -1149,6 +1158,46 @@ impl GatewayEngine { Ok(deleted) } + /// Compiles an effect against operator-installed trust, approval policy and + /// the current shared connection. It reads configuration but performs no + /// provider I/O, credential custody or reservation. The resulting review + /// remains subject to full fresh admission and entry validation. + /// + /// # Errors + /// Refuses unavailable/rolled-back connection state, an ineligible workload, + /// unavailable deployment time, or native compilation failure. + pub async fn compile_effect( + &self, + proof: &[u8], + action: &[u8], + ) -> Result { + let loaded = match self.connection.load().await { + Ok(Some(loaded)) => loaded, + Err(SharedConnectionError::Rollback) => { + return Err(not_entered("gateway.connection.restore-rollback")); + } + Ok(None) | Err(_) => return Err(not_entered("gateway.connection.unavailable")), + }; + if !authorizes_entry(loaded.record(), &self.workload_id, &self.profile) { + return Err(not_entered("gateway.connection.unavailable")); + } + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + crate::effect::compile_mutation_effect( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + ), + now, + proof, + action, + ) + } + /// Verifies and attempts one exact action. Only proof and action bytes are /// accepted from the application; trust, recipe, connection, and credential /// come from the operator's installation. The admission-order step machine @@ -2008,6 +2057,14 @@ pub(crate) mod tests { recipe, digest, &trust, + crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(), + ) + .expect("effect policy"), provider(), alias(), "gateway".to_owned(), diff --git a/product/runtime/auths-gateway/src/operator.rs b/product/runtime/auths-gateway/src/operator.rs index 900e854f4..710b0e23b 100644 --- a/product/runtime/auths-gateway/src/operator.rs +++ b/product/runtime/auths-gateway/src/operator.rs @@ -2,7 +2,7 @@ //! operator principal. //! //! A production installation names its operator only through a signed -//! `auths.gateway-operator-attestation/1` statement, canonical under +//! `auths.gateway-operator-attestation/2` statement, canonical under //! RFC 8785. The signing preimage is the schema, a NUL byte, and the //! canonical statement. It starts with lowercase `auths.`, and every core //! signing preimage starts with `AUTHS`, so the two can never be equal. @@ -25,7 +25,7 @@ use serde::{Deserialize, Serialize}; use thiserror::Error; /// The statement's schema and the preimage's domain. -pub const OPERATOR_ATTESTATION_SCHEMA: &str = "auths.gateway-operator-attestation/1"; +pub const OPERATOR_ATTESTATION_SCHEMA: &str = "auths.gateway-operator-attestation/2"; /// The largest attestation file accepted. pub const MAX_OPERATOR_ATTESTATION_BYTES: usize = 16 * 1024; /// The most control-evidence objects an attestation carries. @@ -73,6 +73,8 @@ pub struct OperatorInstallation { pub profile_lock_sha256: String, /// SHA-256 of the installed trusted context, lowercase hex. pub trusted_context_sha256: String, + /// Exact installed replay partition, epoch and human approver policy. + pub effect_policy: crate::effect::EffectPolicy, /// The provider kind. pub provider: String, /// The connection alias. @@ -163,6 +165,7 @@ pub fn verify_operator_attestation( serde_json::from_slice(bytes).map_err(|_| OperatorAttestationError::Malformed)?; let statement = &file.statement; if statement.schema != OPERATOR_ATTESTATION_SCHEMA + || statement.installation.effect_policy.validate().is_err() || file.evidence.is_empty() || file.evidence.len() > MAX_OPERATOR_EVIDENCE { @@ -283,6 +286,14 @@ mod tests { recipe_digest: "a".repeat(64), profile_lock_sha256: "b".repeat(64), trusted_context_sha256: "c".repeat(64), + effect_policy: crate::effect::EffectPolicy::new( + "operator-test".to_owned(), + 1, + ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(), + ) + .expect("effect policy"), provider: "stripe".to_owned(), alias: "refunds".to_owned(), deployment: "production".to_owned(), @@ -328,7 +339,7 @@ mod tests { Ok(operator.principal.clone()) ); let preimage = signed.statement.preimage().expect("preimage"); - assert!(preimage.starts_with(b"auths.gateway-operator-attestation/1\0{")); + assert!(preimage.starts_with(b"auths.gateway-operator-attestation/2\0{")); } #[test] @@ -339,6 +350,27 @@ mod tests { verify_operator_attestation(&bytes(attestation), &installation(), NOW) }; + let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + let other_public = ed25519_dalek::SigningKey::from_bytes(&[30; 32]) + .verifying_key() + .to_bytes(); + for (partition, epoch, approver) in [ + ("different", 1, public), + ("operator-test", 2, public), + ("operator-test", 1, other_public), + ] { + let mut changed = statement(&operator); + changed.installation.effect_policy = + crate::effect::EffectPolicy::new(partition.to_owned(), epoch, approver) + .expect("changed policy"); + assert_eq!( + check(&attestation(&operator, changed)), + Err(OperatorAttestationError::InstallationMismatch) + ); + } + let mut forged = attestation(&operator, statement(&operator)); forged.signature_b64 = attestation(&other, statement(&operator)).signature_b64; assert_eq!(check(&forged), Err(OperatorAttestationError::Unverified)); diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 1a39a00b4..59ea4b463 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -389,6 +389,18 @@ impl QualificationGate { self.policy } + /// Samples the existing deployment clock for native effect evaluation. + /// Required-policy deployments refuse an untrusted clock. This sample is + /// not an entry fence; admission must sample again under its transaction. + pub(crate) fn effect_time(&self) -> Option { + if self.policy == QualificationPolicy::Required + && self.clock.trust() != ClockTrustState::Trusted + { + return None; + } + self.clock.now() + } + /// Verifies `bundle` under the pinned root and replaces the verified /// result in one step. A bundle equal to the one already held is not /// verified again. Returns whether the held result was replaced. diff --git a/product/runtime/auths-gateway/tests/admin_capacity.rs b/product/runtime/auths-gateway/tests/admin_capacity.rs index 96d2b380f..8de56af3e 100644 --- a/product/runtime/auths-gateway/tests/admin_capacity.rs +++ b/product/runtime/auths-gateway/tests/admin_capacity.rs @@ -171,6 +171,11 @@ fn install(root: &Path, state: &Path) { .digest_hex(); let mut child = Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(state) .arg("--recipe") diff --git a/product/runtime/auths-gateway/tests/isolated_process.rs b/product/runtime/auths-gateway/tests/isolated_process.rs index 325c71383..5cd2a80b9 100644 --- a/product/runtime/auths-gateway/tests/isolated_process.rs +++ b/product/runtime/auths-gateway/tests/isolated_process.rs @@ -127,6 +127,11 @@ fn install( ) -> std::process::Output { let mut child = Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(state) .arg("--recipe") diff --git a/product/runtime/auths-gateway/tests/operator_plane.rs b/product/runtime/auths-gateway/tests/operator_plane.rs index 751d1e530..508525244 100644 --- a/product/runtime/auths-gateway/tests/operator_plane.rs +++ b/product/runtime/auths-gateway/tests/operator_plane.rs @@ -94,6 +94,11 @@ fn install(root: &Path, state: &Path, arguments: &[&str], secret: &[u8]) -> Outp run( Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(state) .arg("--recipe") @@ -464,6 +469,11 @@ fn operator_attestation(root: &Path) -> PathBuf { let request = run( Command::new(BIN) .arg("operator-request") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--recipe") .arg(root.join("recipe.json")) .arg("--profile-lock") diff --git a/product/runtime/auths-gateway/tests/qualification_gate.rs b/product/runtime/auths-gateway/tests/qualification_gate.rs index 2ac21afa3..5b4a90a31 100644 --- a/product/runtime/auths-gateway/tests/qualification_gate.rs +++ b/product/runtime/auths-gateway/tests/qualification_gate.rs @@ -78,6 +78,11 @@ fn install(root: &Path, state: &Path, arguments: &[&str]) -> Output { run( Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(state) .arg("--recipe") diff --git a/product/runtime/auths-gateway/tests/socket_paths.rs b/product/runtime/auths-gateway/tests/socket_paths.rs index dfb5de18a..57d763e1f 100644 --- a/product/runtime/auths-gateway/tests/socket_paths.rs +++ b/product/runtime/auths-gateway/tests/socket_paths.rs @@ -76,6 +76,11 @@ fn install(root: &Path, state: &Path) { .digest_hex(); let mut child = Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(state) .arg("--recipe") diff --git a/product/runtime/auths-gateway/tests/support_bundle.rs b/product/runtime/auths-gateway/tests/support_bundle.rs index a69cfbb8f..c66ff0bb8 100644 --- a/product/runtime/auths-gateway/tests/support_bundle.rs +++ b/product/runtime/auths-gateway/tests/support_bundle.rs @@ -121,6 +121,11 @@ fn a_support_bundle_holds_no_planted_canary() { let installed = run( Command::new(BIN) .arg("install") + .arg("--effect-policy") + .arg(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../../bindings/fixtures/gateway/effect-policy.json" + )) .arg("--state-dir") .arg(&state) .arg("--recipe") diff --git a/qualification/reference/author_operator.py b/qualification/reference/author_operator.py index 3e8455344..6c9f4a9d9 100644 --- a/qualification/reference/author_operator.py +++ b/qualification/reference/author_operator.py @@ -16,7 +16,7 @@ from expand import child, decode, read from resource_io import finish, write -SCHEMA = 'auths.gateway-operator-attestation/1' +SCHEMA = 'auths.gateway-operator-attestation/2' ALIAS = 'recipe-qualification' @@ -56,14 +56,16 @@ def author(gateway, work): '--profile-lock', work / 'profile.lock.json']) require(review['recipe_digest'] == tuple_value['compiled_recipe_sha256'], 'qualification.operator.recipe-binding') + effect_policy = decode(read(work / 'effect-policy.json', 4096)) for context in carrier['trusted_contexts']: installation = {'recipe_digest': tuple_value['compiled_recipe_sha256'], 'profile_lock_sha256': sha256(read(work / 'profile.lock.json', 65536)), 'trusted_context_sha256': sha256(read(work / context, 4 * 1024 * 1024)), + 'effect_policy': effect_policy, 'provider': provider, 'alias': ALIAS, 'deployment': 'production'} require(installation['profile_lock_sha256'] == tuple_value['profile_lock_sha256'], 'qualification.operator.lock-binding') - request = child(gateway, ['operator-request', '--recipe', work / 'recipe.json', + request = child(gateway, ['operator-request', '--effect-policy', work / 'effect-policy.json', '--recipe', work / 'recipe.json', '--profile-lock', work / 'profile.lock.json', '--trusted-context', work / context, '--provider', provider, '--alias', ALIAS, '--deployment', 'production', '--operator-principal', key.principal, '--principal-method', key.principal_method, diff --git a/qualification/reference/custody_fault.py b/qualification/reference/custody_fault.py index f7a0aebc8..4370bc5e8 100644 --- a/qualification/reference/custody_fault.py +++ b/qualification/reference/custody_fault.py @@ -178,7 +178,7 @@ def drift(self, kind, credential, successor): def kind(self): state = self.deployment.gateway / 'refused-plaintext-install' require(not state.exists(), 'qualification.custody.directory') - arguments = ['install', '--state-dir', state, + arguments = ['install', '--effect-policy', self.deployment.gateway / 'effect-policy.json', '--state-dir', state, '--recipe', self.deployment.gateway / 'recipe.json', '--profile-lock', self.deployment.gateway / 'profile.lock.json', '--trusted-context', self.deployment.gateway / 'context-0.cbor', diff --git a/qualification/reference/family_harness.py b/qualification/reference/family_harness.py index b4830dbe0..e4d3db7f7 100644 --- a/qualification/reference/family_harness.py +++ b/qualification/reference/family_harness.py @@ -99,6 +99,8 @@ def prepare(family, work): require(result.returncode == 0, 'qualification.harness.installed-author') tuple_value = candidate(family, work) write(work / 'tuple.json', tuple_value, new=True) + # Credential-free synthetic preparation uses the native synthetic policy corpus. + write_bytes(work / 'effect-policy.json', read(ROOT / 'bindings/fixtures/gateway/effect-policy.json', 4096), new=True) operator = command([python, '-B', kit / 'author_operator.py', '--gateway', gateway(), '--work', work], cwd=work) require(operator.returncode == 0, 'qualification.harness.installed-operator') diff --git a/qualification/reference/production_journey.py b/qualification/reference/production_journey.py index de30a002c..6c50650ce 100644 --- a/qualification/reference/production_journey.py +++ b/qualification/reference/production_journey.py @@ -71,6 +71,10 @@ def __init__(self, family, root, binary, issuer, python, kit, wheel, node, scrip self.run, self.attempt, self.commit = artifact_wait.identity(environment) require(environment.get('GITHUB_ACTIONS') == 'true' and environment.get('RUNNER_ENVIRONMENT') == 'github-hosted', 'qualification.journey.host') + policy_path = environment.get('AUTHS_QUALIFICATION_EFFECT_POLICY') + require(type(policy_path) is str and Path(policy_path).is_absolute(), + 'qualification.journey.effect-policy-required') + self.effect_policy = read(Path(policy_path), 4096) self.family, self.root = family, Path(root).absolute() self.keys = provider_keys(family, environment) require(not self.root.exists() and self.root.resolve() == self.root @@ -85,6 +89,7 @@ def __init__(self, family, root, binary, issuer, python, kit, wheel, node, scrip self.root.mkdir(mode=0o700) self.work = self.root / 'publication' self.work.mkdir(mode=0o700) + write_bytes(self.work / 'effect-policy.json', self.effect_policy, new=True) (self.work / 'cases').mkdir(mode=0o700) self.mailboxes = self.root / 'mailboxes' self.mailboxes.mkdir(mode=0o700) diff --git a/qualification/reference/production_setup.py b/qualification/reference/production_setup.py index 1fba5e52a..705565908 100644 --- a/qualification/reference/production_setup.py +++ b/qualification/reference/production_setup.py @@ -116,7 +116,7 @@ def __init__(self, binary, work, private, environment, canaries): require(family in ['stripe-platform-refund-v1', 'airtable-record-update-v1'], 'qualification.production.family') self.provider = 'stripe' if family == 'stripe-platform-refund-v1' else 'airtable' - for name in ['recipe.json', 'profile.lock.json', 'resources.json', *carrier['trusted_contexts'], + for name in ['recipe.json', 'profile.lock.json', 'resources.json', 'effect-policy.json', *carrier['trusted_contexts'], *[context + '.operator.json' for context in carrier['trusted_contexts']]]: path = self.gateway / name write_bytes(path, read(self.work / name, 4 * 1024 * 1024), new=True) @@ -186,7 +186,7 @@ def install(self, credential, account): state.mkdir(mode=0o700) os.chown(state, GATEWAY_UID, GATEWAY_UID) trust = 'context-' + str(context) + '.cbor' - arguments = ['install', '--state-dir', state, + arguments = ['install', '--effect-policy', self.gateway / 'effect-policy.json', '--state-dir', state, '--recipe', self.gateway / 'recipe.json', '--profile-lock', self.gateway / 'profile.lock.json', '--trusted-context', self.gateway / trust, '--approve-digest', self.tuple['compiled_recipe_sha256'], '--provider', self.provider, '--alias', ALIAS, '--credential-stdin', diff --git a/qualification/simulation/live/airtable.py b/qualification/simulation/live/airtable.py index 5e737ee0c..8d96e7962 100644 --- a/qualification/simulation/live/airtable.py +++ b/qualification/simulation/live/airtable.py @@ -169,7 +169,7 @@ def api(self, method, suffix, body=None): raise Refusal('live.airtable-http-' + str(error.code)) from None def install(self, state, digest, join=False): - argv = [self.binary, 'install', '--state-dir', state, '--recipe', self.work / 'recipe.json', + argv = [self.binary, 'install', '--effect-policy', self.args.effect_policy, '--state-dir', state, '--recipe', self.work / 'recipe.json', '--profile-lock', self.work / 'profile.lock.json', '--trusted-context', self.app / 'context.cbor', '--approve-digest', digest, '--provider', 'airtable', '--alias', 'live-rehearsal', '--attempt-store', self.work / 'store', '--credential-stdin'] @@ -323,6 +323,7 @@ def main(): parser.add_argument('--inputs', type=Path) parser.add_argument('--wheel', type=Path) parser.add_argument('--credential-stdin', action='store_true') + parser.add_argument('--effect-policy', type=Path, help='Operator-installed human approval policy') parser.add_argument('--base') parser.add_argument('--table') parser.add_argument('--commit') @@ -332,6 +333,7 @@ def main(): if args.consumer: consumer(args.consumer, args.consumer_work, args.consumer_socket) return + require(args.effect_policy is not None and args.effect_policy.is_file(), 'live.effect-policy-required') operator = Operator(args) def interrupted(_signal, _frame): raise Refusal('live.interrupted') diff --git a/qualification/simulation/live/stripe.py b/qualification/simulation/live/stripe.py index 8cf14c54e..555a879e2 100644 --- a/qualification/simulation/live/stripe.py +++ b/qualification/simulation/live/stripe.py @@ -238,7 +238,7 @@ def exercise(self): os.chown(self.app / 'plan.json', self.app_uid, self.gid) sdk = json.loads(self.run('installed-consumer-author', self.child('author'), uid=self.app_uid)) require(sdk['sdk_location'].startswith('/opt/consumer/lib/'), 'live.repository-import') - self.run('install', [self.binary, 'install', '--state-dir', self.work / 'state', '--recipe', self.work / 'recipe.json', + self.run('install', [self.binary, 'install', '--effect-policy', self.args.effect_policy, '--state-dir', self.work / 'state', '--recipe', self.work / 'recipe.json', '--profile-lock', self.work / 'profile.lock.json', '--trusted-context', self.app / 'context.cbor', '--approve-digest', review['recipe_digest'], '--provider', 'stripe', '--alias', 'platform-rehearsal', '--account-label', platform, '--credential-stdin'], stdin=(self.keys['STRIPE_TEST_RESTRICTED_KEY'] + '\n').encode()) @@ -308,10 +308,12 @@ def main(): parser.add_argument('--' + name, type=Path) parser.add_argument('--commit') parser.add_argument('--credential-stdin', action='store_true') + parser.add_argument('--effect-policy', type=Path, help='Operator-installed human approval policy') args = parser.parse_args() try: if args.consumer: consumer(args); return + require(args.effect_policy is not None and args.effect_policy.is_file(), 'live.effect-policy-required') operator = Operator(args) def interrupted(_signal, _frame): raise Refusal('live.interrupted') From cd3a34486a59768be593274e60ae848fb160d249 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 02:34:51 +0000 Subject: [PATCH 009/136] feat(gateway)!: require exact bound-effect approval for submission --- .../gateway/effect-approval-request.json | 1 + .../fixtures/gateway/effect-approval.json | 1 + bindings/fixtures/gateway/effect-binding.json | 3 +- bindings/python/python/auths/_public.py | 2 +- bindings/python/python/auths/gateway.py | 9 +- bindings/python/tests/test_gateway_client.py | 16 +- bindings/typescript/src/gateway.ts | 11 +- .../test/unit/gateway-client.test.js | 6 +- compliance.toml | 10 +- .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 28 +++ docs/plans/0074-implementation-status.md | 51 ++++-- ...LE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md | 3 +- examples/stripe-refund-approval/refunds.py | 5 +- .../typescript/refunds.ts | 26 ++- .../runtime/auths-gateway-kernel/src/order.rs | 9 +- product/runtime/auths-gateway/src/app.rs | 91 ++++++++-- .../auths-gateway/src/bin/auths-gateway.rs | 168 +++++++++++++++++- .../src/commissioning_session.rs | 18 +- .../src/commissioning_session/tests.rs | 69 ++++++- product/runtime/auths-gateway/src/effect.rs | 123 ++++++++++++- .../auths-gateway/src/effect_native_tests.rs | 29 ++- product/runtime/auths-gateway/src/engine.rs | 96 +++++++--- product/runtime/auths-gateway/src/harness.rs | 46 ++++- .../auths-gateway/src/scenario_tests.rs | 17 +- product/runtime/auths-gateway/src/submit.rs | 82 ++++++--- 25 files changed, 792 insertions(+), 128 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-approval-request.json create mode 100644 bindings/fixtures/gateway/effect-approval.json diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json new file mode 100644 index 000000000..3d20af181 --- /dev/null +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -0,0 +1 @@ +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json new file mode 100644 index 000000000..04846fadf --- /dev/null +++ b/bindings/fixtures/gateway/effect-approval.json @@ -0,0 +1 @@ +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"tVxnMe0bJwPg9P6NV4a7zGDPy_cgsSXWP5XQIz8J2H2Tur2m38UZUpCuYYThRKKQlyuzEHmjsQnMtT1MlhjrCQ"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 3ee816000..ba586734c 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -9,5 +9,6 @@ "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-Approved\",\"auths_echo\":\"auths-e1-e38d866bf40628b9f92313a8dc13515ad20b2b63498935834e2c6c3435545424\"}}", "evaluated_at": 1790000000, - "approval_expires_at": 1790000030 + "approval_expires_at": 1790000030, + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJjZmM4YjNiNjVjN2Q3NjI0ZjVjMDM4ZjQ5ZThkNzk4NzJiMzI1MTZkZmE3M2EwM2E5OWEwMmE3NjIzY2QyY2MxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwtQXBwcm92ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyMjEsMTkyLDI0MCwzNCw3NywxNDgsMjI4LDgyLDIzOSw2LDE2Niw1NCwxNDksMTkwLDEwNiwyMzcsMTczLDU0LDI0OSwxNDgsMTI3LDEzNCwxMTksNjcsNDMsOSwxMTgsODIsMTA5LDY1LDMzLDc1XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6InRWeG5NZTBiSndQZzlQNk5WNGE3ekdEUHlfY2dzU1hXUDVYUUl6OEoySDJUdXIybTM4VVpVcEN1WVlUaFJLS1FseXV6RUhtanNRbk10VDFNbGhqckNRIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIFB1dw6IqVrQ58Oi4P9Re7Ve2MLzFoKpRm-DZAL7NYcvBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAER3htVt3Aoh5hFUwCLzv5OAc6-IN2aZFFm_1p6QH1o0ziEHaxjl3CForY3H-8nhNwDdp-aOC2bQioKpKcpDIPA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg5OBIkJBwGBaheSXK-uLktL2erWkN-lSFRHqnoPFlmWgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFUeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImNmYzhiM2I2NWM3ZDc2MjRmNWMwMzhmNDllOGQ3OTg3MmIzMjUxNmRmYTczYTAzYTk5YTAyYTc2MjNjZDJjYzEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC1BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/python/python/auths/_public.py b/bindings/python/python/auths/_public.py index 6a143ca7e..5c591c07e 100644 --- a/bindings/python/python/auths/_public.py +++ b/bindings/python/python/auths/_public.py @@ -295,7 +295,7 @@ def runtime_info() -> RuntimeInfo: 1, digest, native == 2, - ("auths.gateway-submit/1",), + ("auths.gateway-submit/2",), (), ("verification", "identity", "gateway.client-v1"), () if native == 2 else ("native ABI mismatch",), diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index 6d102b2cc..1424b8197 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -21,7 +21,7 @@ from pathlib import Path from typing import Final, Literal, Mapping, Optional, Union, cast -_REQUEST_SCHEMA = "auths.gateway-submit/1" +_REQUEST_SCHEMA = "auths.gateway-submit/2" _OBSERVE_SCHEMA = "auths.gateway-observe/2" _READ_BACK_SCHEMA: Final = "auths.gateway-readback/1" _OUTCOME_SCHEMA: Final = "auths.gateway-outcome/2" @@ -428,7 +428,7 @@ def _read_back_request(arguments: Mapping[str, str]) -> dict[str, object]: class GatewayClient: - """Submit only canonical proof and action bytes over the local app socket, + """Submit canonical proof, action and exact approval bytes over the local app socket, or request one read-only gateway-signed observation.""" def __init__(self, endpoint: GatewayEndpoint) -> None: @@ -436,7 +436,7 @@ def __init__(self, endpoint: GatewayEndpoint) -> None: raise TypeError("endpoint must be a GatewayEndpoint") self._endpoint = endpoint - async def submit(self, *, proof: bytes, action: bytes) -> GatewayResult: + async def submit(self, *, proof: bytes, action: bytes, approval: bytes) -> GatewayResult: """Return proof/transport stage without implying provider effect. An IPC failure is not a retry signal: the gateway may have entered the @@ -446,11 +446,14 @@ async def submit(self, *, proof: bytes, action: bytes) -> GatewayResult: raise ValueError("proof must be bounded bytes") if not isinstance(action, bytes) or not 1 <= len(action) <= _MAX_ACTION_BYTES: raise ValueError("action must be bounded bytes") + if not isinstance(approval, bytes) or not 1 <= len(approval) <= 4096: + raise ValueError("approval must be bounded native canonical bytes") payload = json.dumps( { "schema": _REQUEST_SCHEMA, "proof_b64": _encode_base64url(proof), "action_b64": _encode_base64url(action), + "approval_b64": _encode_base64url(approval), }, separators=(",", ":"), ).encode("utf-8") diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index 487e46961..a1109ec7f 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -1,4 +1,4 @@ -"""Proof/action-only application socket behavior with no provider credential.""" +"""Proof/action/exact-approval application socket behavior with no provider credential.""" from __future__ import annotations @@ -65,7 +65,7 @@ def _provider_result(status: object = 200, **evidence: object) -> bytes: @pytest.mark.skipif( sys.platform == "win32", reason="first gateway deployment is Unix-only" ) -def test_client_sends_only_proof_and_action(socket_dir) -> None: +def test_client_sends_proof_action_and_native_approval(socket_dir) -> None: async def scenario() -> None: socket = socket_dir / "gateway.sock" seen: list[dict[str, str]] = [] @@ -84,14 +84,15 @@ async def handle( server = await asyncio.start_unix_server(handle, path=str(socket)) async with server: result = await GatewayClient(GatewayEndpoint(socket)).submit( - proof=b"proof", action=b"action" + proof=b"proof", action=b"action", approval=b"approval" ) assert result == GatewayObserved(status=200, matched=True) assert seen == [ { - "schema": "auths.gateway-submit/1", + "schema": "auths.gateway-submit/2", "proof_b64": "cHJvb2Y", "action_b64": "YWN0aW9u", + "approval_b64": "YXBwcm92YWw", } ] @@ -103,7 +104,10 @@ def test_client_rejects_invalid_endpoint_and_oversized_input(socket_dir) -> None GatewayEndpoint(socket_dir.name) # type: ignore[arg-type] client = GatewayClient(GatewayEndpoint(socket_dir / "gateway.sock")) with pytest.raises(ValueError): - asyncio.run(client.submit(proof=b"", action=b"action")) + asyncio.run(client.submit(proof=b"", action=b"action", approval=b"approval")) + for approval in (b"", b"a" * 4097): + with pytest.raises(ValueError): + asyncio.run(client.submit(proof=b"p", action=b"a", approval=approval)) @pytest.mark.parametrize("code", [ @@ -415,7 +419,7 @@ def test_connect_failure_names_the_path_and_cause(socket_dir: Path) -> None: missing = socket_dir / "missing.sock" client = GatewayClient(GatewayEndpoint(missing)) with pytest.raises(GatewayProtocolError) as failed: - asyncio.run(client.submit(proof=b"p", action=b"a")) + asyncio.run(client.submit(proof=b"p", action=b"a", approval=b"approval")) text = str(failed.value) assert "outcome may be unknown" in text assert str(missing) in text diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index 314d1d1d7..1d0403dd5 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -1,5 +1,5 @@ /** - * Proof/action-only client for a separately operated local Auths gateway. It can also + * Proof/action/exact-approval client for a separately operated local Auths gateway. It can also * ask the gateway for one read-only signed observation to attach to a later action, or * for the signed pre-entry observations stored for one operation. */ @@ -7,7 +7,7 @@ import { createConnection } from "node:net"; import { platform } from "node:os"; -const REQUEST_SCHEMA = "auths.gateway-submit/1"; +const REQUEST_SCHEMA = "auths.gateway-submit/2"; const OBSERVE_SCHEMA = "auths.gateway-observe/2"; const READ_BACK_SCHEMA = "auths.gateway-readback/1"; const OUTCOME_SCHEMA = "auths.gateway-outcome/2"; @@ -18,6 +18,7 @@ const MAX_READ_BACK_ARGUMENTS = 16; const MAX_ARGUMENT_BYTES = 128; const MAX_PROOF_BYTES = 4 * 1024 * 1024; const MAX_ACTION_BYTES = 64 * 1024; +const MAX_APPROVAL_BYTES = 4_096; const MAX_PRE_ENTRY_OBSERVATIONS = 4; // Room for four maximal pre-entry observations in one base64url response. const MAX_RESPONSE_BYTES = 32 * 1024; @@ -371,17 +372,21 @@ export class GatewayClient { this.#endpoint = endpoint; } - async submit(input: Readonly<{ proof: Uint8Array; action: Uint8Array }>): Promise { + async submit(input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Promise { if (!(input.proof instanceof Uint8Array) || input.proof.length < 1 || input.proof.length > MAX_PROOF_BYTES) { throw new TypeError("proof must be bounded bytes"); } if (!(input.action instanceof Uint8Array) || input.action.length < 1 || input.action.length > MAX_ACTION_BYTES) { throw new TypeError("action must be bounded bytes"); } + if (!(input.approval instanceof Uint8Array) || input.approval.length < 1 || input.approval.length > MAX_APPROVAL_BYTES) { + throw new TypeError("approval must be bounded native canonical bytes"); + } const payload = new TextEncoder().encode(JSON.stringify({ schema: REQUEST_SCHEMA, proof_b64: encodeBase64Url(input.proof), action_b64: encodeBase64Url(input.action), + approval_b64: encodeBase64Url(input.approval), })); return this.#exchange(payload, "outcome may be unknown", parseResult); } diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index fd3482028..ae9746dd1 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -28,12 +28,14 @@ test("gateway client submits proof/action only and separates observed from effec const result = await new GatewayClient(new GatewayEndpoint(path)).submit({ proof: new Uint8Array([1, 2]), action: new Uint8Array([3, 4]), + approval: new Uint8Array([5, 6]), }); assert.deepEqual(result, { outcome: "observed", status: 200, matched: true }); assert.deepEqual(seen, [{ - schema: "auths.gateway-submit/1", + schema: "auths.gateway-submit/2", proof_b64: "AQI", action_b64: "AwQ", + approval_b64: "BQY", }]); } finally { await new Promise((resolve) => server.close(resolve)); @@ -73,6 +75,7 @@ test("gateway connect failure names the path and the cause", { skip: process.pla new GatewayClient(new GatewayEndpoint(path)).submit({ proof: new Uint8Array([1]), action: new Uint8Array([2]), + approval: new Uint8Array([3]), }), (error) => error instanceof GatewayProtocolError && error.message.includes(path) && error.message.includes("ENOENT"), ); @@ -101,6 +104,7 @@ async function replyOnce(reply) { return await new GatewayClient(new GatewayEndpoint(path)).submit({ proof: new Uint8Array([1]), action: new Uint8Array([2]), + approval: new Uint8Array([3]), }); } finally { await new Promise((resolve) => server.close(resolve)); diff --git a/compliance.toml b/compliance.toml index ef589aff8..3f12b88b2 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1430,7 +1430,7 @@ kind = "cargo" layer = "bindings" path = "bindings/python" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-identity", "auths-identity-raw-key", "auths-model", "auths-ports", "auths-raw-key", "auths-registries", "auths-signature", "auths-signature-core", "auths-signature-ed25519", "auths-verifier"] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/1", "auths.openapi-derive-result/1", "auths.portable-receipt/1"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.openapi-derive-result/1", "auths.portable-receipt/1"] wire_objects = ["ActionEnvelope", "AuthorizationPlan", "CanonicalAction", "GrantStatement", "GrantStatusSnapshot", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusSnapshot", "PrincipalStatusStatement", "ProofBundle", "SignedAction", "SignedGrant", "SignedGrantStatus", "SignedPrincipalStatus", "VerifierContext"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/openapi-derivation", "bindings/python/differential-fixtures-v1.json", "core/fixtures/v1"] principal_families = ["self-contained-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/3", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/3", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1961,7 +1961,7 @@ kind = "npm" layer = "bindings" path = "bindings/typescript" core_apis = ["auths-openapi-derive-wasm", "auths-proof-wasm"] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/1", "auths.portable-receipt/1"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.portable-receipt/1"] wire_objects = ["ActionEnvelope", "CanonicalAction", "GrantStatement", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusStatement", "ProofBundle", "VerifierContext"] fixture_suites = ["core/fixtures/v1"] principal_families = ["self-contained-v1"] @@ -2007,7 +2007,7 @@ kind = "npm" layer = "demos" path = "demos/stripe-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/1", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] fixture_suites = ["demos/stripe-gateway", "qualification/simulation/live/stripe-platform"] principal_families = ["raw-key-v1"] @@ -2027,7 +2027,7 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/1", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index dfb02ebc4..b2b2a3194 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -34,6 +34,34 @@ schema `/2` reject the obsolete formats; reinstall disposable prelaunch state. This configuration is a foundation for exact-effect approval, not evidence that transactional entry fencing has been completed. +The application submission schema is now `auths.gateway-submit/2`; it requires +canonical native exact-effect approval in addition to proof and action. The +commissioning path requires the same approval. Resource-authority approvals in +the proof remain separate requirements and cannot substitute for it. + +The private operator flow is: + +```text +auths-gateway effect-review --state-dir --proof proof.cbor --action action.cbor \ + --not-before --expires-at --request-out +auths-gateway effect-approval --request --signature-hex +auths-gateway submit --app-socket --proof proof.cbor --action action.cbor --approval +``` + +`effect-review` emits private JSON containing the native review, signing request +and `signing_message_hex`. The external approver signs those exact decoded +32 message bytes with Ed25519; do not independently hash or reconstruct them. +Keep review/request/approval files on the authorized private channel. The +`effect-approval` command only assembles canonical data; submission independently +checks the installed signer, effect binding and validity interval. Missing, +obsolete or invalid approvals are refused before credential leasing. + +AP074 remains under implementation: versioned semantic review completeness, +transactional entry fencing, durable full-binding comparison and controlled +recovery are not established by these commands. The existing example journeys +still need the complete operator review round trip and updated integration +evidence before they demonstrate the revised contract. + A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints the statement for the installation and the preimage the operator's own diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 2876b1a94..a034c1d84 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -53,9 +53,10 @@ No stage is complete merely because types, documentation or a happy path exist. is compilation, canonical round-trip and exact approval, not A01 completion. This local run constructs the required canonical artifact; it is not a broad pre-push verification run. No hosted workflows observed or formal gates run. -- Existing submission still uses the baseline path. P1 is not closed until the - installed review/approval/admission path replaces it. No new effect can yet be - submitted, and the new sealed compilation API grants no execution authority. +- Initially the new effect module was not connected to submission. The installed + approval cutover below now replaces that proof/action-only interface. P1 is + still open for review completeness, full binding persistence and integration + evidence; the existing reservation/entry lifecycle has not been replaced yet. - Added entry validation over the retained original proof/action. It re-runs the full verifier, compares the complete newly compiled binding, and checks the original human approval at the supplied transaction time. The installed exact @@ -87,6 +88,28 @@ No stage is complete merely because types, documentation or a happy path exist. journey requires `AUTHS_QUALIFICATION_EFFECT_POLICY` before infrastructure or provider work. Live approval-channel integration remains pending; no synthetic approver is installed implicitly into a live journey. +- The installed mutation and commissioning APIs now require native exact effect + approval. The shared driver owns `ApprovedEffect`, accesses its single sealed + command, and revalidates original proof/approval against prepared configuration + before claim and before send. Its clock now uses the existing deployment clock. + These checks are not a transaction fence. Full binding is not yet persisted in + the attempt journal; ancillary reads and replay observation still need their + separately authorized acquisition/recovery cutover. +- Application socket `/2` requires bounded canonical approval bytes; `/1` and + missing approvals are rejected. Python/TypeScript wrappers carry those native + bytes without hashing or signing. Private `effect-review` and `effect-approval` + CLI commands expose native review/signing data and canonical envelope assembly. + Source tests cover obsolete/missing/oversized frames and installed wrong-signer + or expired approval with zero custody/transport calls; these tests are authored, + not executed. Test-only post-verification driver oracles use explicitly synthetic + approvals and establish no human or installed-authority claim. +- The targeted native generator passed while constructing the `/2` frame and + `effect-approval-request.json`. Running the native CLI to construct + `effect-approval.json` succeeded and its bytes equal the native signed corpus. + This artifact construction also compiled the gateway binary. No broad local + suite or hosted workflow was run/observed. Installed binding journeys, example + proof preparation/review, qualification consumers and semantic closure/formal + regeneration still require updates for the new approval round trip. ## Immediate implementation continuation @@ -98,11 +121,13 @@ claiming new executed evidence. The existing review and revalidation APIs do not yet meet review-completeness or transactional-fencing gates. The adapter mechanism remains an explicit open decision in ADR 0017 before P2 cutover. -1. Complete the installed policy and IPC review/approve/submit cutover. The new - `effect` module currently owns native compile/approve/revalidate operations, - but `GatewayEngine::submit`, `SubmitIo`, the application socket and clients - still use the baseline proof/action submission. Replace that path with the - approved effect; do not leave a bypass or an optional compatibility mode. +1. Complete the versioned semantic review contract and full operator review round + trip in maintained consumers. Installed submit and commissioning now require + exact approval, but the native raw review projection does not yet establish + the newly required mandatory-field presentation contract. Update installed + binding tests and example/qualification authoring so original proof bytes are + preserved from review through submission; never synthesize human approval in + an ordinary application wrapper. 2. Store the complete immutable binding in the existing attempt journal, with replay keyed independently of the effect digest. Reuse the approved effect's single owned command for send and reporting; reject changed binding as conflict. @@ -117,10 +142,12 @@ mechanism remains an explicit open decision in ADR 0017 before P2 cutover. source stabilizes. Required hosted workflows have deliberately not been observed yet. The draft's current CI is not completion evidence. -The native artifact-generation run last passed for `c75e16ba` plus the installed -policy source/fixture changes recorded above. It covers native compilation, -canonical policy/binding, private review and exact approval/revalidation, not -installed transport or transactional admission. All unfulfilled AP074 gates +The native artifact-generation run last passed for `7c79532a` plus the installed +approval and native signing/frame fixture changes recorded above. CLI canonical +envelope generation then passed against that same native corpus. These cover +compilation, canonical policy/binding, private review and exact approval data, +not installed transport or transactional admission. Subsequent refusal tests +and input-zeroization edits are source-authored only. All unfulfilled AP074 gates remain open, and the goal remains active. ## Phase gates diff --git a/docs/target-state/PROFILE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md b/docs/target-state/PROFILE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md index 450e5481e..51f39b1d3 100644 --- a/docs/target-state/PROFILE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md +++ b/docs/target-state/PROFILE_AND_DOMAIN_ABSTRACTION_BOUNDARY_PLAN.md @@ -125,7 +125,8 @@ makes the data-only gateway of [AP-SPEC-053](../specs/0053-declarative-credential-isolated-gateway.md), as generalized by [AP-SPEC-063](../specs/0063-generalized-gateway.md), the production mechanism for credential-isolated provider writes. Its application -channel supplies proof and canonical action only; an operator separately +channel supplies proof, canonical action and native exact-effect approval; +an operator separately approves the typed recipe digest, trust, connection, and credential generation. The gateway owns the shared mechanics once: bounded request construction, the atomic claim, the spend limit, attempt records, recovery, diff --git a/examples/stripe-refund-approval/refunds.py b/examples/stripe-refund-approval/refunds.py index 6c185f0ee..767e372a4 100644 --- a/examples/stripe-refund-approval/refunds.py +++ b/examples/stripe-refund-approval/refunds.py @@ -610,7 +610,9 @@ async def _submit(args: argparse.Namespace) -> Dict[str, Any]: ) proof = collection.assemble(action) gateway = GatewayClient(GatewayEndpoint(args.socket.resolve())) - result = await gateway.submit(proof=proof, action=proposal.action) + with args.effect_approval.open("rb") as approval_file: + approval = approval_file.read(4097) + result = await gateway.submit(proof=proof, action=proposal.action, approval=approval) record.update(dataclasses.asdict(result)) record["decided_by"] = "gateway" observation = await gateway.observe_outcome(args.operation_id) @@ -693,6 +695,7 @@ def main(argv: Optional[List[str]] = None) -> int: submit = commands.add_parser("submit", help="collect the responses and submit through the gateway") submit.add_argument("--state", type=Path, required=True) submit.add_argument("--socket", type=Path, required=True) + submit.add_argument("--effect-approval", type=Path, required=True, help="native exact-effect approval") submit.add_argument("--operation-id", required=True) submit.add_argument("--responses", type=Path, required=True, help="directory of *.response files") bundle = commands.add_parser("export", help="write the audit bundle") diff --git a/examples/stripe-refund-approval/typescript/refunds.ts b/examples/stripe-refund-approval/typescript/refunds.ts index 4525b4b18..f63e70773 100644 --- a/examples/stripe-refund-approval/typescript/refunds.ts +++ b/examples/stripe-refund-approval/typescript/refunds.ts @@ -39,7 +39,7 @@ import { execFileSync } from "node:child_process"; import { createHash, randomBytes } from "node:crypto"; import { - appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, writeFileSync, + appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, writeFileSync, } from "node:fs"; import { dirname, join, resolve } from "node:path"; import { fileURLToPath } from "node:url"; @@ -569,8 +569,26 @@ function recordEntry(audit: string, entry: Entry): "appended" | "replaced" | "un return "unchanged"; } +function readEffectApproval(path: string): Uint8Array { + const file = openSync(path, "r"); + try { + const bytes = new Uint8Array(4097); + let length = 0; + while (length < bytes.length) { + const count = readSync(file, bytes, length, bytes.length - length, null); + if (count === 0) break; + length += count; + } + // The native client enforces its public bound; parsing and signature + // validation remain in the gateway. + return bytes.subarray(0, length); + } finally { + closeSync(file); + } +} + async function submit(options: Readonly<{ - state: string; socket: string; operationId: string; responses: string; + state: string; socket: string; operationId: string; responses: string; effectApproval: string; }>): Promise> { const state = options.state; const facts = JSON.parse(readFileSync(join(state, "setup.json"), "utf8")) as SetupFacts; @@ -619,7 +637,7 @@ async function submit(options: Readonly<{ }); const proof = collection.assemble(action); const gateway = new GatewayClient(new GatewayEndpoint(resolve(options.socket))); - Object.assign(record, await gateway.submit({ proof, action: built.action }), { decided_by: "gateway" }); + Object.assign(record, await gateway.submit({ proof, action: built.action, approval: readEffectApproval(options.effectApproval) }), { decided_by: "gateway" }); const observation = await gateway.observeOutcome(options.operationId); const outcome = observation.outcome === "signed" ? observation.observation : null; record.bundle = recordEntry(join(state, "audit"), { @@ -694,6 +712,7 @@ async function main(): Promise { amount: { type: "string" }, required: { type: "string" }, responses: { type: "string" }, + "effect-approval": { type: "string" }, out: { type: "string" }, precheck: { type: "boolean", default: false }, help: { type: "boolean", default: false }, @@ -746,6 +765,7 @@ async function main(): Promise { socket: required(values.socket, "socket"), operationId: required(values["operation-id"], "operation-id"), responses: resolve(required(values.responses, "responses")), + effectApproval: resolve(required(values["effect-approval"], "effect-approval")), }))}\n`); break; case "export": diff --git a/product/runtime/auths-gateway-kernel/src/order.rs b/product/runtime/auths-gateway-kernel/src/order.rs index fdd14a801..22f76a58c 100644 --- a/product/runtime/auths-gateway-kernel/src/order.rs +++ b/product/runtime/auths-gateway-kernel/src/order.rs @@ -7,16 +7,17 @@ //! read, a store write, and the provider write each happen only when the //! machine names them, and the machine names them only in this order: //! -//! 1. read the clock, verify natively, admit (with the account-scope binding -//! when declared), and prepare the transport, storing nothing; +//! 1. read the clock, verify native authority and exact effect approval, admit +//! (with the account-scope binding when declared), and prepare the transport, +//! revalidating the approved effect against that installation, storing nothing; //! 2. claim the logical operation; a replay goes to one read-only //! re-observation and never to a write; //! 3. reload the connection record, lease the credential, check the prefix, //! the account read, and each denied read; //! 4. run the pre-entry re-read and the relative-ceiling read, when declared, //! and record what they read in one checkpoint; -//! 5. reload the connection record again, refuse entry after the deadline, -//! and send the one write; +//! 5. reload the connection record again, refuse entry after the deadline or +//! failed fresh authority/approval validation, and send the one write; //! 6. record the response or `unknown`, then at most one read-back under a //! fresh lease that passes the same credential checks. //! diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 967e1c4fa..2a9f228c9 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -3,6 +3,7 @@ //! submission or an observation request; anything else is refused without //! reaching the application. +use crate::effect::{ExactEffectApproval, MAX_EFFECT_APPROVAL_BYTES}; use crate::{GatewayEngine, GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult}; use base64ct::{Base64UrlUnpadded, Encoding as _}; use serde::{Deserialize, Serialize}; @@ -12,9 +13,10 @@ use std::time::Duration; use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _}; use tokio::net::UnixStream; use tokio::time::{Instant, sleep_until, timeout_at}; +use zeroize::{Zeroize as _, Zeroizing}; /// Schema of a proof/action submission frame. -pub const APP_REQUEST_SCHEMA: &str = "auths.gateway-submit/1"; +pub const APP_REQUEST_SCHEMA: &str = "auths.gateway-submit/2"; /// Schema of an observation request frame. pub const APP_OBSERVE_SCHEMA: &str = "auths.gateway-observe/2"; /// Largest frame either side accepts. @@ -133,6 +135,16 @@ pub struct AppSubmission { pub proof_b64: String, /// Canonical action bytes, unpadded base64url. pub action_b64: String, + /// Native canonical exact-effect approval, unpadded base64url. + pub approval_b64: String, +} + +impl Drop for AppSubmission { + fn drop(&mut self) { + self.proof_b64.zeroize(); + self.action_b64.zeroize(); + self.approval_b64.zeroize(); + } } /// An observation request frame. @@ -171,7 +183,12 @@ pub(crate) fn frame_kind(bytes: &[u8]) -> Option<&'static str> { /// harness that follows the same dispatch against a counting provider. pub trait GatewayApplication { /// Verifies and attempts one exact action. - fn submit(&self, proof: &[u8], action: &[u8]) -> impl Future; + fn submit( + &self, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> impl Future; /// Signs one read-only observation. fn observe( @@ -181,8 +198,13 @@ pub trait GatewayApplication { } impl GatewayApplication for GatewayEngine { - async fn submit(&self, proof: &[u8], action: &[u8]) -> GatewaySubmitResult { - GatewayEngine::submit(self, proof, action).await + async fn submit( + &self, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> GatewaySubmitResult { + GatewayEngine::submit(self, proof, action, approval).await } async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { @@ -236,12 +258,20 @@ fn invalid_frame() -> GatewaySubmitResult { } async fn submit_frame(submission: AppSubmission, application: &impl GatewayApplication) -> Vec { - let result = if submission.schema == APP_REQUEST_SCHEMA { + let result = if submission.schema == APP_REQUEST_SCHEMA + && submission.approval_b64.len() <= (MAX_EFFECT_APPROVAL_BYTES * 4).div_ceil(3) + { match ( - Base64UrlUnpadded::decode_vec(&submission.proof_b64), - Base64UrlUnpadded::decode_vec(&submission.action_b64), + Base64UrlUnpadded::decode_vec(&submission.proof_b64).map(Zeroizing::new), + Base64UrlUnpadded::decode_vec(&submission.action_b64).map(Zeroizing::new), + Base64UrlUnpadded::decode_vec(&submission.approval_b64) + .ok() + .map(Zeroizing::new) + .and_then(|bytes| ExactEffectApproval::from_private_bytes(&bytes).ok()), ) { - (Ok(proof), Ok(action)) => application.submit(&proof, &action).await, + (Ok(proof), Ok(action), Some(approval)) => { + application.submit(&proof, &action, approval).await + } _ => GatewaySubmitResult::Indeterminate { code: "gateway.submit.invalid-encoding".to_owned(), }, @@ -327,7 +357,12 @@ mod tests { } impl GatewayApplication for HeldApplication { - async fn submit(&self, _proof: &[u8], _action: &[u8]) -> GatewaySubmitResult { + async fn submit( + &self, + _proof: &[u8], + _action: &[u8], + _approval: ExactEffectApproval, + ) -> GatewaySubmitResult { self.release.notified().await; self.finished.store(true, Ordering::SeqCst); GatewaySubmitResult::Indeterminate { @@ -343,14 +378,50 @@ mod tests { } fn submission() -> Vec { + let fixture: serde_json::Value = serde_json::from_str(include_str!( + "../../../../bindings/fixtures/gateway/effect-binding.json" + )) + .expect("native fixture"); + let approval = fixture["approval_canonical"].as_str().expect("approval"); serde_json::to_vec(&serde_json::json!({ "schema": APP_REQUEST_SCHEMA, "proof_b64": "AA", - "action_b64": "AA" + "action_b64": "AA", + "approval_b64": Base64UrlUnpadded::encode_string(approval.as_bytes()) })) .expect("submission frame") } + #[tokio::test] + async fn obsolete_missing_and_oversized_approval_frames_do_not_dispatch() { + let valid: serde_json::Value = serde_json::from_slice(&submission()).expect("frame"); + let mut missing = valid.clone(); + missing + .as_object_mut() + .expect("object") + .remove("approval_b64"); + assert!(serde_json::from_value::(missing).is_err()); + for (field, value) in [ + ("schema", "auths.gateway-submit/1".to_owned()), + ("approval_b64", "x".repeat(MAX_EFFECT_APPROVAL_BYTES * 2)), + ("approval_b64", "not+base64url".to_owned()), + ] { + let mut changed = valid.clone(); + changed[field] = serde_json::Value::String(value); + let frame: AppSubmission = serde_json::from_value(changed).expect("typed frame"); + let application = HeldApplication::new(1); + let output = tokio::time::timeout( + Duration::from_millis(100), + submit_frame(frame, application.as_ref()), + ) + .await + .expect("refusal without dispatch"); + let result: GatewaySubmitResult = serde_json::from_slice(&output).expect("result"); + assert!(matches!(result, GatewaySubmitResult::Indeterminate { .. })); + assert!(!application.finished.load(Ordering::SeqCst)); + } + } + const SHORT: SessionLimits = SessionLimits { frame_read: Duration::from_millis(200), result_wait: Duration::from_millis(200), diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 782dcde03..dc4c134f4 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -167,6 +167,31 @@ mod unix { #[arg(long)] approver_public_key: String, }, + /// Private native review of the installed exact effect, with a bounded + /// signing request. Does not lease credentials or enter provider transport. + EffectReview { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + not_before: u64, + #[arg(long)] + expires_at: u64, + /// New absolute owner-private file for the canonical signing request. + #[arg(long)] + request_out: PathBuf, + }, + /// Attach an external reviewer's Ed25519 signature to native signing + /// data. Submission still verifies installed trust, binding and time. + EffectApproval { + #[arg(long)] + request: PathBuf, + #[arg(long)] + signature_hex: String, + }, /// Operator-only install; credential bytes enter through stdin. The /// first host inserts the shared connection record; each further host /// joins it with `--join` and the same secret. @@ -336,6 +361,9 @@ mod unix { proof: PathBuf, #[arg(long)] action: PathBuf, + /// Canonical native exact-effect approval from the authorized reviewer. + #[arg(long)] + approval: PathBuf, }, /// Ask the private operator socket to disable new writes in every /// process sharing the store. @@ -414,6 +442,9 @@ mod unix { proof: PathBuf, #[arg(long)] action: PathBuf, + /// Canonical native exact-effect approval from the authorized reviewer. + #[arg(long)] + approval: PathBuf, /// Optional new owner-private file of bounded, secret-free counter /// snapshots. Read-only diagnostics; never a remote effect claim. #[arg(long)] @@ -2776,15 +2807,16 @@ mod unix { engine: &GatewayEngine, proof: &[u8], action: &[u8], + approval: auths_gateway::effect::ExactEffectApproval, witness_file: Option<&Path>, before: &auths_gateway::GatewayExecutionWitness, ) -> Result<(GatewaySubmitResult, Option<&'static str>), Failure> { let Some(path) = witness_file else { - return Ok((session.submit(proof, action).await, None)); + return Ok((session.submit(proof, action, approval).await, None)); }; let mut witness = CommissioningWitnessFile::open(path)?; witness.record(before.clone())?; - let submission = session.submit(proof, action); + let submission = session.submit(proof, action, approval); tokio::pin!(submission); let mut interval = tokio::time::interval(Duration::from_millis(10)); interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); @@ -2808,7 +2840,7 @@ mod unix { /// Direct operator process; ordinary application handlers never call this. async fn commissioning( options: &CommissioningOptions, - command: Option<(&Path, &Path)>, + command: Option<(&Path, &Path, &Path)>, witness_file: Option<&Path>, ) -> Result<(), Failure> { use auths_recipe_qualification::{ @@ -2861,7 +2893,8 @@ mod unix { "{{\"outcome\":\"commissioning-registered\",\"qualification\":\"required\"}}" ); } - Some((proof, action)) => { + Some((proof, action, approval)) => { + let approval = read_effect_approval(approval)?; let proof = read_bounded(proof, 4 * 1024 * 1024)?; let action = read_bounded(action, 64 * 1024)?; let before = engine.execution_witness(); @@ -2870,6 +2903,7 @@ mod unix { &engine, &proof, &action, + approval, witness_file, &before, ) @@ -2893,13 +2927,85 @@ mod unix { Ok(()) } - async fn submit(socket: PathBuf, proof: PathBuf, action: PathBuf) -> Result<(), Failure> { + fn read_effect_approval( + path: &Path, + ) -> Result { + let bytes = read_bounded(path, auths_gateway::effect::MAX_EFFECT_APPROVAL_BYTES)?; + auths_gateway::effect::ExactEffectApproval::from_private_bytes(&bytes) + .map_err(|_| "gateway.effect.approval") + } + + #[allow(clippy::too_many_arguments)] + async fn effect_review( + state_dir: PathBuf, + proof: PathBuf, + action: PathBuf, + not_before: u64, + expires_at: u64, + request_out: PathBuf, + ) -> Result<(), Failure> { + private_root(&state_dir)?; + if !request_out.is_absolute() { + return Err("gateway.state.invalid-path".into()); + } + let engine = tokio::task::spawn_blocking(move || load_engine(&state_dir)) + .await + .map_err(|_| "gateway.effect.unavailable")??; + let proof = read_bounded(&proof, 4 * 1024 * 1024)?; + let action = read_bounded(&action, 64 * 1024)?; + let effect = engine + .compile_effect(&proof, &action) + .await + .map_err(|_| "gateway.effect.review-refused")?; + let request = effect + .approval_request(not_before, expires_at) + .map_err(|_| "gateway.effect.approval")?; + let review = effect + .private_review() + .map_err(|_| "gateway.effect.review-refused")?; + let signing_message = request + .signing_message() + .map_err(|_| "gateway.effect.approval")?; + let output = Zeroizing::new( + serde_json_canonicalizer::to_vec(&serde_json::json!({ + "schema": "auths.private-effect-signing/1", + "review": review, + "approval_request": request, + "signing_message_hex": hex::encode(signing_message), + })) + .map_err(|_| "gateway.output")?, + ); + if output.len() > auths_gateway::effect::MAX_PRIVATE_EFFECT_REVIEW_BYTES { + return Err("gateway.effect.review-refused".into()); + } + private_file( + &request_out, + &request + .to_private_bytes() + .map_err(|_| "gateway.effect.approval")?, + )?; + std::io::stdout() + .write_all(&output) + .map_err(|_| "gateway.output")?; + Ok(()) + } + + async fn submit( + socket: PathBuf, + proof: PathBuf, + action: PathBuf, + approval: PathBuf, + ) -> Result<(), Failure> { + let approval = read_effect_approval(&approval)? + .to_private_bytes() + .map_err(|_| "gateway.effect.approval")?; let proof = read_bounded(&proof, 4 * 1024 * 1024)?; let action = read_bounded(&action, 64 * 1024)?; let request = AppSubmission { schema: APP_REQUEST_SCHEMA.to_owned(), proof_b64: Base64UrlUnpadded::encode_string(&proof), action_b64: Base64UrlUnpadded::encode_string(&action), + approval_b64: Base64UrlUnpadded::encode_string(&approval), }; let bytes = serde_json::to_vec(&request).map_err(|_| "gateway.submit.encoding-failed")?; let mut stream = connect_app_socket(&socket, "gateway.submit.socket-unavailable").await?; @@ -3563,6 +3669,45 @@ mod unix { )] pub async fn run() -> Result<(), Failure> { match Cli::parse().command { + Command::EffectReview { + state_dir, + proof, + action, + not_before, + expires_at, + request_out, + } => { + effect_review( + state_dir, + proof, + action, + not_before, + expires_at, + request_out, + ) + .await + } + Command::EffectApproval { + request, + signature_hex, + } => { + let bytes = + read_bounded(&request, auths_gateway::effect::MAX_EFFECT_APPROVAL_BYTES)?; + let request = + auths_gateway::effect::EffectApprovalRequest::from_private_bytes(&bytes) + .map_err(|_| "gateway.effect.approval")?; + let mut signature = [0_u8; 64]; + hex::decode_to_slice(signature_hex, &mut signature) + .map_err(|_| "gateway.effect.approval")?; + let approval = request + .with_signature(signature) + .to_private_bytes() + .map_err(|_| "gateway.effect.approval")?; + std::io::stdout() + .write_all(&approval) + .map_err(|_| "gateway.output")?; + Ok(()) + } Command::EffectPolicy { partition, epoch, @@ -3708,8 +3853,16 @@ mod unix { session, proof, action, + approval, witness_file, - } => commissioning(&session, Some((&proof, &action)), witness_file.as_deref()).await, + } => { + commissioning( + &session, + Some((&proof, &action, &approval)), + witness_file.as_deref(), + ) + .await + } #[cfg(feature = "loopback-provider")] Command::Serve { state_dir, @@ -3788,7 +3941,8 @@ mod unix { app_socket, proof, action, - } => submit(app_socket, proof, action).await, + approval, + } => submit(app_socket, proof, action, approval).await, Command::Disable { state_dir, admin_socket, diff --git a/product/runtime/auths-gateway/src/commissioning_session.rs b/product/runtime/auths-gateway/src/commissioning_session.rs index d1a30d7e0..971da6562 100644 --- a/product/runtime/auths-gateway/src/commissioning_session.rs +++ b/product/runtime/auths-gateway/src/commissioning_session.rs @@ -184,11 +184,23 @@ impl CommissioningSession<'_> { /// No proof/request can select this method through an ordinary app socket. /// The exact actor and action must match the finite signed permit; before /// every custody acquisition an atomic lifetime unit and host floor commit. - pub async fn submit(&self, proof: &[u8], action: &[u8]) -> GatewaySubmitResult { + pub async fn submit( + &self, + proof: &[u8], + action: &[u8], + approval: crate::effect::ExactEffectApproval, + ) -> GatewaySubmitResult { + let approved = match self + .engine + .approve_submission(proof, action, approval) + .await + { + Ok(approved) => approved, + Err(result) => return result, + }; let io = EngineIo { engine: self.engine, - proof, - action, + pending: std::sync::Mutex::new(Some(approved)), started: Instant::now(), prepared: OnceLock::new(), commissioning: Some(self), diff --git a/product/runtime/auths-gateway/src/commissioning_session/tests.rs b/product/runtime/auths-gateway/src/commissioning_session/tests.rs index 86c870ff9..bc65ff1f7 100644 --- a/product/runtime/auths-gateway/src/commissioning_session/tests.rs +++ b/product/runtime/auths-gateway/src/commissioning_session/tests.rs @@ -233,11 +233,24 @@ fn signed( QualificationCommissioningPermit::from_body(&body).expect("signed synthetic permit") } -fn io<'a>(setup: &'a Setup, session: Option<&'a CommissioningSession<'a>>) -> EngineIo<'a> { +async fn io<'a>(setup: &'a Setup, session: Option<&'a CommissioningSession<'a>>) -> EngineIo<'a> { + let effect = setup + .engine() + .compile_effect(&setup.proof, &setup.action) + .await + .expect("native bound effect"); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let request = effect.approval_request(NOW, NOW + 3_600).expect("review"); + let signature = key + .sign(&request.signing_message().expect("native message")) + .to_bytes(); + let approved = effect + .approve(request.with_signature(signature), &public, NOW) + .expect("exact approval"); EngineIo { engine: setup.engine(), - proof: &setup.proof, - action: &setup.action, + pending: std::sync::Mutex::new(Some(approved)), started: Instant::now(), prepared: OnceLock::new(), commissioning: session, @@ -254,7 +267,7 @@ async fn ordinary_submission_cannot_select_commissioning_authority() { .commissioning_session(&setup.inputs()) .expect("operator"); session.initialize_budget().await.expect("registered"); - let ordinary = io(&setup, None); + let ordinary = io(&setup, None).await; ordinary.verify(NOW).expect("native proof"); assert_eq!( ordinary.prepare().await, @@ -274,6 +287,46 @@ async fn ordinary_submission_cannot_select_commissioning_authority() { assert!(!setup.engine().qualification().status().permits_lease()); } +#[tokio::test] +async fn installed_submission_refuses_wrong_or_expired_exact_approval_before_custody() { + let setup = Setup::new().await; + for expired in [false, true] { + let effect = setup + .engine() + .compile_effect(&setup.proof, &setup.action) + .await + .expect("native effect"); + let (not_before, expires_at) = if expired { + (NOW - 60, NOW) + } else { + (NOW, NOW + 60) + }; + let request = effect + .approval_request(not_before, expires_at) + .expect("review"); + // Expiry case has the actual installed signer. The other case has a + // valid signature from a different key and must fail independently. + let key = SigningKey::from_bytes(&[if expired { 29 } else { 30 }; 32]); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let result = setup + .engine() + .submit( + &setup.proof, + &setup.action, + request.with_signature(signature), + ) + .await; + assert_eq!(result, super::super::not_entered("gateway.effect.approval")); + assert_eq!(setup.leases(), 0); + let witness = setup.engine().execution_witness(); + assert_eq!(witness.credential_lease_calls, 0); + assert_eq!(witness.write_transport_entries, 0); + assert_eq!(witness.read_transport_entries, 0); + } +} + #[tokio::test] async fn exact_native_actor_and_action_require_a_durable_unit_before_custody() { let setup = Setup::new().await; @@ -282,7 +335,7 @@ async fn exact_native_actor_and_action_require_a_durable_unit_before_custody() { .commissioning_session(&setup.inputs()) .expect("operator"); session.initialize_budget().await.expect("registered"); - let commissioned = io(&setup, Some(&session)); + let commissioned = io(&setup, Some(&session)).await; commissioned.verify(NOW).expect("exact native actor/action"); commissioned .prepare() @@ -321,7 +374,7 @@ async fn absent_registration_and_expiry_after_preparation_never_lease() { if initialized { session.initialize_budget().await.expect("registered"); } - let commissioned = io(&setup, Some(&session)); + let commissioned = io(&setup, Some(&session)).await; commissioned.verify(NOW).expect("native proof"); commissioned.prepare().await.expect("prepared"); if initialized { @@ -349,7 +402,7 @@ async fn another_signed_actor_or_action_is_refused_before_custody() { .commissioning_session(&setup.inputs()) .expect("operator"); session.initialize_budget().await.expect("registered"); - let commissioned = io(&setup, Some(&session)); + let commissioned = io(&setup, Some(&session)).await; assert_eq!( commissioned.verify(NOW).map(|_| ()), Err(super::super::not_entered( @@ -403,7 +456,7 @@ async fn execution_witness_measures_custody_calls_even_when_a_charged_call_fails .commissioning_session(&setup.inputs()) .expect("operator"); session.initialize_budget().await.expect("registered"); - let commissioned = io(&setup, Some(&session)); + let commissioned = io(&setup, Some(&session)).await; commissioned.verify(NOW).expect("native exact actor"); commissioned .prepare() diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index e7058f817..0d5e6e2f5 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -55,6 +55,9 @@ impl fmt::Debug for EffectPolicy { } impl EffectPolicy { + pub(crate) const fn approver(&self) -> &[u8; 32] { + &self.approver + } /// Constructs the operator's policy. Epoch changes require deliberate /// operator action; they must never be inferred from a missing journal. /// @@ -133,6 +136,87 @@ impl EffectPolicy { } } +/// Post-verification driver oracle only. It deliberately does not establish +/// installed native authority, isolation or a real human review. Production +/// builds cannot construct this fixture or select it through an app request. +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn approve_driver_fixture( + command: VerifiedCommand, + now: u64, + approval: Option, +) -> Result { + use auths_connections::{ + ConnectionAlias, ConnectionId, ConnectionProfile, ConnectionState, ProviderKind, SemanticId, + }; + use ed25519_dalek::{Signer as _, SigningKey}; + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let invalid = || not_entered("test.effect.fixture-invalid"); + let connection = ConnectionRecord::new( + ProviderKind::parse("fixture").map_err(|_| invalid())?, + ConnectionAlias::parse("driver").map_err(|_| invalid())?, + ConnectionId::parse("conn_AAAAAAAAAAAAAAAAAAAAAA").map_err(|_| invalid())?, + SemanticId::parse("auths.gateway-operation/1").map_err(|_| invalid())?, + SemanticId::parse("auths.gateway-connection-descriptor/1").map_err(|_| invalid())?, + b"post-verification-driver-fixture".to_vec(), + [4; 32], + [5; 32], + std::num::NonZeroU64::MIN, + ConnectionState::Active, + vec!["gateway".to_owned()], + vec![ + ConnectionProfile::new(SemanticId::parse("auths.mcp").map_err(|_| invalid())?, 2) + .map_err(|_| invalid())?, + ], + now, + now, + None, + ) + .map_err(|_| invalid())?; + let binding = EffectBinding::new(BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: command.request.namespace().as_str().to_owned(), + partition: "driver-fixture".to_owned(), + epoch: 1, + operation: command.request.operation_id().as_str().to_owned(), + action: *command.request.action_commitment(), + native_authority: command.native_authority, + scope: Scope::Unscoped, + recipe: [0; 32], + compiler: COMPILER.to_owned(), + connection: [0; 32], + credential_generation: 1, + qualification_policy: "optional".to_owned(), + approval_policy: ApprovalPolicy::Exact { approver: public }, + reservations: Vec::new(), + protocol: Protocol::Mutation { + request: request_commitment(&command.request).map_err(|_| invalid())?, + }, + }) + .map_err(|_| invalid())?; + let effect = BoundEffect { + binding, + command, + connection, + proof: Zeroizing::new(Vec::new()), + action: Zeroizing::new(Vec::new()), + }; + if let Some(approval) = approval { + return effect + .approve(approval, &public, now) + .map_err(|_| invalid()); + } + let request = effect + .approval_request(now, now.saturating_add(MAX_EFFECT_APPROVAL_SECONDS)) + .map_err(|_| invalid())?; + let signature = key + .sign(&request.signing_message().map_err(|_| invalid())?) + .to_bytes(); + effect + .approve(request.with_signature(signature), &public, now) + .map_err(|_| invalid()) +} + /// Private audit identity. Do not publish it as a hiding content commitment. #[derive(Clone, Copy, Eq, PartialEq)] pub struct EffectId([u8; 32]); @@ -405,6 +489,7 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { pub struct BoundEffect { binding: EffectBinding, command: VerifiedCommand, + connection: ConnectionRecord, proof: Zeroizing>, action: Zeroizing>, } @@ -495,13 +580,10 @@ impl BoundEffect { /// Refuses an invalid key, time range or approval lifetime. pub fn approval_request( &self, - approver: [u8; 32], not_before: u64, expires_at: u64, ) -> Result { - if self.binding.wire.approval_policy != (ApprovalPolicy::Exact { approver }) { - return Err(EffectBindingError::Invalid); - } + let ApprovalPolicy::Exact { approver } = self.binding.wire.approval_policy; let request = EffectApprovalRequest { schema: APPROVAL_SCHEMA.to_owned(), effect: *self.binding.id().as_bytes(), @@ -560,6 +642,31 @@ impl fmt::Debug for EffectApprovalRequest { } impl EffectApprovalRequest { + /// Canonical private signing request for an external human signer. + /// + /// # Errors + /// Refuses invalid/obsolete request data or encoding failure. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + self.validate()?; + canonical(self) + } + + /// Reads bounded canonical signing data; this grants no authority. + /// + /// # Errors + /// Refuses malformed, duplicate, noncanonical, obsolete or oversized input. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_APPROVAL_BYTES { + return Err(EffectBindingError::Invalid); + } + let request: Self = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + if request.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(request) + } + fn validate(&self) -> Result<(), EffectBindingError> { if self.schema != APPROVAL_SCHEMA { return Err(EffectBindingError::Unsupported); @@ -685,6 +792,13 @@ pub struct ApprovedEffect { } impl ApprovedEffect { + pub(crate) fn command(&self) -> &VerifiedCommand { + &self.effect.command + } + + pub(crate) fn connection(&self) -> &ConnectionRecord { + &self.effect.connection + } /// Immutable effect reviewed by the approver. #[must_use] pub const fn effect(&self) -> &BoundEffect { @@ -831,6 +945,7 @@ fn bind_mutation( Ok(BoundEffect { binding, command, + connection: installed.connection.clone(), proof: Zeroizing::new(proof.to_vec()), action: Zeroizing::new(action.to_vec()), }) diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index d787cf90a..b0c433848 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -113,13 +113,27 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .contains("private-sentinel") ); assert!(!format!("{effect:?}").contains("private-sentinel")); - let review = effect - .approval_request(public, NOW, NOW + 30) - .expect("review"); + let review = effect.approval_request(NOW, NOW + 30).expect("review"); let signature = key .sign(&review.signing_message().expect("native message")) .to_bytes(); + let signing_request = review + .to_private_bytes() + .expect("canonical signing request"); + assert_eq!( + crate::effect::EffectApprovalRequest::from_private_bytes(&signing_request) + .expect("signing data"), + review + ); let approval = review.with_signature(signature); + let frame = crate::app::AppSubmission { + schema: crate::app::APP_REQUEST_SCHEMA.to_owned(), + proof_b64: base64ct::Base64UrlUnpadded::encode_string(&submission.proof), + action_b64: base64ct::Base64UrlUnpadded::encode_string(&submission.action), + approval_b64: base64ct::Base64UrlUnpadded::encode_string( + &approval.to_private_bytes().expect("approval"), + ), + }; let fixture = serde_json::to_vec_pretty(&json!({ "schema": "auths.effect-fixture/1", "scope": "native compilation and exact approval; no entry or durability claim", @@ -132,18 +146,25 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { "request_body": std::str::from_utf8(expected.body()).expect("request UTF-8"), "evaluated_at": NOW, "approval_expires_at": NOW + 30, + "submission_frame_canonical": String::from_utf8(serde_json_canonicalizer::to_vec(&frame).expect("native frame")).expect("UTF-8"), })).expect("fixture JSON"); let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/effect-binding.json"); let policy_path = fixture_path.with_file_name("effect-policy.json"); + let request_path = fixture_path.with_file_name("effect-approval-request.json"); if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { std::fs::write(&fixture_path, &fixture).expect("write native fixture"); std::fs::write(&policy_path, &policy_bytes).expect("write native policy fixture"); + std::fs::write(&request_path, &signing_request).expect("write native signing fixture"); } assert_eq!( std::fs::read(&policy_path).expect("policy fixture"), *policy_bytes ); + assert_eq!( + std::fs::read(&request_path).expect("signing fixture"), + *signing_request + ); assert_eq!( std::fs::read(&fixture_path).expect("native fixture"), fixture @@ -157,7 +178,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { assert!(approved.validate_for_entry(&installed, NOW + 29).is_ok()); assert!(approved.validate_for_entry(&installed, NOW + 30).is_err()); let late_request = later - .approval_request(public, NOW + 3_570, NOW + 3_605) + .approval_request(NOW + 3_570, NOW + 3_605) .expect("approval spanning native action expiry"); let late_signature = key .sign(&late_request.signing_message().expect("message")) diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 702c098e9..ad2215a2e 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -10,6 +10,7 @@ use crate::bounds::{BoundAdmission, admit_bounds}; use crate::connection::{ LoadedConnection, SharedConnection, SharedConnectionError, authorizes_entry, }; +use crate::effect::{ApprovedEffect, ExactEffectApproval}; use crate::observer::{ GatewayObserver, GatewaySignedObservation, OUTCOME_SCHEMA, READ_BACK_SCHEMA, operation_subject, outcome_facts, read_back_facts, @@ -1113,8 +1114,7 @@ impl GatewayEngine { }; let io = EngineIo { engine: self, - proof: &[], - action: &[], + pending: std::sync::Mutex::new(None), started: Instant::now(), prepared: OnceLock::new(), #[cfg(unix)] @@ -1198,16 +1198,27 @@ impl GatewayEngine { ) } - /// Verifies and attempts one exact action. Only proof and action bytes are - /// accepted from the application; trust, recipe, connection, and credential + /// Verifies and attempts one exactly approved action. Proof, action and + /// exact approval are accepted from the application; trust, recipe, connection, and credential /// come from the operator's installation. The admission-order step machine /// directs every step: a replay never writes again, and for a linked /// recipe it may perform one more read-only observation. - pub async fn submit(&self, proof_cbor: &[u8], action_cbor: &[u8]) -> GatewaySubmitResult { + pub async fn submit( + &self, + proof_cbor: &[u8], + action_cbor: &[u8], + approval: ExactEffectApproval, + ) -> GatewaySubmitResult { + let approved = match self + .approve_submission(proof_cbor, action_cbor, approval) + .await + { + Ok(approved) => approved, + Err(result) => return result, + }; let io = EngineIo { engine: self, - proof: proof_cbor, - action: action_cbor, + pending: std::sync::Mutex::new(Some(approved)), started: Instant::now(), prepared: OnceLock::new(), #[cfg(unix)] @@ -1229,6 +1240,22 @@ impl GatewayEngine { .await } + async fn approve_submission( + &self, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let effect = self.compile_effect(proof, action).await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval")) + } + /// Loads the shared record, requires it to authorize this gateway's /// workload and profile, requires this process's credential store to /// hold the secret its credential generation names, and prepares the @@ -1401,8 +1428,7 @@ fn stored_result(snapshot: &crate::GatewayAttemptSnapshot) -> GatewaySubmitResul /// The installed engine's I/O for one submission. struct EngineIo<'a> { engine: &'a GatewayEngine, - proof: &'a [u8], - action: &'a [u8], + pending: std::sync::Mutex>, started: Instant, prepared: OnceLock, #[cfg(unix)] @@ -1417,29 +1443,51 @@ impl SubmitIo for EngineIo<'_> { type Lease = StoredSecretLease; fn clock(&self) -> Option { - #[cfg(unix)] - if self.commissioning.is_some() { - return Some(self.engine.qualification.commissioning_time().0); - } - wall_clock_seconds() - } - - fn verify(&self, now: u64) -> Result { - let verified = verify_detailed( - &self.engine.recipe, - &self.engine.trusted_context, + self.engine.qualification.effect_time() + } + + fn verify(&self, now: u64) -> Result { + let approved = self + .pending + .lock() + .map_err(|_| not_entered("gateway.effect.unavailable"))? + .take() + .ok_or_else(|| not_entered("gateway.effect.unavailable"))?; + approved.validate_for_entry( + &self.engine.effect_policy.installation( + &self.engine.recipe, + &self.engine.trusted_context, + approved.connection(), + self.engine.qualification.policy(), + ), now, - self.proof, - self.action, )?; #[cfg(unix)] if let Some(session) = self.commissioning { - let action = session.bind_verified(&verified).map_err(not_entered)?; + let action = session + .bind_verified(approved.command()) + .map_err(not_entered)?; self.commissioned_action .set(action) .map_err(|_| not_entered("gateway.commissioning.binding-mismatch"))?; } - Ok(verified) + Ok(approved) + } + + fn revalidate(&self, approved: &ApprovedEffect, now: u64) -> Result<(), GatewaySubmitResult> { + let prepared = self + .prepared + .get() + .ok_or_else(|| not_entered("gateway.effect.unavailable"))?; + approved.validate_for_entry( + &self.engine.effect_policy.installation( + &self.engine.recipe, + &self.engine.trusted_context, + prepared.loaded.record(), + self.engine.qualification.policy(), + ), + now, + ) } fn bind_scope(&self, verified: &VerifiedCommand) -> Result<(), &'static str> { diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 63a35f8f1..03c4cd4b9 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -717,6 +717,7 @@ struct HarnessIo<'a> { proof: &'a [u8], action: &'a [u8], now: u64, + approval: Option, } impl SubmitIo for HarnessIo<'_> { @@ -726,14 +727,28 @@ impl SubmitIo for HarnessIo<'_> { Some(self.now) } - fn verify(&self, now: u64) -> Result { - verify_detailed( + fn verify(&self, now: u64) -> Result { + let command = verify_detailed( &self.harness.recipe, &self.harness.context, now, self.proof, self.action, - ) + )?; + crate::effect::approve_driver_fixture(command, now, self.approval.clone()) + } + + fn revalidate( + &self, + effect: &crate::effect::ApprovedEffect, + now: u64, + ) -> Result<(), GatewaySubmitResult> { + let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + effect + .validate_approval(&public, now) + .map_err(|_| crate::engine::not_entered("test.effect.approval")) } fn bind_scope(&self, verified: &VerifiedCommand) -> Result<(), &'static str> { @@ -866,6 +881,16 @@ impl Harness { proof: &[u8], action: &[u8], now: u64, + ) -> GatewaySubmitResult { + self.submit_with_approval(proof, action, now, None).await + } + + async fn submit_with_approval( + &self, + proof: &[u8], + action: &[u8], + now: u64, + approval: Option, ) -> GatewaySubmitResult { crate::submit::run( &SubmitContext { @@ -879,6 +904,7 @@ impl Harness { proof, action, now, + approval, }, ) .await @@ -1001,9 +1027,19 @@ mod process { } impl GatewayApplication for Application { - async fn submit(&self, proof: &[u8], action: &[u8]) -> GatewaySubmitResult { + async fn submit( + &self, + proof: &[u8], + action: &[u8], + approval: crate::effect::ExactEffectApproval, + ) -> GatewaySubmitResult { self.harness - .submit(proof, action, self.clock.load(Ordering::SeqCst)) + .submit_with_approval( + proof, + action, + self.clock.load(Ordering::SeqCst), + Some(approval), + ) .await } diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index aa66ada4d..5ac8e37b9 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -207,8 +207,21 @@ impl SubmitIo for TestIo<'_, P> { Some(self.clock.load(Ordering::SeqCst)) } - fn verify(&self, _now: u64) -> Result { - self.verified.clone() + fn verify(&self, now: u64) -> Result { + crate::effect::approve_driver_fixture(self.verified.clone()?, now, None) + } + + fn revalidate( + &self, + effect: &crate::effect::ApprovedEffect, + now: u64, + ) -> Result<(), GatewaySubmitResult> { + let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + effect + .validate_approval(&public, now) + .map_err(|_| crate::engine::not_entered("test.effect.approval")) } fn bind_scope(&self, verified: &VerifiedCommand) -> Result<(), &'static str> { diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 1c8031e78..047ecda89 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -9,6 +9,7 @@ //! installed transport and credential store; the tests supply a counting //! provider double through the same driver. +use crate::effect::ApprovedEffect; use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered, replay_refused}; use crate::pre_entry::{self, PreEntryObservation, SelectedRequirement}; use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES, ReadBack}; @@ -46,7 +47,11 @@ pub(crate) trait SubmitIo { fn clock(&self) -> Option; /// Verifies natively at `now` and projects the verified command. - fn verify(&self, now: u64) -> Result; + fn verify(&self, now: u64) -> Result; + + /// Revalidates the retained original authority and approval against the + /// prepared installation. This is still separate from the durable fence. + fn revalidate(&self, effect: &ApprovedEffect, now: u64) -> Result<(), GatewaySubmitResult>; /// Checks that every link's scope lists the verified account-scope /// value. @@ -232,7 +237,7 @@ struct Run<'a, I: SubmitIo> { guard: Option, ceiling: Option, evaluated_at: u64, - verified: Option, + verified: Option, selected: Vec, claim: Option, observable: Option, @@ -341,7 +346,7 @@ impl Run<'_, I> { SubmitAction::Verify => SubmitEvent::Verification(self.verify()), SubmitAction::Admit => SubmitEvent::Admission(self.admit()), SubmitAction::BindScope => { - let bound = match &self.verified { + let bound = match self.verified.as_ref().map(ApprovedEffect::command) { Some(verified) => self.io.bind_scope(verified), None => Err("gateway.attempt.unavailable"), }; @@ -355,7 +360,8 @@ impl Run<'_, I> { if let Err(code) = prepared { self.refuse_before_claim(not_entered(code)); } - SubmitEvent::Preparation(prepared.is_ok()) + let valid = prepared.is_ok() && self.revalidate(); + SubmitEvent::Preparation(valid) } SubmitAction::Claim => SubmitEvent::Claim(self.claim().await), SubmitAction::Resume => SubmitEvent::Resume(self.resume().await), @@ -393,9 +399,9 @@ impl Run<'_, I> { }, None => false, }), - SubmitAction::CheckDeadline => { - SubmitEvent::Deadline(self.io.within_entry_deadline(self.evaluated_at)) - } + SubmitAction::CheckDeadline => SubmitEvent::Deadline( + self.io.within_entry_deadline(self.evaluated_at) && self.revalidate(), + ), SubmitAction::Send => SubmitEvent::Write(self.send().await), SubmitAction::RecordResponse => { let recorded = self.record_response().await; @@ -420,14 +426,42 @@ impl Run<'_, I> { } } + fn revalidate(&mut self) -> bool { + let (Some(effect), Some(now)) = (self.verified.as_ref(), self.io.clock()) else { + self.refuse_before_claim(not_entered("gateway.verify.clock-unavailable")); + return false; + }; + match self.io.revalidate(effect, now) { + Ok(()) => true, + Err(result) => { + self.refusal = Some(match &result { + GatewaySubmitResult::NotEntered { code } + if code == "gateway.effect.approval" => + { + "gateway.effect.approval" + } + GatewaySubmitResult::NotEntered { code } + if code == "gateway.effect.binding-changed" => + { + "gateway.effect.binding-changed" + } + _ => "gateway.effect.authority-unavailable", + }); + self.refuse_before_claim(result); + false + } + } + } + fn verify(&mut self) -> Verification { - let verified = match self.io.verify(self.evaluated_at) { + let approved = match self.io.verify(self.evaluated_at) { Ok(verified) => verified, Err(result) => { self.refuse_before_claim(result); return Verification::Refused; } }; + let verified = approved.command(); let argument = match &self.ceiling { None => 0, Some(ceiling) => { @@ -438,7 +472,7 @@ impl Run<'_, I> { argument } }; - self.verified = Some(verified); + self.verified = Some(approved); Verification::Authorized { argument } } @@ -446,7 +480,7 @@ impl Run<'_, I> { /// observer check; nothing is stored. The first failing check's code is /// the one reported. fn admit(&mut self) -> bool { - let Some(verified) = &self.verified else { + let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { return false; }; if let Some(retention) = self.cx.recipe.idempotency_retention() @@ -500,7 +534,7 @@ impl Run<'_, I> { } async fn claim(&mut self) -> ClaimResult { - let Some(verified) = &self.verified else { + let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { return ClaimResult::Unavailable; }; match self @@ -535,7 +569,7 @@ impl Run<'_, I> { } async fn resume(&mut self) -> bool { - let Some(verified) = &self.verified else { + let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { return false; }; match self @@ -593,7 +627,7 @@ impl Run<'_, I> { async fn pre_entry_read(&mut self) -> PreEntryResult { let (Some(lease), Some(verified), Some(observer), Some(pointers)) = ( &self.lease, - &self.verified, + self.verified.as_ref().map(ApprovedEffect::command), self.cx.observer, self.cx.recipe.pre_entry_pointers(), ) else { @@ -637,9 +671,11 @@ impl Run<'_, I> { } async fn ceiling_read(&mut self) -> CeilingRead { - let (Some(lease), Some(verified), Some(ceiling)) = - (&self.lease, &self.verified, &self.ceiling) - else { + let (Some(lease), Some(verified), Some(ceiling)) = ( + &self.lease, + self.verified.as_ref().map(ApprovedEffect::command), + &self.ceiling, + ) else { return CeilingRead::Unavailable; }; let Some(read) = verified.request.relative_ceiling_read() else { @@ -674,7 +710,10 @@ impl Run<'_, I> { } async fn send(&mut self) -> WriteResult { - let (Some(lease), Some(verified)) = (&self.lease, &self.verified) else { + let (Some(lease), Some(verified)) = ( + &self.lease, + self.verified.as_ref().map(ApprovedEffect::command), + ) else { return WriteResult::NotEntered; }; match self.io.write(lease, &verified.request).await { @@ -693,9 +732,11 @@ impl Run<'_, I> { } async fn record_response(&mut self) -> ResponseRecord { - let (Some(claim), Some((status, digest, body, version_ok)), Some(verified)) = - (self.claim.take(), self.written.take(), &self.verified) - else { + let (Some(claim), Some((status, digest, body, version_ok)), Some(verified)) = ( + self.claim.take(), + self.written.take(), + self.verified.as_ref().map(ApprovedEffect::command), + ) else { return ResponseRecord::Failed; }; let locator = verified @@ -722,6 +763,7 @@ impl Run<'_, I> { return false; }; let code = match refusal { + Refusal::EntryDeadline => self.refusal.unwrap_or_else(|| refusal_code(refusal)), Refusal::CredentialUnavailable | Refusal::ConnectionChanged => self .io .authority_refusal() From f7bf938de50904764ae948c979a8aa0daf3c3e43 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 02:38:10 +0000 Subject: [PATCH 010/136] chore(formal): regenerate qualification artifacts Source-SHA: cd3a34486a59768be593274e60ae848fb160d249 Workflow-Run: 40621783276 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index f0600223b..9c4e0205f 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "5cf292b7c37fbc6183c496fd348e885b87204d515353fb5088f2d181b69b7720", + "digest": "2a5b02a1ceeaa15c63cca7e083875f84bf7a483a8d0c63db87aee19697d8c3f5", "files": [ { "path": ".cargo/config.toml", @@ -189,7 +189,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/order.rs", - "sha256": "e0045f877c4b7fe3860c291039853885064ddcdebba7c9b345ab65e81e646dda" + "sha256": "0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26" }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", From 96e47805cb245a00256ec4ad8e7d45c61ffe7947 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 02:59:30 +0000 Subject: [PATCH 011/136] feat(gateway)!: persist exact effects under scoped operation keys --- .../gateway/attempt-scenarios-v3.json | 8 +- bindings/fixtures/gateway/effect-binding.json | 1 + compliance.toml | 4 +- ...017-bound-effect-and-recovery-ownership.md | 30 +++ docs/plans/0074-implementation-status.md | 36 ++- .../auths-gateway/src/bin/auths-gateway.rs | 46 ++-- .../src/commissioning_session/tests.rs | 18 +- product/runtime/auths-gateway/src/effect.rs | 131 ++++++++-- .../auths-gateway/src/effect_native_tests.rs | 1 + product/runtime/auths-gateway/src/engine.rs | 9 +- product/runtime/auths-gateway/src/harness.rs | 14 +- .../src/pending_vectors/attempts.rs | 10 +- .../auths-gateway/src/property_tests.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../src/qualification_simulation.rs | 6 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../runtime/auths-gateway/src/recipe/tests.rs | 28 +- .../auths-gateway/src/scenario_tests.rs | 200 ++++++++++++-- product/runtime/auths-gateway/src/store.rs | 244 ++++++++++++++---- .../auths-gateway/src/store_testkit.rs | 6 +- product/runtime/auths-gateway/src/submit.rs | 21 +- 21 files changed, 669 insertions(+), 150 deletions(-) diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 892032a6b..e9381b8c9 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/3", + "attempt_schema": "auths.gateway-attempt/4", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { @@ -776,7 +776,7 @@ "recipe": "airtable", "setup": { "crash": "after-write-before-response", - "replay": "fresh-proof" + "replay": "same-binding" }, "stages": [ "attempting", @@ -797,12 +797,12 @@ }, { "id": "same-id-fresh-challenge", - "transition": "attempting->replay-refused", + "transition": "attempting->binding-conflict", "provider_entries": 0 }, { "id": "changed-action-same-id", - "transition": "attempting->replay-refused", + "transition": "attempting->binding-conflict", "provider_entries": 0 }, { diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index ba586734c..114c30508 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -2,6 +2,7 @@ "schema": "auths.effect-fixture/1", "scope": "native compilation and exact approval; no entry or durability claim", "effect_id_hex": "ddc0f0224d94e452ef06a63695be6aedad36f9947f8677432b0976526d41214b", + "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/1\",\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/1\",\"scope\":{\"kind\":\"unscoped\"}}", "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"tVxnMe0bJwPg9P6NV4a7zGDPy_cgsSXWP5XQIz8J2H2Tur2m38UZUpCuYYThRKKQlyuzEHmjsQnMtT1MlhjrCQ\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", diff --git a/compliance.toml b/compliance.toml index 3f12b88b2..f49003822 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/3", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/4", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/3", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/4", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index ea341787f..6ad4c5682 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -89,3 +89,33 @@ floors and PostgreSQL transaction rollback; these are current safety semantics. Retain reference implementations and original formal evidence only with accurate scope. Acceptance requires A01–A22, updated source-linked proofs and hosted CI; this ADR itself is not evidence that those gates passed. + +## Installed mutation journal identity cutover + +Attempt record `auths.gateway-attempt/4` retains the complete native canonical +binding and original canonical exact approval as immutable fixed fields. The +existing transition predicate compares those fixed bytes; a later observation +or outcome cannot substitute them. Historical approval validation uses the +recorded evaluation time and the approver pinned in that binding, not a new +approval supplied by a replay. This preserves evidence; it does not grant entry. + +The only operation lookup key is the repository domain commitment +`auths.effect-replay-key/1` over canonical `(namespace, partition, epoch, +operation)`. It excludes the effect digest. An insertion collision loads and +validates the retained record and compares the complete binding: equality is +replay, inequality is `gateway.effect.operation-conflict`. Neither changes the +record or allocates another slot. Malformed state is unavailable, never replay +success or a free operation. There is no legacy lookup or decoder. + +The runtime constructs the attempt owner from the same installed effect policy +as the engine and refuses a mismatch. Support listings filter the installed +partition/epoch within their bounded scan. Native count/sum counter keys remain +unchanged: changing an operation epoch must not reset a shared grant's capacity. +Old attempt tombstones remain durable. A higher epoch is an independently +installed namespace, not evidence of rollback protection or permission to retry +an old unknown operation. Store conformance source covers both adapters, but +its new binding/scope cases have not yet been executed on hosted CI. + +This cutover does not replace `Attempting` with a durable entry grant, provide a +configuration fence, or finish independent recovery authority. Those remain the +explicit P2 requirements above. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index a034c1d84..395f44aa9 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -150,6 +150,38 @@ not installed transport or transactional admission. Subsequent refusal tests and input-zeroization edits are source-authored only. All unfulfilled AP074 gates remain open, and the goal remains active. +## Full-binding journal cutover (in progress) + +- Mutation admission now receives the sealed `ApprovedEffect`; the unchecked + request-only claim helper exists only under test/testkit compilation. +- Attempt schema `/4` persists canonical full binding and original exact signed + approval in the immutable fixed fields. Historical signature validation and + redundant namespace/operation/action/recipe checks reject corrupt state. +- The sole replay key includes installed namespace, partition and epoch plus + operation ID, and deliberately excludes the effect digest. Full binding + collisions produce `gateway.effect.operation-conflict`; equal bindings remain + replay even when approval is renewed. Neither replaces the initial bytes. +- Every installed CLI store open receives operator policy; the engine rejects + a different store policy. Existing native budget counter identities remain + unchanged so new operation epochs do not reset grant capacity. +- File reads now limit bytes before allocating/decoding records and rollback + files. This is a read bound, not yet the required bounded lock/transaction. +- Shared file/PostgreSQL conformance source adds restart, changed selected + authority/recipe/action, renewed approval, partition/epoch isolation and + original-byte preservation checks. These new behavioral cases are authored, + not executed. Existing reference expectations distinguish conflict from replay. +- Required local artifact generation passed for `cd3a3448` plus this journal + source: `pending_vectors::attempts::attempt_scenarios_v3_are_current` (one + test) and `observed_tests::effect_native_tests::native_compilation_approval_and_reverification_keep_exact_request` + (one test), each via `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact ...`. + The native corpus now includes the canonical scoped operation key. Native CLI + envelope generation also passed after correcting its policy type import; + output remains byte-identical to the native approval corpus. No hosted CI, broad local suite, formal gate or actual adapter conformance run is claimed. +- P1 still needs semantic review completeness and integration evidence. P2 + still needs atomic fencing and a consumed permit. Identical replay's existing + observation path must be replaced by independently authorized bounded recovery; + the updated reference cases do not establish that future contract. + ## Phase gates | Phase | State | Outstanding gate | @@ -170,7 +202,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | --- | --- | --- | --- | | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / compilation-only | Execution cutover pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | -| A03 | Concurrent/restart replay, conflict, approval reuse | Pending / no / no | Full binding comparison | +| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Pending / no / no | Atomic journal admission | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | @@ -183,7 +215,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Pending / no / no | Separate recovery authority | -| A16 | Cross-task/recipe/partition substitution | Pending / no / no | Scope and epoch binding | +| A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index dc4c134f4..b67c6cc4f 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -1361,7 +1361,8 @@ mod unix { } let attempts = { let store_path = store_path.clone(); - tokio::task::spawn_blocking(move || open_attempts(deployment, store_path)) + let policy = manifest.effect_policy.clone(); + tokio::task::spawn_blocking(move || open_attempts(deployment, store_path, policy)) .await .map_err(|_| "gateway.install.attempt-store-unavailable")? .map_err(|_| "gateway.install.attempt-store-unavailable")? @@ -1923,22 +1924,27 @@ mod unix { fn open_attempts( deployment: Deployment, store_path: Option, + policy: auths_gateway::effect::EffectPolicy, ) -> Result { - Ok(GatewayAttempts::new(match (deployment, store_path) { - (Deployment::Development, Some(path)) => Arc::new( - FileGatewayAttemptStore::open(path) - .map_err(|_| "gateway.serve.attempt-store-unavailable")?, - ), - (Deployment::Production, None) => { - let configuration = PostgresStoreConfig::from_env(Vec::new(), 1_000_000) - .map_err(|_| "gateway.serve.postgres-configuration")?; - Arc::new(PostgresGatewayAttemptStore::new(Arc::new( - PostgresLifecycleStore::connect(configuration) + GatewayAttempts::new( + match (deployment, store_path) { + (Deployment::Development, Some(path)) => Arc::new( + FileGatewayAttemptStore::open(path) .map_err(|_| "gateway.serve.attempt-store-unavailable")?, - ))) - } - _ => return Err("gateway.serve.invalid-installation"), - })) + ), + (Deployment::Production, None) => { + let configuration = PostgresStoreConfig::from_env(Vec::new(), 1_000_000) + .map_err(|_| "gateway.serve.postgres-configuration")?; + Arc::new(PostgresGatewayAttemptStore::new(Arc::new( + PostgresLifecycleStore::connect(configuration) + .map_err(|_| "gateway.serve.attempt-store-unavailable")?, + ))) + } + _ => return Err("gateway.serve.invalid-installation"), + }, + policy, + ) + .map_err(|_| "gateway.serve.invalid-effect-policy") } /// The store connections `serve` may hold: the `PostgreSQL` pool's @@ -2045,6 +2051,7 @@ mod unix { open_attempts( manifest.deployment, manifest.attempt_store.as_ref().map(PathBuf::from), + manifest.effect_policy.clone(), )?, ) .map_err(|_| "gateway.serve.invalid-installation")?; @@ -3202,6 +3209,7 @@ mod unix { let listed = open_attempts( manifest.deployment, manifest.attempt_store.as_ref().map(PathBuf::from), + manifest.effect_policy.clone(), ) .ok() .and_then(|attempts| { @@ -3245,9 +3253,11 @@ mod unix { let manifest = installation(state_dir)?; let deployment = manifest.deployment; let store_path = manifest.attempt_store.as_ref().map(PathBuf::from); - let attempts = tokio::task::spawn_blocking(move || open_attempts(deployment, store_path)) - .await - .map_err(|_| "gateway.admin.connection-unavailable")??; + let policy = manifest.effect_policy.clone(); + let attempts = + tokio::task::spawn_blocking(move || open_attempts(deployment, store_path, policy)) + .await + .map_err(|_| "gateway.admin.connection-unavailable")??; let shared = SharedConnection::new( attempts.store(), ProviderKind::parse(manifest.provider).map_err(|_| "gateway.serve.invalid-provider")?, diff --git a/product/runtime/auths-gateway/src/commissioning_session/tests.rs b/product/runtime/auths-gateway/src/commissioning_session/tests.rs index bc65ff1f7..42a8a899d 100644 --- a/product/runtime/auths-gateway/src/commissioning_session/tests.rs +++ b/product/runtime/auths-gateway/src/commissioning_session/tests.rs @@ -268,7 +268,9 @@ async fn ordinary_submission_cannot_select_commissioning_authority() { .expect("operator"); session.initialize_budget().await.expect("registered"); let ordinary = io(&setup, None).await; - ordinary.verify(NOW).expect("native proof"); + ordinary + .verify(NOW, &setup.engine().recipe) + .expect("native proof"); assert_eq!( ordinary.prepare().await, Err("gateway.qualification.unavailable") @@ -336,7 +338,9 @@ async fn exact_native_actor_and_action_require_a_durable_unit_before_custody() { .expect("operator"); session.initialize_budget().await.expect("registered"); let commissioned = io(&setup, Some(&session)).await; - commissioned.verify(NOW).expect("exact native actor/action"); + commissioned + .verify(NOW, &setup.engine().recipe) + .expect("exact native actor/action"); commissioned .prepare() .await @@ -375,7 +379,9 @@ async fn absent_registration_and_expiry_after_preparation_never_lease() { session.initialize_budget().await.expect("registered"); } let commissioned = io(&setup, Some(&session)).await; - commissioned.verify(NOW).expect("native proof"); + commissioned + .verify(NOW, &setup.engine().recipe) + .expect("native proof"); commissioned.prepare().await.expect("prepared"); if initialized { setup.clock.set(setup.permit.body().statement.not_after); @@ -404,7 +410,7 @@ async fn another_signed_actor_or_action_is_refused_before_custody() { session.initialize_budget().await.expect("registered"); let commissioned = io(&setup, Some(&session)).await; assert_eq!( - commissioned.verify(NOW).map(|_| ()), + commissioned.verify(NOW, &setup.engine().recipe).map(|_| ()), Err(super::super::not_entered( "gateway.commissioning.binding-mismatch" )) @@ -457,7 +463,9 @@ async fn execution_witness_measures_custody_calls_even_when_a_charged_call_fails .expect("operator"); session.initialize_budget().await.expect("registered"); let commissioned = io(&setup, Some(&session)).await; - commissioned.verify(NOW).expect("native exact actor"); + commissioned + .verify(NOW, &setup.engine().recipe) + .expect("native exact actor"); commissioned .prepare() .await diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 0d5e6e2f5..aba830caa 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -55,6 +55,26 @@ impl fmt::Debug for EffectPolicy { } impl EffectPolicy { + pub(crate) fn operation_key( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + ) -> Result<[u8; 32], EffectBindingError> { + self.validate()?; + commitment( + "auths.effect-replay-key/1", + &canonical(&( + namespace.as_str(), + &self.partition, + self.epoch, + operation.as_str(), + ))?, + ) + } + + pub(crate) fn contains(&self, binding: &EffectBinding) -> bool { + self.partition == binding.wire.partition && self.epoch == binding.wire.epoch + } pub(crate) const fn approver(&self) -> &[u8; 32] { &self.approver } @@ -142,6 +162,7 @@ impl EffectPolicy { #[cfg(any(test, feature = "testkit-harness"))] pub(crate) fn approve_driver_fixture( command: VerifiedCommand, + recipe_digest: [u8; 32], now: u64, approval: Option, ) -> Result { @@ -173,26 +194,12 @@ pub(crate) fn approve_driver_fixture( None, ) .map_err(|_| invalid())?; - let binding = EffectBinding::new(BindingWire { - schema: EFFECT_BINDING_SCHEMA.to_owned(), - namespace: command.request.namespace().as_str().to_owned(), - partition: "driver-fixture".to_owned(), - epoch: 1, - operation: command.request.operation_id().as_str().to_owned(), - action: *command.request.action_commitment(), - native_authority: command.native_authority, - scope: Scope::Unscoped, - recipe: [0; 32], - compiler: COMPILER.to_owned(), - connection: [0; 32], - credential_generation: 1, - qualification_policy: "optional".to_owned(), - approval_policy: ApprovalPolicy::Exact { approver: public }, - reservations: Vec::new(), - protocol: Protocol::Mutation { - request: request_commitment(&command.request).map_err(|_| invalid())?, - }, - }) + let binding = store_binding_fixture( + &command.request, + recipe_digest, + command.native_authority, + &fixture_policy().map_err(|_| invalid())?, + ) .map_err(|_| invalid())?; let effect = BoundEffect { binding, @@ -217,6 +224,70 @@ pub(crate) fn approve_driver_fixture( .map_err(|_| invalid()) } +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn fixture_policy() -> Result { + EffectPolicy::new( + "test-partition".to_owned(), + 1, + ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(), + ) +} + +/// Store/driver reference data only; never an installed authorization path. +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn store_binding_fixture( + request: &ClosedProviderRequest, + recipe_digest: [u8; 32], + native_authority: [u8; 32], + policy: &EffectPolicy, +) -> Result { + EffectBinding::new(BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: request.namespace().as_str().to_owned(), + partition: policy.partition.clone(), + epoch: policy.epoch, + operation: request.operation_id().as_str().to_owned(), + action: *request.action_commitment(), + native_authority, + scope: Scope::Unscoped, + recipe: recipe_digest, + compiler: COMPILER.to_owned(), + connection: [0; 32], + credential_generation: 1, + qualification_policy: "optional".to_owned(), + approval_policy: ApprovalPolicy::Exact { + approver: policy.approver, + }, + reservations: Vec::new(), + protocol: Protocol::Mutation { + request: request_commitment(request)?, + }, + }) +} + +/// Signs synthetic store oracle data with the fixed test-only approver. +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn approval_fixture( + binding: &EffectBinding, + now: u64, +) -> Result { + use ed25519_dalek::Signer as _; + let key = ed25519_dalek::SigningKey::from_bytes(&[29; 32]); + let request = EffectApprovalRequest { + schema: APPROVAL_SCHEMA.to_owned(), + effect: *binding.id().as_bytes(), + approver: key.verifying_key().to_bytes(), + not_before: now, + expires_at: now + .checked_add(MAX_EFFECT_APPROVAL_SECONDS) + .ok_or(EffectBindingError::Invalid)?, + }; + let signature = key.sign(&request.signing_message()?).to_bytes(); + Ok(request.with_signature(signature)) +} + /// Private audit identity. Do not publish it as a hiding content commitment. #[derive(Clone, Copy, Eq, PartialEq)] pub struct EffectId([u8; 32]); @@ -355,6 +426,23 @@ fn canonical(value: &T) -> Result>, EffectBindin } impl EffectBinding { + pub(crate) fn journal_identity(&self) -> (&str, &str, &[u8; 32], &[u8; 32]) { + ( + &self.wire.namespace, + &self.wire.operation, + &self.wire.action, + &self.wire.recipe, + ) + } + + pub(crate) fn validate_recorded_approval( + &self, + approval: &ExactEffectApproval, + at: u64, + ) -> Result<(), EffectBindingError> { + let ApprovalPolicy::Exact { approver } = self.wire.approval_policy; + approval.verify(self.id(), &approver, at) + } fn new(wire: BindingWire) -> Result { validate(&wire)?; let bytes = canonical(&wire)?; @@ -792,6 +880,9 @@ pub struct ApprovedEffect { } impl ApprovedEffect { + pub(crate) fn approval(&self) -> &ExactEffectApproval { + &self.approval + } pub(crate) fn command(&self) -> &VerifiedCommand { &self.effect.command } diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index b0c433848..bafa270aa 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -138,6 +138,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { "schema": "auths.effect-fixture/1", "scope": "native compilation and exact approval; no entry or durability claim", "effect_id_hex": hex::encode(effect.binding().id().as_bytes()), + "operation_key_hex": hex::encode(crate::GatewayAttemptKey::for_operation(&policy, expected.namespace(), expected.operation_id()).expect("native replay key").as_bytes()), "binding_canonical": std::str::from_utf8(&bytes).expect("binding UTF-8"), "approval_canonical": std::str::from_utf8(&approval.to_private_bytes().expect("approval bytes")).expect("approval UTF-8"), "approver_public_key_hex": hex::encode(public), diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index ad2215a2e..aee1f86da 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -400,6 +400,9 @@ impl GatewayEngine { effect_policy .validate() .map_err(|_| GatewayEngineConfigurationError::InvalidEffectPolicy)?; + if attempts.policy() != &effect_policy { + return Err(GatewayEngineConfigurationError::InvalidEffectPolicy); + } if trusted_context_cbor.is_empty() || trusted_context_cbor.len() > MAX_CONTEXT_BYTES { return Err(GatewayEngineConfigurationError::InvalidTrust); } @@ -1446,7 +1449,11 @@ impl SubmitIo for EngineIo<'_> { self.engine.qualification.effect_time() } - fn verify(&self, now: u64) -> Result { + fn verify( + &self, + now: u64, + _recipe: &CompiledRecipe, + ) -> Result { let approved = self .pending .lock() diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 03c4cd4b9..5983a1449 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -727,7 +727,11 @@ impl SubmitIo for HarnessIo<'_> { Some(self.now) } - fn verify(&self, now: u64) -> Result { + fn verify( + &self, + now: u64, + recipe: &CompiledRecipe, + ) -> Result { let command = verify_detailed( &self.harness.recipe, &self.harness.context, @@ -735,7 +739,7 @@ impl SubmitIo for HarnessIo<'_> { self.proof, self.action, )?; - crate::effect::approve_driver_fixture(command, now, self.approval.clone()) + crate::effect::approve_driver_fixture(command, *recipe.digest(), now, self.approval.clone()) } fn revalidate( @@ -845,7 +849,11 @@ impl Harness { recipe, context, observer, - GatewayAttempts::new(std::sync::Arc::new(store)), + GatewayAttempts::new( + std::sync::Arc::new(store), + crate::effect::fixture_policy().map_err(|_| HarnessError::Store)?, + ) + .map_err(|_| HarnessError::Store)?, )) } diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 97e730045..a03c2bb14 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -1,4 +1,4 @@ -//! Attempt scenarios for attempt record `/3`: the pre-entry re-read, the +//! Attempt scenarios for attempt record `/4`: the pre-entry re-read, the //! relative ceiling, the lease-time account and denied reads, account-scope //! headers, the retention rule, the entry deadline, and response-locator //! recovery. @@ -20,7 +20,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/3"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/4"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; @@ -480,7 +480,7 @@ fn entry_and_recovery_cases() -> Vec { scenario( "linked-attempting-reobserved", "airtable", - json!({"crash": "after-write-before-response", "replay": "fresh-proof"}), + json!({"crash": "after-write-before-response", "replay": "same-binding"}), &["attempting", "observed-by-provider"], None, &counts(2, 0, 1, 1), @@ -491,8 +491,8 @@ fn entry_and_recovery_cases() -> Vec { /// The `/2` record scenarios: id, transition, and provider entries. const RECORD_CASES: &[(&str, &str, u64)] = &[ ("first-claim", "unclaimed->attempting", 0), - ("same-id-fresh-challenge", "attempting->replay-refused", 0), - ("changed-action-same-id", "attempting->replay-refused", 0), + ("same-id-fresh-challenge", "attempting->binding-conflict", 0), + ("changed-action-same-id", "attempting->binding-conflict", 0), ("crash-after-claim", "attempting->unknown-on-restart", 0), ("complete-http-response", "attempting->response-recorded", 1), ("ambiguous-transport", "attempting->unknown", 1), diff --git a/product/runtime/auths-gateway/src/property_tests.rs b/product/runtime/auths-gateway/src/property_tests.rs index de01ec3f4..f87be573e 100644 --- a/product/runtime/auths-gateway/src/property_tests.rs +++ b/product/runtime/auths-gateway/src/property_tests.rs @@ -294,7 +294,7 @@ proptest! { let recipe = airtable(); let digest = <[u8; 32]>::try_from(hex::decode(recipe.digest_hex()).expect("hex")).expect("digest"); let root = std::fs::canonicalize(directory.path()).expect("canonical").join("attempts"); - let open = || GatewayAttempts::new(Arc::new(FileGatewayAttemptStore::open(root.clone()).expect("store"))); + let open = || GatewayAttempts::new(Arc::new(FileGatewayAttemptStore::open(root.clone()).expect("store")), crate::effect::fixture_policy().expect("policy")).expect("attempts"); let mut attempts = open(); let mut held: BTreeMap = BTreeMap::new(); let mut writes: BTreeMap = BTreeMap::new(); diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 59ea4b463..dd22cbb69 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/6"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/3"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/4"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_simulation.rs b/product/runtime/auths-gateway/src/qualification_simulation.rs index a31d90847..973a55664 100644 --- a/product/runtime/auths-gateway/src/qualification_simulation.rs +++ b/product/runtime/auths-gateway/src/qualification_simulation.rs @@ -271,7 +271,11 @@ async fn lifecycle( let observer = GatewayObserver::from_test_seed(OBSERVER_SEED); let args = family.arguments("qualification-1"); let command = family.command(&recipe, &args, ORIGINAL); - let attempts = GatewayAttempts::new(recording.clone()); + let attempts = GatewayAttempts::new( + recording.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); let mut first = TestIo::new(provider, command.clone()); first.recipe = Some(&recipe); let result = run(&attempts, &recipe, &observer, &first).await; diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 193bd17fc..2b45dcd4b 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/3", + "store_schema": "auths.gateway-attempt/4", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index fca7edb73..7e65fc91b 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -386,9 +386,11 @@ fn idempotency_key_is_domain_separated_and_bound_to_namespace_and_operation() { "the separator keeps the two fields apart" ); let replay = crate::GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), &namespace("stripe-refunds"), &operation("refund-1"), - ); + ) + .expect("key"); assert_ne!(key[9..], hex::encode(replay.as_bytes()), "own hash domain"); } @@ -695,9 +697,11 @@ async fn durable_claim_is_one_use_across_races_and_restart() { let root = std::fs::canonicalize(temp.path()) .expect("canonical temp") .join("attempts"); - let store = crate::GatewayAttempts::new(Arc::new( - FileGatewayAttemptStore::open(&root).expect("private store"), - )); + let store = crate::GatewayAttempts::new( + Arc::new(FileGatewayAttemptStore::open(&root).expect("private store")), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); let tasks: Vec<_> = (0..16) .map(|_| { let store = store.clone(); @@ -721,9 +725,11 @@ async fn durable_claim_is_one_use_across_races_and_restart() { 15 ); drop(store); - let restarted = crate::GatewayAttempts::new(Arc::new( - FileGatewayAttemptStore::open(&root).expect("restart"), - )); + let restarted = crate::GatewayAttempts::new( + Arc::new(FileGatewayAttemptStore::open(&root).expect("restart")), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); let snapshot = restarted .read(request.namespace(), request.operation_id()) .await @@ -752,9 +758,11 @@ async fn response_and_observation_are_distinct_durable_stages() { let root = std::fs::canonicalize(temp.path()) .expect("canonical temp") .join("attempts"); - let store = crate::GatewayAttempts::new(Arc::new( - FileGatewayAttemptStore::open(&root).expect("store"), - )); + let store = crate::GatewayAttempts::new( + Arc::new(FileGatewayAttemptStore::open(&root).expect("store")), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); let claim = store .claim(&request, *recipe.digest(), 1_790_000_000) .await diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 5ac8e37b9..b0f6dc80b 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -207,8 +207,12 @@ impl SubmitIo for TestIo<'_, P> { Some(self.clock.load(Ordering::SeqCst)) } - fn verify(&self, now: u64) -> Result { - crate::effect::approve_driver_fixture(self.verified.clone()?, now, None) + fn verify( + &self, + now: u64, + recipe: &CompiledRecipe, + ) -> Result { + crate::effect::approve_driver_fixture(self.verified.clone()?, *recipe.digest(), now, None) } fn revalidate( @@ -663,8 +667,11 @@ async fn run_claim_case(id: &str, backend: Backend) -> (String, usize) { "Pending" }; let second = record.airtable(FRESH, replacement); - assert_eq!(record.submit(&second, &provider).await, replay_refused()); - "attempting->replay-refused".to_owned() + assert_eq!( + record.submit(&second, &provider).await, + crate::engine::not_entered("gateway.effect.operation-conflict") + ); + "attempting->binding-conflict".to_owned() } "crash-after-claim" => { record.store.restart(); @@ -737,8 +744,15 @@ async fn run_resolution_case(id: &str, backend: Backend) -> (String, usize) { } else { "Approved" }; + let changed = matches!( + id, + "changed-action-during-unknown" | "fresh-challenge-after-observed-by-provider" + ); let replay = record - .submit(&record.airtable(FRESH, replacement), &provider) + .submit( + &record.airtable(if changed { FRESH } else { ORIGINAL }, replacement), + &provider, + ) .await; if matches!( record.snapshot(&original).await.stage(), @@ -750,7 +764,12 @@ async fn run_resolution_case(id: &str, backend: Backend) -> (String, usize) { GatewaySubmitResult::ObservedByProvider { status: None, .. } )); } else { - assert_eq!(replay, replay_refused(), "{id}: first {first:?}"); + let expected = if changed { + crate::engine::not_entered("gateway.effect.operation-conflict") + } else { + replay_refused() + }; + assert_eq!(replay, expected, "{id}: first {first:?}"); } ( format!("{before}->{}", record.describe(&original).await), @@ -869,7 +888,10 @@ async fn a_lost_claim_resends_the_same_idempotency_key() { GatewaySubmitResult::ObservedByProvider { .. } )); let fresh = intact.airtable(FRESH, "Approved"); - assert_eq!(intact.submit(&fresh, &provider).await, replay_refused()); + assert_eq!( + intact.submit(&fresh, &provider).await, + crate::engine::not_entered("gateway.effect.operation-conflict") + ); assert_eq!(provider.writes(), 1, "the intact claim stops the repeat"); let lost = Record { recipe, @@ -1167,7 +1189,11 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend if setup["crash"] == "after-write-before-response" { recording.lose_response_record.store(true, Ordering::SeqCst); } - let attempts = GatewayAttempts::new(recording.clone()); + let attempts = GatewayAttempts::new( + recording.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); let arguments = setup["arguments"].as_object().expect("arguments").clone(); let command = admitted( &recipe, @@ -1204,11 +1230,15 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend }; let first = submit::run(&cx, &io).await; let mut leases = io.leases(); - if setup["replay"] == "fresh-proof" { + if setup["replay"] == "fresh-proof" || setup["replay"] == "same-binding" { let replay_command = admitted( &recipe, &arguments, - FRESH, + if setup["replay"] == "same-binding" { + ORIGINAL + } else { + FRESH + }, grant_requirement(&setup), setup["validity_seconds"].as_u64().expect("validity"), scenario_links(&setup), @@ -1305,7 +1335,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/3"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/4"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1434,7 +1464,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/3", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/4", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); @@ -1476,7 +1506,17 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { RunStep { operation: Operation::Replay, evidence_comparison: EvidenceComparison::Static {}, - expected: expected(RunOutcome::Refused, "gateway.attempt.replay", 0, 0, 0), + expected: expected( + RunOutcome::Refused, + if scenario == Scenario::FreshChallengeReplay { + "gateway.effect.operation-conflict" + } else { + "gateway.attempt.replay" + }, + 0, + 0, + 0, + ), }, ] }; @@ -1485,7 +1525,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { if recovering && index == 1 { record.store.restart(); } - let command = if index == 0 || scenario == Scenario::ProofReplay { + let command = if index == 0 || scenario != Scenario::FreshChallengeReplay { original.clone() } else { record.airtable(FRESH, "Approved") @@ -1610,6 +1650,112 @@ async fn conformance_claim_exactly_once_and_replay(backend: Backend) { assert_eq!((provider.writes(), provider.reads()), (1, 1)); } +/// Full binding comparison survives restart. Namespace/partition/epoch scope +/// the operation key, while selected authority and recipe change the binding. +async fn conformance_complete_binding_and_scope(backend: Backend) { + use crate::effect::{EffectPolicy, approve_driver_fixture}; + let mut record = Record::open("airtable", backend); + let command = record.airtable(ORIGINAL, "Approved"); + let approve = |command, digest, at| { + approve_driver_fixture(command, digest, at, None).expect("oracle approval") + }; + let first = approve(command.clone(), *record.recipe.digest(), NOW); + let attempts = record.store.attempts(); + assert!(attempts.claim_bounded(&first, NOW).await.is_ok()); + let key = GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + command.request.namespace(), + command.request.operation_id(), + ) + .expect("key"); + let raw = record.store.raw(); + let before = tokio::task::spawn_blocking(move || raw.load(GatewayRecordKind::Attempt, &key)) + .await + .expect("read task") + .expect("read") + .expect("claim"); + record.store.restart(); + let attempts = record.store.attempts(); + let renewed = approve(command.clone(), *record.recipe.digest(), NOW + 1); + assert!( + matches!( + attempts.claim_bounded(&renewed, NOW + 1).await, + Err(GatewayAttemptError::Replay) + ), + "renewing approval cannot mint another claim" + ); + let mut changed_authority = command.clone(); + changed_authority.native_authority = [42; 32]; + for changed in [ + approve(changed_authority, *record.recipe.digest(), NOW), + approve(command.clone(), [42; 32], NOW), + approve( + record.airtable(FRESH, "Pending"), + *record.recipe.digest(), + NOW, + ), + ] { + assert!(matches!( + attempts.claim_bounded(&changed, NOW).await, + Err(GatewayAttemptError::BindingConflict) + )); + } + let raw = record.store.raw(); + let after = tokio::task::spawn_blocking(move || raw.load(GatewayRecordKind::Attempt, &key)) + .await + .expect("read task") + .expect("read") + .expect("claim"); + assert_eq!( + before, after, + "conflict and renewed approval preserve every original byte" + ); + let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + for policy in [ + EffectPolicy::new("other-partition".to_owned(), 1, public).expect("partition"), + EffectPolicy::new("test-partition".to_owned(), 2, public).expect("epoch"), + ] { + let scoped = + GatewayAttempts::new(record.store.raw(), policy.clone()).expect("scoped attempts"); + assert_eq!( + scoped + .read(command.request.namespace(), command.request.operation_id()) + .await + .expect("scoped read"), + None + ); + assert!( + matches!( + scoped.claim_bounded(&first, NOW).await, + Err(GatewayAttemptError::BindingConflict) + ), + "foreign binding cannot enter the new scope" + ); + scoped + .claim(&command.request, *record.recipe.digest(), NOW) + .await + .expect("independent scoped reference claim"); + assert_ne!( + key, + GatewayAttemptKey::for_operation( + &policy, + command.request.namespace(), + command.request.operation_id() + ) + .expect("scoped key") + ); + } + let raw = record.store.raw(); + let unchanged = tokio::task::spawn_blocking(move || raw.load(GatewayRecordKind::Attempt, &key)) + .await + .expect("read task") + .expect("read") + .expect("original claim"); + assert_eq!(before, unchanged, "new epochs retain old tombstones"); +} + /// A fresh challenge, or a changed action, under the same logical ID is /// the same operation and never a second entry. async fn conformance_fresh_challenge(backend: Backend) { @@ -1622,12 +1768,20 @@ async fn conformance_fresh_challenge(backend: Backend) { first, GatewaySubmitResult::ObservedByProvider { .. } )); + assert_eq!( + record + .submit(&record.airtable(ORIGINAL, "Approved"), &provider) + .await, + replay_refused() + ); for command in [ - record.airtable(ORIGINAL, "Approved"), record.airtable(FRESH, "Approved"), record.airtable(FRESH, "Pending"), ] { - assert_eq!(record.submit(&command, &provider).await, replay_refused()); + assert_eq!( + record.submit(&command, &provider).await, + crate::engine::not_entered("gateway.effect.operation-conflict") + ); } assert_eq!((provider.writes(), provider.reads()), (1, 1)); } @@ -1648,7 +1802,7 @@ async fn conformance_unknown_and_reobserve(backend: Backend) { "an unknown write is not read back in-line" ); record.store.restart(); - let fresh = record.airtable(FRESH, "Approved"); + let fresh = record.airtable(ORIGINAL, "Approved"); let GatewaySubmitResult::ObservedByProvider { status, evidence } = record.submit(&fresh, &provider).await else { @@ -1656,7 +1810,7 @@ async fn conformance_unknown_and_reobserve(backend: Backend) { }; assert_eq!(status, None); assert_eq!(evidence.echo, original_token()); - assert_ne!(Some(evidence.echo.as_str()), fresh.request.echo_token()); + assert_eq!(Some(evidence.echo.as_str()), fresh.request.echo_token()); assert_eq!( record.submit(&fresh, &provider).await, replay_refused(), @@ -1734,9 +1888,11 @@ async fn conformance_mechanism_fails_closed(backend: Backend) { let record = Record::open("airtable", backend); let raw = record.store.raw(); let key = GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), record.recipe.namespace(), &LogicalOperationId::parse("run-1").expect("operation"), - ); + ) + .expect("key"); let obsolete = serde_json::to_vec(&json!({ "schema": "auths.gateway-attempt/2", "namespace": "airtable-demo", "operation_id": "run-1", "action_commitment": "11".repeat(32), @@ -1778,7 +1934,10 @@ async fn conformance_mechanism_fails_closed(backend: Backend) { "a record /2 is corrupt, not read" ); let provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); - assert_eq!(record.submit(&command, &provider).await, replay_refused()); + assert_eq!( + record.submit(&command, &provider).await, + crate::engine::not_entered("gateway.attempt.unavailable") + ); assert_eq!((provider.writes(), provider.reads()), (0, 0)); } @@ -2158,6 +2317,7 @@ async fn conformance_shared_connection_record(backend: Backend) { async fn store_conformance(backend: Backend) { conformance_claim_exactly_once_and_replay(backend).await; + conformance_complete_binding_and_scope(backend).await; conformance_fresh_challenge(backend).await; conformance_unknown_and_reobserve(backend).await; conformance_echo_mismatch(backend).await; diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 745f786a6..b3dfdf90b 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/3`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/4`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -11,6 +11,7 @@ //! the multi-host `PostgresLifecycleStore`, whose production qualification is //! still open. +use crate::effect::{ApprovedEffect, EffectBinding, EffectPolicy, ExactEffectApproval}; use crate::recipe::ObservationTemplate; use crate::{ ClosedObservationRequest, ClosedProviderRequest, LogicalOperationId, OperatorNamespace, @@ -25,7 +26,7 @@ use sha2::{Digest as _, Sha256}; use std::{ collections::BTreeMap, fs::{self, File, OpenOptions}, - io::Write as _, + io::{Read as _, Write as _}, path::{Component, Path, PathBuf}, sync::Arc, }; @@ -34,7 +35,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/3"; +const SCHEMA: &str = "auths.gateway-attempt/4"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -474,6 +475,8 @@ impl PreEntryWire { #[serde(deny_unknown_fields)] struct Record { schema: String, + binding_canonical: String, + approval_canonical: String, namespace: String, operation_id: String, action_commitment: String, @@ -507,6 +510,8 @@ struct Record { #[derive(Serialize)] struct FixedFields<'a> { schema: &'a str, + binding_canonical: &'a str, + approval_canonical: &'a str, namespace: &'a str, operation_id: &'a str, action_commitment: &'a str, @@ -557,6 +562,8 @@ impl Record { Ok(AttemptView { fixed: canonical(&FixedFields { schema: &self.schema, + binding_canonical: &self.binding_canonical, + approval_canonical: &self.approval_canonical, namespace: &self.namespace, operation_id: &self.operation_id, action_commitment: &self.action_commitment, @@ -633,6 +640,21 @@ impl Record { } fn snapshot(&self, recovered: bool) -> Result { + let binding = EffectBinding::from_private_bytes(self.binding_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let approval = ExactEffectApproval::from_private_bytes(self.approval_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + binding + .validate_recorded_approval(&approval, self.evaluated_at) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let (namespace, operation, action, recipe) = binding.journal_identity(); + if namespace != self.namespace + || operation != self.operation_id + || hex::encode(action) != self.action_commitment + || hex::encode(recipe) != self.recipe_digest + { + return Err(GatewayAttemptError::Corrupt); + } if self.schema != SCHEMA || self.nonce.len() != 32 || !self @@ -732,6 +754,9 @@ pub enum GatewayAttemptError { /// A logical ID was already claimed, regardless of proof challenge or body. #[error("logical operation already claimed")] Replay, + /// The logical operation exists with a different complete effect binding. + #[error("logical operation binding conflict")] + BindingConflict, /// The state directory is not a private, normalized local directory. #[error("unsafe attempt directory")] UnsafeDirectory, @@ -856,15 +881,20 @@ pub fn check_private_directory_owned_by( pub struct GatewayAttemptKey([u8; 32]); impl GatewayAttemptKey { - /// Derives the key of `operation_id` in `namespace`. - #[must_use] - pub fn for_operation(namespace: &OperatorNamespace, operation_id: &LogicalOperationId) -> Self { - let mut hash = Sha256::new(); - hash.update(b"auths.gateway-logical-operation/1\0"); - hash.update(namespace.as_str().as_bytes()); - hash.update([0]); - hash.update(operation_id.as_str().as_bytes()); - Self(hash.finalize().into()) + /// Derives a replay key from installed partition/epoch, namespace and + /// operation. The effect digest is deliberately excluded. + /// + /// # Errors + /// Refuses invalid installed policy or an encoding failure. + pub fn for_operation( + policy: &EffectPolicy, + namespace: &OperatorNamespace, + operation_id: &LogicalOperationId, + ) -> Result { + policy + .operation_key(namespace, operation_id) + .map(Self) + .map_err(|_| GatewayAttemptError::Corrupt) } /// Uses `bytes`, a key derived under another record kind's hash domain. @@ -1089,11 +1119,21 @@ impl FileGatewayAttemptStore { } fn read_file(path: &Path, maximum: usize) -> Result>, GatewayAttemptError> { - let bytes = match fs::read(path) { - Ok(bytes) => bytes, + let file = match File::open(path) { + Ok(file) => file, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), Err(_) => return Err(GatewayAttemptError::Unavailable), }; + // Bound allocation before decoding, even if a record or rollback file + // has been replaced by an oversized file on disk. + let limit = u64::try_from(maximum) + .ok() + .and_then(|n| n.checked_add(1)) + .ok_or(GatewayAttemptError::Corrupt)?; + let mut bytes = Vec::new(); + file.take(limit) + .read_to_end(&mut bytes) + .map_err(|_| GatewayAttemptError::Unavailable)?; if bytes.is_empty() || bytes.len() > maximum { return Err(GatewayAttemptError::Corrupt); } @@ -1543,17 +1583,32 @@ enum ExpectedPlan<'a> { /// no counters. fn claim_record( request: &ClosedProviderRequest, - recipe_digest: [u8; 32], + binding: &EffectBinding, + approval: &ExactEffectApproval, evaluated_at: u64, ) -> Result { let mut nonce = [0_u8; 16]; getrandom::fill(&mut nonce).map_err(|_| GatewayAttemptError::Unavailable)?; let record = Record { schema: SCHEMA.to_owned(), + binding_canonical: String::from_utf8( + binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, + approval_canonical: String::from_utf8( + approval + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, namespace: request.namespace().as_str().to_owned(), operation_id: request.operation_id().as_str().to_owned(), action_commitment: hex::encode(request.action_commitment()), - recipe_digest: hex::encode(recipe_digest), + recipe_digest: hex::encode(binding.journal_identity().3), nonce: hex::encode(nonce), evaluated_at, stage: GatewayAttemptStage::Attempting, @@ -1576,13 +1631,34 @@ fn claim_record( #[derive(Clone)] pub struct GatewayAttempts { store: Arc, + policy: EffectPolicy, } impl GatewayAttempts { - /// Uses `store` for every claim and stage change. - #[must_use] - pub fn new(store: Arc) -> Self { - Self { store } + /// Uses one installed partition and epoch for every claim and lookup. + /// + /// # Errors + /// Refuses invalid installed policy. There is no implicit replay namespace. + pub fn new( + store: Arc, + policy: EffectPolicy, + ) -> Result { + policy + .validate() + .map_err(|_| GatewayAttemptError::Corrupt)?; + Ok(Self { store, policy }) + } + + pub(crate) fn policy(&self) -> &EffectPolicy { + &self.policy + } + + fn key( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + ) -> Result { + GatewayAttemptKey::for_operation(&self.policy, namespace, operation) } /// Returns the underlying mechanism. @@ -1591,21 +1667,35 @@ impl GatewayAttempts { Arc::clone(&self.store) } - /// Claims one logical ID before credential access or transport entry. The - /// record keeps the request's verified action commitment, the gateway - /// evaluation time, and the observation plan; a later echo token is - /// always derived from this record. - /// - /// # Errors - /// An existing record, including a crashed claim, is `Replay`. - pub async fn claim( + /// Reference-store oracle only; production admission requires ApprovedEffect. + #[cfg(any(test, feature = "testkit-harness"))] + pub(crate) async fn claim( &self, request: &ClosedProviderRequest, recipe_digest: [u8; 32], evaluated_at: u64, ) -> Result { - let key = GatewayAttemptKey::for_operation(request.namespace(), request.operation_id()); - let record = claim_record(request, recipe_digest, evaluated_at)?; + let binding = + crate::effect::store_binding_fixture(request, recipe_digest, [0; 32], &self.policy) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let approval = crate::effect::approval_fixture(&binding, evaluated_at) + .map_err(|_| GatewayAttemptError::Corrupt)?; + self.claim_binding(request, &binding, &approval, evaluated_at) + .await + } + + async fn claim_binding( + &self, + request: &ClosedProviderRequest, + binding: &EffectBinding, + approval: &ExactEffectApproval, + evaluated_at: u64, + ) -> Result { + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let key = self.key(request.namespace(), request.operation_id())?; + let record = claim_record(request, binding, approval, evaluated_at)?; let stored = encode(&record)?; let store = Arc::clone(&self.store); let entry = GatewayRecordEntry { @@ -1614,7 +1704,12 @@ impl GatewayAttempts { record: stored.clone(), expires_at: None, }; - blocking(move || store.insert(&entry)).await?; + let expected = record.binding_canonical.clone(); + blocking(move || match store.insert(&entry) { + Err(GatewayAttemptError::Replay) => Err(existing_binding(&*store, key, &expected)), + result => result, + }) + .await?; Ok(ClaimedGatewayAttempt { attempt: Attempt { store: Arc::clone(&self.store), @@ -1626,7 +1721,9 @@ impl GatewayAttempts { } /// Lists at most `limit` stored attempts as the hexadecimal digest that - /// keys each one and its conservative stage. Nothing else of an attempt + /// keys each one and its conservative stage, restricted to this installed + /// partition and epoch. At most `limit` raw entries are inspected; entries + /// in another scope can make the result shorter. Nothing else of an attempt /// is returned: no operation identifier, argument, or provider value. /// /// # Errors @@ -1636,6 +1733,7 @@ impl GatewayAttempts { limit: usize, ) -> Result, GatewayAttemptError> { let store = Arc::clone(&self.store); + let policy = self.policy.clone(); blocking(move || { store .attempt_keys(limit)? @@ -1644,7 +1742,19 @@ impl GatewayAttempts { let stage = store .load(GatewayRecordKind::Attempt, &key) .and_then(|bytes| bytes.map(|bytes| decode(&bytes)).transpose()) - .and_then(|record| record.map(|record| record.snapshot(true)).transpose()); + .and_then(|record| { + let Some(record) = record else { + return Ok(None); + }; + let binding = EffectBinding::from_private_bytes( + record.binding_canonical.as_bytes(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !policy.contains(&binding) { + return Ok(None); + } + record.snapshot(true).map(Some) + }); match stage { Ok(Some(snapshot)) => { Some(Ok((hex::encode(key.as_bytes()), snapshot.stage()))) @@ -1747,10 +1857,11 @@ impl GatewayAttempts { ExpectedPlan::Stored => true, } && record.observation_request().is_some(); + let key = self.key(namespace, operation_id)?; Ok(resumable.then(|| ObservableGatewayAttempt { attempt: Attempt { store: Arc::clone(&self.store), - key: GatewayAttemptKey::for_operation(namespace, operation_id), + key, stored, record, }, @@ -1762,14 +1873,19 @@ impl GatewayAttempts { namespace: &OperatorNamespace, operation_id: &LogicalOperationId, ) -> Result, Record)>, GatewayAttemptError> { - let key = GatewayAttemptKey::for_operation(namespace, operation_id); + let key = self.key(namespace, operation_id)?; let store = Arc::clone(&self.store); let Some(bytes) = blocking(move || store.load(GatewayRecordKind::Attempt, &key)).await? else { return Ok(None); }; let record = decode(&bytes)?; - if record.namespace != namespace.as_str() || record.operation_id != operation_id.as_str() { + let binding = EffectBinding::from_private_bytes(record.binding_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !self.policy.contains(&binding) + || record.namespace != namespace.as_str() + || record.operation_id != operation_id.as_str() + { return Err(GatewayAttemptError::Corrupt); } Ok(Some((bytes, record))) @@ -2005,6 +2121,29 @@ fn encode(record: &Record) -> Result, GatewayAttemptError> { Ok(bytes) } +/// Existing claims never disappear. A loser compares the immutable complete +/// binding after the insert transaction reports a collision, without minting +/// any capability or consuming another reservation. +fn existing_binding( + store: &dyn GatewayAttemptStore, + key: GatewayAttemptKey, + expected: &str, +) -> GatewayAttemptError { + let checked = (|| { + let bytes = store + .load(GatewayRecordKind::Attempt, &key)? + .ok_or(GatewayAttemptError::Corrupt)?; + let record = decode(&bytes)?; + record.snapshot(false)?; + Ok::<_, GatewayAttemptError>(record.binding_canonical == expected) + })(); + match checked { + Ok(true) => GatewayAttemptError::Replay, + Ok(false) => GatewayAttemptError::BindingConflict, + Err(error) => error, + } +} + fn decode(bytes: &[u8]) -> Result { if bytes.is_empty() || bytes.len() > MAX_RECORD_BYTES { return Err(GatewayAttemptError::Corrupt); @@ -2361,29 +2500,42 @@ fn reserve_with_claim( impl GatewayAttempts { /// Claims one logical ID together with one slot of every count and sum /// counter `bound` names, in one all-or-none batch, before credential - /// access or transport entry. Without a bound it is [`Self::claim`]. + /// access or transport entry. Unbounded effects insert only the claim. /// Slots are never released, and a replay consumes none. /// /// # Errors - /// An existing claim is `Replay`; a store failure stores nothing. + /// An identical binding is `Replay`; a different binding for the same + /// operation is `BindingConflict`. Store errors never authorize entry. pub(crate) async fn claim_bounded( &self, - request: &ClosedProviderRequest, - recipe_digest: [u8; 32], + approved: &ApprovedEffect, evaluated_at: u64, - bound: Option<&crate::bounds::BoundAdmission>, ) -> Result { - let Some(bound) = bound else { + let command = approved.command(); + let request = &command.request; + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let Some(bound) = command.bound.as_ref() else { return self - .claim(request, recipe_digest, evaluated_at) + .claim_binding(request, binding, approved.approval(), evaluated_at) .await .map(|claim| BoundedClaim::Claimed(Box::new(claim))); }; - let key = GatewayAttemptKey::for_operation(request.namespace(), request.operation_id()); - let base = claim_record(request, recipe_digest, evaluated_at)?; + let key = self.key(request.namespace(), request.operation_id())?; + let base = claim_record(request, binding, approved.approval(), evaluated_at)?; let store = Arc::clone(&self.store); let bound = bound.clone(); - let reserved = blocking(move || reserve_with_claim(&*store, key, &base, &bound)).await?; + let reserved = blocking( + move || match reserve_with_claim(&*store, key, &base, &bound) { + Err(GatewayAttemptError::Replay) => { + Err(existing_binding(&*store, key, &base.binding_canonical)) + } + result => result, + }, + ) + .await?; Ok(match reserved { Reserved::Claimed { stored, record } => { BoundedClaim::Claimed(Box::new(ClaimedGatewayAttempt { diff --git a/product/runtime/auths-gateway/src/store_testkit.rs b/product/runtime/auths-gateway/src/store_testkit.rs index 9a5226b0c..d16507547 100644 --- a/product/runtime/auths-gateway/src/store_testkit.rs +++ b/product/runtime/auths-gateway/src/store_testkit.rs @@ -154,7 +154,11 @@ impl Drop for TestAttempts { } fn attempts_at(location: &Location) -> GatewayAttempts { - GatewayAttempts::new(raw_at(location)) + GatewayAttempts::new( + raw_at(location), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts") } fn raw_at(location: &Location) -> Arc { diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 047ecda89..54d5317f3 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -47,7 +47,11 @@ pub(crate) trait SubmitIo { fn clock(&self) -> Option; /// Verifies natively at `now` and projects the verified command. - fn verify(&self, now: u64) -> Result; + fn verify( + &self, + now: u64, + recipe: &CompiledRecipe, + ) -> Result; /// Revalidates the retained original authority and approval against the /// prepared installation. This is still separate from the durable fence. @@ -454,7 +458,7 @@ impl Run<'_, I> { } fn verify(&mut self) -> Verification { - let approved = match self.io.verify(self.evaluated_at) { + let approved = match self.io.verify(self.evaluated_at, self.cx.recipe) { Ok(verified) => verified, Err(result) => { self.refuse_before_claim(result); @@ -534,18 +538,13 @@ impl Run<'_, I> { } async fn claim(&mut self) -> ClaimResult { - let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { + let Some(approved) = self.verified.as_ref() else { return ClaimResult::Unavailable; }; match self .cx .attempts - .claim_bounded( - &verified.request, - *self.cx.recipe.digest(), - self.evaluated_at, - verified.bound.as_ref(), - ) + .claim_bounded(approved, self.evaluated_at) .await { Ok(BoundedClaim::Claimed(claim)) => { @@ -561,6 +560,10 @@ impl Run<'_, I> { ClaimResult::Unavailable } Err(GatewayAttemptError::Replay) => ClaimResult::Replay, + Err(GatewayAttemptError::BindingConflict) => { + self.refuse_before_claim(not_entered("gateway.effect.operation-conflict")); + ClaimResult::Refused + } Err(_) => { self.refuse_before_claim(not_entered("gateway.attempt.unavailable")); ClaimResult::Unavailable From 4e0f435de8ade5627d42f57b5453aff49feddfc9 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 03:14:33 +0000 Subject: [PATCH 012/136] feat(stores): add bounded gateway writer fences --- compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 62 +++++- docs/plans/0074-implementation-status.md | 37 +++- .../0009-bound-effect-and-recovery.md | 19 ++ .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 10 +- .../auths-gateway/src/scenario_tests.rs | 175 ++++++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 138 ++++++++++++- .../auths-stores/src/gateway_attempt.rs | 193 +++++++++++++++--- product/stores/auths-stores/src/lib.rs | 5 +- product/stores/auths-stores/src/lifecycle.rs | 15 +- 12 files changed, 611 insertions(+), 49 deletions(-) diff --git a/compliance.toml b/compliance.toml index f49003822..8a29dbeef 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1954,6 +1954,8 @@ stateful-replay-budget-component = [ "product/stores/auths-stores/src/lifecycle.rs#crash_matrix_reopens_old_or_new_canonical_state_never_partial_state", "product/stores/auths-stores/src/gateway_attempt.rs#gateway_records_are_bounded_before_any_database_call", "product/stores/auths-stores/src/gateway_attempt.rs#expiry_is_present_exactly_for_slots_and_keys_are_distinct", + "product/stores/auths-stores/src/gateway_attempt.rs#fence_sets_are_bounded_distinct_and_target_durable_state", + "product/stores/auths-stores/src/lifecycle.rs#production_pool_and_server_identity_are_bounded", ] [packages."@auths-dev/sdk"] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 6ad4c5682..674245790 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -52,8 +52,10 @@ alone do not establish the multi-process order. Before the durable mutation cutover, this ADR must record the implemented file lock and PostgreSQL transaction scopes, lock order, versioned dependency records, configuration/revocation writer participation, after-lock clock sampling, -verification deadlines and durable acknowledgement. This adapter design is -still open. The present attempt CAS and connection reload do not satisfy it. +verification deadlines and durable acknowledgement. The P2 design below fixes +that mechanism; its source implementation alone does not satisfy final entry +until the shared configuration record and grant owner are connected. The present +attempt CAS and connection reload do not satisfy it. Cross-store state requires demonstrated fencing; unsupported atomicity fails closed. Capacity reserved earlier is checked for intact conservation at grant, not allocated a second time. @@ -119,3 +121,59 @@ its new binding/scope cases have not yet been executed on hosted CI. This cutover does not replace `Attempting` with a durable entry grant, provide a configuration fence, or finish independent recovery authority. Those remain the explicit P2 requirements above. + +## P2 adapter fence design + +The gateway keeps lifecycle interpretation in its existing transition owner. +The adapter adds one mechanism: read a bounded set of records under the common +writer fence, invoke one bounded in-process decision, and durably replace the +first record before returning. The decision receives opaque snapshots, performs +no provider, custody or nested store I/O, and returns only the replacement bytes. +The adapter calls it at most once and never retries a failed/ambiguous commit. +The gateway alone interprets those bytes and may consume a newly acknowledged +`Reserved -> EntryGranted` transition to construct one non-cloneable permit. +Reading `EntryGranted` from disk cannot construct that permit. + +File scope is the existing host-wide `.replace.lock`. Every insert, batch, +replacement, sweep and fenced decision uses it; fenced snapshots use lock-held +read helpers instead of acquiring the lock recursively. Acquisition uses +nonblocking flock attempts with a two-second deadline. The decision's work is +bounded by the native input limits and a two-second elapsed deadline; the store +checks the deadline before publication. Atomic replacement uses synced temporary +bytes, rename and directory sync. A failure after publication returns no permit; +the surviving grant prevents reminting after restart. OS scheduling and storage +sync are trusted platform operations, not preemptible hard real-time guarantees. + +PostgreSQL scope is an advisory transaction lock keyed by the qualified gateway +record table's OID and a fixed gateway domain. All gateway insert, replacement +and expiry-sweep writers acquire it before row work; this includes connection +revocation and credential rotation. Row insertion retains sorted key order. +The fence uses READ COMMITTED: snapshots are loaded only after the advisory lock +is acquired, so a committed predecessor is visible. Local lock, statement and +idle-transaction timeouts bound database waits and preserve any tighter installed +pool timeout; values below SQL's millisecond precision are rejected rather than +silently disabling a deadline. The same two-second decision +limit applies before UPDATE and COMMIT. COMMIT must acknowledge durability before +the caller receives success. Pool failures, serialization errors, timeouts and +ambiguous commits return no permit. No transaction spans credential access or a +provider call. Shared-store throughput is deliberately serialized initially; +partitioned locks require later evidence for shared-budget and configuration +interactions, not an opportunistic optimization. + +The final decision's bounded read set must contain the attempt, its connection, +the shared installed-configuration/revocation record and every reserved counter +slot. The native owner samples the deployment clock after obtaining those +snapshots, revalidates the original proof, exact approval and current policy, +checks pinned configuration/revocation and intact reservation membership, then +records the grant and audit event in the same attempt replacement. Reserved +slots become consumed by the grant stage, without allocating or charging them +twice. Unsupported split-store installations fail closed. + +A new shared configuration record must pin recipe/compiler, trust context, +operator effect policy and qualification/revocation versions. Installation, +qualification refresh and operator configuration writers must participate in +the same fence; a host's cached configuration must match that record. Local +manifest comparison and process-local revocation caches are insufficient. +The primitive described here is only preparation: until the shared record, +writer participation and grant reducer are connected, the current engine does +not claim this final-entry guarantee. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 395f44aa9..4cee3c199 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -182,13 +182,48 @@ remain open, and the goal remains active. observation path must be replaced by independently authorized bounded recovery; the updated reference cases do not establish that future contract. +## P2 fence preparation + +The concrete fence design is recorded in ADR 0017 before entry behavior changes. +File and PostgreSQL adapters now expose one bounded snapshot-and-replace +operation. All PostgreSQL gateway mutations acquire the same table-scoped +advisory transaction lock, including connection updates and allocation sweeps. +File locking uses the existing shared writer lock with bounded acquisition. +The native decision runs once under that lock, before durable replacement; a +callback failure, deadline or ambiguous commit returns no acknowledgement. +The API cannot itself issue an entry permit. + +Read sets are bounded to 64 distinct records with a non-expiring first target. +File reads use lock-held helpers to avoid recursive lock acquisition. +PostgreSQL uses READ COMMITTED snapshots after acquiring the lock, retains +sorted batch insertion and explicitly commits replacements and sweeps. Two-second +lock/decision bounds preserve tighter installed SQL timeouts; sub-millisecond +pool values are rejected instead of rounding to disabled timeouts. + +The shared conformance source now races each of replacement, insertion and +sweeping against a held fence, checks the next snapshot sees the predecessor, +and checks a refused decision preserves the target and is never retried. +These tests are authored but not executed. Required semantic-closure artifact +generation passed after fixing an error-type inference ambiguity introduced by +the store error conversion; it compiles the source but does not exercise these +adapter races. Final regeneration after the millisecond-bound correction also +passed: `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact semantic_closure::tests::semantic_closure_is_current` (one artifact-generation +test), on `96e47805` plus this fence source. This is compilation/artifact evidence, +not execution of file/PostgreSQL conformance or final-entry behavior. + +Remaining P2 work: shared configuration/revocation record and every writer's +participation, Reserved/EntryGranted reducer and immutable audit event, checking +all reservation membership and final native authority under the fence, and +issuing/consuming a permit only from a new acknowledged transition. The old +Attempting send path is not represented as compliant final entry. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | In progress | Finish installed first mutation cutover and native fixtures | -| P2 | Pending | Explicit reservation/grant reducer, atomic fencing, both adapters | +| P2 | Adapter preparation | Shared configuration, reservation/grant reducer and fenced permit wiring | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 6c31e65e4..9f4f95108 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -111,3 +111,22 @@ cover verification, compilation, transaction/lock time, bounded memory and scans for both recipes and read/disclosure. No measurements have yet been executed. Actual results and exact revisions belong in the [acceptance ledger](../../../plans/0074-implementation-status.md). + +## Adapter fence mechanism + +The existing attempt adapters now have one bounded snapshot-and-replace +operation. Its decision callback is in-process native validation over opaque +snapshots, not a provider/profile dispatcher or an extension plugin. It runs +once while the same lock excludes connection replacement, allocation insertion +and expiry sweeping; it returns one record replacement. No provider or custody +call may run under the lock, and no error is retried automatically. File +publication and PostgreSQL COMMIT must acknowledge before returning success. + +Both maintained adapters share a 64-record read bound and two-second lock and +decision ceilings; tighter installed PostgreSQL deadlines are preserved. +The source conformance suite orders replacement, insertion and sweep writers +against a held decision and checks failure atomicity. This source has not yet +been exercised in hosted CI. The mechanism does not itself interpret effect +identity, grant entry or establish multi-host revocation freshness. Connecting +the shared configuration record and one-use grant owner remains P2 work, as +specified in ADR 0017. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index b5d7f2261..702e418d2 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"fa23a962fd90331152eed5edbcdf271955f7aed79b8da1e065bfe69a20b487a9"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"e0045f877c4b7fe3860c291039853885064ddcdebba7c9b345ab65e81e646dda"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"6f80f63833ea0815bb44fbf3b0cc54624a08e9fb578b035819f2980dc04e8256"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3dba485deeb4d60f3f5603ad4ce9a0edf49a85c68c5c4ca072df73d2910da832"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"24b48d5eaeaaa3c620e2dfc7ee1f9255fc4519a1eb404b8608cea7af6a910ee2"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"37a097fc8a9261d3fffdaef3f905f40b22e3e6601bb5101fadd9414f963c0824"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"692ff372ffab10f27fcc45b7aa28457ca3fd6f9ca0ca06212f20f34c4431b491"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c87e479f3eb281960f6c9c80d43c7560d7ccb654b0154ec823d3fcec4884ac05"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"fad95d031f88072dd024c78facf0bb0267562b1ac743ddd7219fce47e64024f0"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"a22be071695f89ca2578a4d82fd80d9cb82289213c9bdb8f0470f6b2dc3d9201"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"c3c36954a3e86723df035b47f43b85fc8ab3a6292983522b6258d5c6b4e6c4e4"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"47ef3c8cb1c5504d47ae9a0088705ce6715fe86bac1671a34a56fb38a64d0dd3"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"939c081e2e154aaf10186754044bdd65608932c899b970a04a71d0afaa999a93"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"c597c83de2b94f0374ae54e40a8b57c2a64ec6e254704dca32185f448a908aca"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4ee7cadfb5f46a92713c80f3e55f499cb074d04d8b21ea89d57762af38642bfa"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"a9178a2e58eea459d5e5dafc53a3999ea7c84dbbffefe6e5eb1f3d098827f028"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"aac551a2481bbc60864c64079bc667dcb232e45a0f41a04073ed84ab5dbe1fce"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"025b53473b3af6900e03bc2fee91aa63ed26a8778bc8c8296fe08f5540794c39"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"884bcad4d70d53e12eae9c8517f6ecd0643068ee0be0370015119d04d6cc2516"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"88d82fee42f1b8ef521e8deef0216e938ebeaad822eb2f5020e70b89d145ea70"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"fe2eacb5ad8152eeecbd232c47a356fc72db0098e34fda99532bdf6ef0cf895c"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"218841602d3d9b23b44625f50e5b54cf275ccedc2d5c89f02d2482b8524472af"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"e721262edf8a9ab5568ddc27639176312d4a366203b5f73e2d7c11fde2c554e9"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"3f2cecfda13fdcd7c4a944518646bcc8abd1237f900c0332d5822281f8f9f1cd"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"fa23a962fd90331152eed5edbcdf271955f7aed79b8da1e065bfe69a20b487a9"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"dcd0282db18359bc9ffbb5e61f12c2f61de42e4e79f5ed59f299a8cb022d6a6d"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"1ee30027b3b83a208aa35b1bc01ee2accc1d4f6dc88a758f6b99ee5904d61c59"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2c7bb0181acf6c8706aa1546d51ff58195f39a331eb917d29fe8c98012635c10"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"56a34f797ec7c65c0b0c5d15f415fd4d6aaf14a89a48dc24fd0cc2a43f8adf07"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"298686a44c6c9780eda73d17305def3221ca4d4c19f77d1542ad1603350a378b"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c3eb4f92fcc7b0d453b813c948ed885c006bb2f204d362effdb1dd50b2af29ef"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"6fb307ee3f20236736078f3bcb0e612aed078cf5e45da7e5c453f7f8cc6e06b5"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"f31ed04ac5340590efb00e0962ac580e1a11fda922bebc961d2b3a7c1fe3c96b"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"61e904f5ff9174b6dae75c2cea1896d86f18e5dc8b07db24021f63952420a3a4"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"176764bce092c8d442c30b6c77c3cafa98d089914250d273144410fc3070b0ce"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"63a29c1b74dca778238f69bf6d4e8dc73673cbfe866e5d0d94b020710376e318"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 72c1f2b19..e8c4f7a7f 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -138,11 +138,11 @@ pub use separation::{ pub use store::{ ClaimedGatewayAttempt, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, - GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayInsert, - GatewayObservationFact, GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, - GatewayRecordKind, GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, - PrivateDirectoryError, check_private_directory, check_private_directory_owned_by, - pre_entry_digest, + GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, + GatewayInsert, GatewayObservationFact, GatewayPreEntry, GatewayProviderEvidence, + GatewayRecordEntry, GatewayRecordKind, GatewayRelativeBasis, ObservableGatewayAttempt, + PostgresGatewayAttemptStore, PrivateDirectoryError, check_private_directory, + check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index b0f6dc80b..ef72ad217 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -97,6 +97,25 @@ impl RecordingStore { } impl GatewayAttemptStore for RecordingStore { + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut crate::GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + let mut replacement = None; + self.inner.fenced_replace(keys, &mut |snapshot| { + let next = decide(snapshot)?; + replacement = Some(next.clone()); + Ok(next) + })?; + if keys[0].0 == GatewayRecordKind::Attempt + && let Some(next) = replacement + { + self.record(&next); + } + Ok(()) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { self.inner.attempt_keys(limit) } @@ -2259,6 +2278,161 @@ async fn conformance_sweep_bounds(backend: Backend) { .expect("sweep checks"); } +/// The adapter calls one native decision while all gateway mutators are +/// excluded. These are opaque mechanism records, not native grant evidence. +async fn conformance_writer_fence(backend: Backend) { + for mutation in ["replace", "insert", "sweep"] { + let store = TestAttempts::open(backend); + let (fenced, writer, reader) = (store.raw(), store.raw(), store.raw()); + tokio::task::spawn_blocking(move || { + use std::{sync::mpsc, time::Duration}; + let target = GatewayAttemptKey::from_bytes([11; 32]); + let dependency = GatewayAttemptKey::from_bytes([12; 32]); + let allocation = GatewayAttemptKey::from_bytes([13; 32]); + let absent = GatewayAttemptKey::from_bytes([14; 32]); + reader + .insert(&attempt_entry(target, b"reserved")) + .expect("target"); + reader + .insert(&GatewayRecordEntry { + kind: GatewayRecordKind::Connection, + key: dependency, + record: b"active".to_vec(), + expires_at: None, + }) + .expect("connection"); + reader + .insert(&GatewayRecordEntry { + kind: GatewayRecordKind::CountSlot, + key: allocation, + record: b"allocation".to_vec(), + expires_at: Some(NOW), + }) + .expect("allocation"); + let keys = [ + (GatewayRecordKind::Attempt, target), + (GatewayRecordKind::Connection, dependency), + (GatewayRecordKind::CountSlot, allocation), + (GatewayRecordKind::CountSlot, absent), + ]; + let (entered_tx, entered_rx) = mpsc::channel(); + let (release_tx, release_rx) = mpsc::channel(); + let decision = std::thread::spawn(move || { + let mut calls = 0; + let result = fenced.fenced_replace(&keys, &mut |snapshot| { + calls += 1; + assert_eq!( + snapshot, + &[ + Some(b"reserved".to_vec()), + Some(b"active".to_vec()), + Some(b"allocation".to_vec()), + None + ] + ); + entered_tx.send(()).expect("entered"); + release_rx + .recv_timeout(Duration::from_secs(1)) + .expect("release"); + Ok(b"entry-granted".to_vec()) + }); + assert_eq!(calls, 1); + result + }); + entered_rx + .recv_timeout(Duration::from_secs(2)) + .expect("fenced snapshot"); + let (started_tx, started_rx) = mpsc::channel(); + let (done_tx, done_rx) = mpsc::channel(); + let competing = std::thread::spawn(move || { + started_tx.send(()).expect("writer started"); + let result = match mutation { + "replace" => writer.replace( + GatewayRecordKind::Connection, + &dependency, + b"active", + b"revoked", + ), + "insert" => writer.insert(&GatewayRecordEntry { + kind: GatewayRecordKind::CountSlot, + key: absent, + record: b"new-allocation".to_vec(), + expires_at: Some(NOW + 1), + }), + "sweep" => writer.sweep_expired(NOW, 1).map(|n| assert_eq!(n, 1)), + _ => unreachable!("closed test mutation"), + }; + done_tx.send(result).expect("writer result"); + }); + started_rx + .recv_timeout(Duration::from_secs(1)) + .expect("writer starts"); + assert!( + matches!( + done_rx.recv_timeout(Duration::from_millis(40)), + Err(mpsc::RecvTimeoutError::Timeout) + ), + "{mutation} must wait for the fence" + ); + release_tx.send(()).expect("release"); + decision + .join() + .expect("decision thread") + .expect("durable replacement"); + done_rx + .recv_timeout(Duration::from_secs(2)) + .expect("writer completes") + .expect("writer result"); + competing.join().expect("writer thread"); + assert_eq!( + reader + .load(GatewayRecordKind::Attempt, &target) + .expect("target"), + Some(b"entry-granted".to_vec()) + ); + let mut calls = 0; + assert_eq!( + reader.fenced_replace(&keys, &mut |snapshot| { + calls += 1; + match mutation { + "replace" => assert_eq!(snapshot[1], Some(b"revoked".to_vec())), + "insert" => assert_eq!(snapshot[3], Some(b"new-allocation".to_vec())), + "sweep" => assert_eq!(snapshot[2], None), + _ => unreachable!("closed test mutation"), + } + Err(GatewayAttemptError::InvalidTransition) + }), + Err(GatewayAttemptError::InvalidTransition) + ); + assert_eq!(calls, 1, "decision refusal is never retried"); + assert_eq!( + reader + .load(GatewayRecordKind::Attempt, &target) + .expect("target"), + Some(b"entry-granted".to_vec()), + "refusal preserves original bytes" + ); + assert!( + reader + .fenced_replace(&[], &mut |_| panic!("invalid set must not call decision")) + .is_err() + ); + assert_eq!( + reader.fenced_replace( + &[( + GatewayRecordKind::Attempt, + GatewayAttemptKey::from_bytes([99; 32]) + )], + &mut |_| panic!("missing target must not call decision") + ), + Err(GatewayAttemptError::Conflict) + ); + }) + .await + .expect("writer fence conformance"); + } +} + /// A connection record committed through one store instance is what every /// other instance sharing the store reads next, and a stale compare-and-swap /// through another instance is a conflict. @@ -2327,6 +2501,7 @@ async fn store_conformance(backend: Backend) { conformance_batches_from_two_processes(backend).await; conformance_sweep_bounds(backend).await; conformance_shared_connection_record(backend).await; + conformance_writer_fence(backend).await; } #[tokio::test] diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index d78159007..20623429c 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "5de8b12ec7c774cb49f8292b350c7ebe9f294a7f565cd311b2ca5c748db9ea64"; + "5bcbbf6cbde0a906dd7b05f69fdf02d1ee23e9463fd0bd0d9b9f3d8cd3e003fc"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index b3dfdf90b..fc1902b07 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -29,6 +29,7 @@ use std::{ io::{Read as _, Write as _}, path::{Component, Path, PathBuf}, sync::Arc, + time::Instant, }; use tempfile::NamedTempFile; use thiserror::Error; @@ -617,7 +618,7 @@ impl Record { slot: entry.slot, }) }) - .collect::, _>>()?; + .collect::, GatewayAttemptError>>()?; if counters.windows(2).any(|pair| pair[0] >= pair[1]) { return Err(GatewayAttemptError::Corrupt); } @@ -952,6 +953,23 @@ pub enum GatewayInsert { }, } +/// One bounded native decision over a snapshot held behind the adapter's +/// writer fence. It must not perform custody, provider or nested store I/O. +/// The adapter invokes it at most once; returning bytes does not grant entry. +pub type GatewayFenceDecision<'a> = + dyn FnMut(&[Option>]) -> Result, GatewayAttemptError> + 'a; + +fn fence_keys( + keys: &[(GatewayRecordKind, GatewayAttemptKey)], +) -> Result, GatewayAttemptError> { + if keys.is_empty() || keys.len() > auths_stores::MAX_GATEWAY_FENCE_RECORDS { + return Err(GatewayAttemptError::Corrupt); + } + let keys: Vec<_> = keys.iter().map(|(kind, key)| (*kind, key.0)).collect(); + auths_stores::validate_gateway_fence(&keys).map_err(postgres_error)?; + Ok(keys) +} + /// Durable storage of opaque gateway records of five closed kinds. /// Implementations never interpret the bytes. /// @@ -960,6 +978,19 @@ pub enum GatewayInsert { /// sweeps of expired slots only, and fail-closed reads that never report /// unreadable state as absent. pub trait GatewayAttemptStore: Send + Sync { + /// Reads the bounded set while excluding every participating writer, calls + /// `decide` once, and durably replaces the first record. This is a storage + /// mechanism; the gateway owns validation and the one-use permit. + /// + /// # Errors + /// Refuses invalid sets, missing target, unavailable locking, corrupt + /// state, decision failures and ambiguous durability. No automatic retry. + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError>; + /// Inserts every entry, or none when any key already exists. /// /// # Errors @@ -1174,6 +1205,21 @@ impl FileGatewayAttemptStore { Ok(pending) } + fn load_locked( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + let path = self.path_for(kind, key); + if kind.expires() { + Self::read_file(&path, MAX_SLOT_FILE_BYTES)? + .map(|bytes| Self::decode_slot(&bytes).map(|(_, record)| record)) + .transpose() + } else { + Self::read_file(&path, MAX_RECORD_BYTES) + } + } + fn lock(&self, operation: rustix::fs::FlockOperation) -> Result { let mut options = OpenOptions::new(); options.read(true).write(true).create(true).truncate(false); @@ -1185,8 +1231,33 @@ impl FileGatewayAttemptStore { let lock = options .open(self.root.join(LOCK_FILE)) .map_err(|_| GatewayAttemptError::Unavailable)?; - rustix::fs::flock(&lock, operation).map_err(|_| GatewayAttemptError::Unavailable)?; - Ok(lock) + let nonblocking = match operation { + rustix::fs::FlockOperation::LockExclusive => { + rustix::fs::FlockOperation::NonBlockingLockExclusive + } + rustix::fs::FlockOperation::LockShared => { + rustix::fs::FlockOperation::NonBlockingLockShared + } + _ => return Err(GatewayAttemptError::Unavailable), + }; + let started = Instant::now(); + loop { + match rustix::fs::flock(&lock, nonblocking) { + Ok(()) => return Ok(lock), + Err(error) + if error == rustix::io::Errno::WOULDBLOCK + || error == rustix::io::Errno::INTR => {} + Err(_) => return Err(GatewayAttemptError::Unavailable), + } + let Some(remaining) = auths_stores::GATEWAY_LOCK_TIMEOUT.checked_sub(started.elapsed()) + else { + return Err(GatewayAttemptError::Unavailable); + }; + if remaining.is_zero() { + return Err(GatewayAttemptError::Unavailable); + } + std::thread::sleep(remaining.min(std::time::Duration::from_millis(5))); + } } /// Serializes mutations across every process on this host. @@ -1335,6 +1406,43 @@ fn valid_file_name(name: &str) -> bool { } impl GatewayAttemptStore for FileGatewayAttemptStore { + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + fence_keys(keys)?; + let _lock = self.exclusive()?; + let started = Instant::now(); + let records = keys + .iter() + .map(|(kind, key)| { + if started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE { + return Err(GatewayAttemptError::Unavailable); + } + self.load_locked(*kind, key) + }) + .collect::, _>>()?; + if records[0].is_none() { + return Err(GatewayAttemptError::Conflict); + } + if started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE { + return Err(GatewayAttemptError::Unavailable); + } + let next = decide(&records)?; + if next.is_empty() || next.len() > MAX_RECORD_BYTES { + return Err(GatewayAttemptError::Corrupt); + } + let pending = self.pending(&next)?; + if started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE { + return Err(GatewayAttemptError::Unavailable); + } + pending + .persist(self.path_for(keys[0].0, &keys[0].1)) + .map_err(|_| GatewayAttemptError::Unavailable)?; + sync_directory(&self.root) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { self.claimed_keys(limit) } @@ -1368,14 +1476,7 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { key: &GatewayAttemptKey, ) -> Result>, GatewayAttemptError> { let _lock = self.shared()?; - let path = self.path_for(kind, key); - if kind.expires() { - Self::read_file(&path, MAX_SLOT_FILE_BYTES)? - .map(|bytes| Self::decode_slot(&bytes).map(|(_, record)| record)) - .transpose() - } else { - Self::read_file(&path, MAX_RECORD_BYTES) - } + self.load_locked(kind, key) } fn replace( @@ -1496,6 +1597,15 @@ impl FileGatewayAttemptStore { } impl GatewayAttemptStore for PostgresGatewayAttemptStore { + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + let keys = fence_keys(keys)?; + self.store()?.fenced_gateway_replace(&keys, decide) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { self.store()? .list_gateway_record_keys(GatewayRecordKind::Attempt, limit) @@ -1547,6 +1657,12 @@ impl GatewayAttemptStore for PostgresGatewayAttemptStore { } } +impl From for GatewayAttemptError { + fn from(error: StoreError) -> Self { + postgres_error(error) + } +} + const fn postgres_error(error: StoreError) -> GatewayAttemptError { match error { StoreError::Conflict => GatewayAttemptError::Conflict, diff --git a/product/stores/auths-stores/src/gateway_attempt.rs b/product/stores/auths-stores/src/gateway_attempt.rs index d5d3732b4..c8fba4555 100644 --- a/product/stores/auths-stores/src/gateway_attempt.rs +++ b/product/stores/auths-stores/src/gateway_attempt.rs @@ -7,8 +7,9 @@ use crate::lifecycle::{PostgresLifecycleStore, map_postgres_error}; use auths_lifecycle::StoreError; -use postgres::IsolationLevel; +use postgres::{GenericClient, IsolationLevel, Transaction}; use sha2::{Digest as _, Sha256}; +use std::time::{Duration, Instant}; /// Largest gateway record the schema accepts. pub const MAX_GATEWAY_RECORD_BYTES: usize = 262_144; @@ -16,6 +17,71 @@ pub const MAX_GATEWAY_RECORD_BYTES: usize = 262_144; /// Largest number of records one batch may insert. pub const MAX_GATEWAY_BATCH_ENTRIES: usize = 64; +/// Maximum number of records read by one final-decision fence. +pub const MAX_GATEWAY_FENCE_RECORDS: usize = 64; +/// Maximum lock acquisition wait for a gateway writer. +pub const GATEWAY_LOCK_TIMEOUT: Duration = Duration::from_secs(2); +/// Maximum elapsed decision work before publishing a fenced replacement. +pub const GATEWAY_FENCE_DEADLINE: Duration = Duration::from_secs(2); + +/// Checks the ordered fence read set. The first record is the replacement +/// target and must be durable (not an expiring allocation slot). +/// +/// # Errors +/// Rejects empty/oversized sets, duplicate keys and an expiring target. +pub fn validate_gateway_fence(keys: &[(GatewayRecordKind, [u8; 32])]) -> Result<(), StoreError> { + if keys.is_empty() || keys.len() > MAX_GATEWAY_FENCE_RECORDS { + return Err(StoreError::LimitExceeded); + } + if keys[0].0.expires() { + return Err(StoreError::Corrupt); + } + let mut sorted: Vec<_> = keys.iter().map(|(_, key)| key).collect(); + sorted.sort_unstable(); + if sorted.windows(2).any(|pair| pair[0] == pair[1]) { + return Err(StoreError::Corrupt); + } + Ok(()) +} + +// All gateway writers participate, including connection/configuration writers. +// The second int is a one-to-one signed mapping of the table OID, so isolated +// qualification schemas do not share a lock accidentally. +fn writer_fence(sql: &mut Transaction<'_>, timeout: Duration) -> Result<(), StoreError> { + sql.batch_execute(&format!( + "SET LOCAL lock_timeout = '{}ms'", + timeout.as_millis() + )) + .map_err(|error| map_postgres_error(&error))?; + sql.query_one("SELECT pg_advisory_xact_lock(1095780183, ('auths_gateway_records'::regclass::oid::bigint - 2147483648)::integer)", &[]) + .map_err(|error| map_postgres_error(&error))?; + Ok(()) +} + +fn load_record( + sql: &mut impl GenericClient, + kind: GatewayRecordKind, + key: &[u8; 32], +) -> Result>, StoreError> { + let row = sql.query_opt( + "SELECT record_kind, record_bytes, record_sha256 FROM auths_gateway_records WHERE record_key = $1", + &[&&key[..]], + ).map_err(|error| map_postgres_error(&error))?; + row.map(|row| { + let stored: String = row.try_get(0).map_err(|_| StoreError::Corrupt)?; + let record: Vec = row.try_get(1).map_err(|_| StoreError::Corrupt)?; + let digest: Vec = row.try_get(2).map_err(|_| StoreError::Corrupt)?; + if GatewayRecordKind::parse(&stored) != Some(kind) + || bounded(&record).is_err() + || Sha256::digest(&record).as_slice() != digest + { + return Err(StoreError::Corrupt); + } + Ok(record) + }) + .transpose() +} + /// The closed record kinds of the gateway store. #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub enum GatewayRecordKind { @@ -155,6 +221,7 @@ impl PostgresLifecycleStore { .isolation_level(IsolationLevel::ReadCommitted) .start() .map_err(|error| map_postgres_error(&error))?; + writer_fence(&mut sql, self.gateway_lock_timeout)?; for index in order { let entry = &entries[index]; let digest: [u8; 32] = Sha256::digest(&entry.record).into(); @@ -200,27 +267,66 @@ impl PostgresLifecycleStore { key: &[u8; 32], ) -> Result>, StoreError> { let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; - let row = client - .query_opt( - "SELECT record_kind, record_bytes, record_sha256 - FROM auths_gateway_records - WHERE record_key = $1", - &[&&key[..]], - ) + load_record(&mut *client, kind, key) + } + + /// Reads one bounded snapshot under the common gateway writer fence and + /// replaces the first record with the decision's result. The decision is + /// invoked once, after lock acquisition, and must do bounded native work + /// without network, custody or nested store calls. The adapter never retries. + /// + /// # Errors + /// Refuses malformed read sets, absent target, corrupt state, decision + /// failure or elapsed deadline. Database/commit errors return no durable + /// acknowledgement, including when the commit outcome is ambiguous. + pub fn fenced_gateway_replace>( + &self, + keys: &[(GatewayRecordKind, [u8; 32])], + decide: impl FnOnce(&[Option>]) -> Result, E>, + ) -> Result<(), E> { + validate_gateway_fence(keys)?; + let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; + let mut sql = client + .build_transaction() + .isolation_level(IsolationLevel::ReadCommitted) + .start() .map_err(|error| map_postgres_error(&error))?; - row.map(|row| { - let stored: String = row.try_get(0).map_err(|_| StoreError::Corrupt)?; - let record: Vec = row.try_get(1).map_err(|_| StoreError::Corrupt)?; - let digest: Vec = row.try_get(2).map_err(|_| StoreError::Corrupt)?; - if GatewayRecordKind::parse(&stored) != Some(kind) - || bounded(&record).is_err() - || Sha256::digest(&record).as_slice() != digest - { - return Err(StoreError::Corrupt); - } - Ok(record) - }) - .transpose() + sql.batch_execute(&format!("SET LOCAL statement_timeout = '{}ms'; SET LOCAL idle_in_transaction_session_timeout = '{}ms'", self.gateway_statement_timeout.as_millis(), self.gateway_idle_timeout.as_millis())) + .map_err(|error| map_postgres_error(&error))?; + writer_fence(&mut sql, self.gateway_lock_timeout)?; + let started = Instant::now(); + let records = keys + .iter() + .map(|(kind, key)| { + if started.elapsed() >= GATEWAY_FENCE_DEADLINE { + return Err(StoreError::Timeout); + } + load_record(&mut sql, *kind, key) + }) + .collect::, _>>()?; + if records[0].is_none() { + return Err(StoreError::Conflict.into()); + } + if started.elapsed() >= GATEWAY_FENCE_DEADLINE { + return Err(StoreError::Timeout.into()); + } + let next = decide(&records)?; + bounded(&next)?; + if started.elapsed() >= GATEWAY_FENCE_DEADLINE { + return Err(StoreError::Timeout.into()); + } + let digest: [u8; 32] = Sha256::digest(&next).into(); + let changed = sql.execute("UPDATE auths_gateway_records SET record_bytes = $3, record_sha256 = $4 WHERE record_key = $1 AND record_kind = $2", + &[&&keys[0].1[..], &keys[0].0.as_str(), &next, &&digest[..]]) + .map_err(|error| map_postgres_error(&error))?; + if changed != 1 { + return Err(StoreError::Conflict.into()); + } + if started.elapsed() >= GATEWAY_FENCE_DEADLINE { + return Err(StoreError::Timeout.into()); + } + sql.commit() + .map_err(|error| E::from(map_postgres_error(&error))) } /// Lists at most `limit` keys of the records of `kind`, in key order. @@ -278,7 +384,11 @@ impl PostgresLifecycleStore { let current_digest: [u8; 32] = Sha256::digest(current).into(); let next_digest: [u8; 32] = Sha256::digest(next).into(); let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; - let replaced = client + let mut sql = client + .transaction() + .map_err(|error| map_postgres_error(&error))?; + writer_fence(&mut sql, self.gateway_lock_timeout)?; + let replaced = sql .execute( "UPDATE auths_gateway_records SET record_bytes = $4, record_sha256 = $5 @@ -293,7 +403,7 @@ impl PostgresLifecycleStore { ) .map_err(|error| map_postgres_error(&error))?; if replaced == 1 { - Ok(()) + sql.commit().map_err(|error| map_postgres_error(&error)) } else { Err(StoreError::Conflict) } @@ -315,7 +425,11 @@ impl PostgresLifecycleStore { let now = i64::try_from(now).map_err(|_| StoreError::LimitExceeded)?; let limit = i64::try_from(limit).map_err(|_| StoreError::LimitExceeded)?; let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; - let deleted = client + let mut sql = client + .transaction() + .map_err(|error| map_postgres_error(&error))?; + writer_fence(&mut sql, self.gateway_lock_timeout)?; + let deleted = sql .execute( "DELETE FROM auths_gateway_records WHERE record_key IN ( @@ -327,7 +441,9 @@ impl PostgresLifecycleStore { &[&now, &limit], ) .map_err(|error| map_postgres_error(&error))?; - usize::try_from(deleted).map_err(|_| StoreError::Corrupt) + let deleted = usize::try_from(deleted).map_err(|_| StoreError::Corrupt)?; + sql.commit().map_err(|error| map_postgres_error(&error))?; + Ok(deleted) } } @@ -352,6 +468,33 @@ mod tests { } } + #[test] + fn fence_sets_are_bounded_distinct_and_target_durable_state() { + let keys: Vec<_> = (0..64) + .map(|n| (GatewayRecordKind::Attempt, [n; 32])) + .collect(); + assert_eq!(validate_gateway_fence(&keys), Ok(())); + assert_eq!(validate_gateway_fence(&[]), Err(StoreError::LimitExceeded)); + let mut over = keys.clone(); + over.push((GatewayRecordKind::Connection, [64; 32])); + assert_eq!( + validate_gateway_fence(&over), + Err(StoreError::LimitExceeded) + ); + assert_eq!( + validate_gateway_fence(&[keys[0], (GatewayRecordKind::Connection, keys[0].1)]), + Err(StoreError::Corrupt) + ); + assert_eq!( + validate_gateway_fence(&[(GatewayRecordKind::CountSlot, [0; 32])]), + Err(StoreError::Corrupt) + ); + assert_eq!( + validate_gateway_fence(&[(GatewayRecordKind::SumSlot, [0; 32])]), + Err(StoreError::Corrupt) + ); + } + #[test] fn gateway_records_are_bounded_before_any_database_call() { assert_eq!(bounded(&[]), Err(StoreError::LimitExceeded)); diff --git a/product/stores/auths-stores/src/lib.rs b/product/stores/auths-stores/src/lib.rs index 89543419d..020c7388f 100644 --- a/product/stores/auths-stores/src/lib.rs +++ b/product/stores/auths-stores/src/lib.rs @@ -6,8 +6,9 @@ mod gateway_attempt; mod lifecycle; pub use gateway_attempt::{ - GatewayRecordEntry, GatewayRecordInsert, GatewayRecordKind, MAX_GATEWAY_BATCH_ENTRIES, - MAX_GATEWAY_RECORD_BYTES, validate_gateway_batch, + GATEWAY_FENCE_DEADLINE, GATEWAY_LOCK_TIMEOUT, GatewayRecordEntry, GatewayRecordInsert, + GatewayRecordKind, MAX_GATEWAY_BATCH_ENTRIES, MAX_GATEWAY_FENCE_RECORDS, + MAX_GATEWAY_RECORD_BYTES, validate_gateway_batch, validate_gateway_fence, }; pub use lifecycle::{ InMemoryLifecycleStore, LifecycleCapacityRuleV1, LifecycleStoreConfigurationError, diff --git a/product/stores/auths-stores/src/lifecycle.rs b/product/stores/auths-stores/src/lifecycle.rs index d289f80da..16608124c 100644 --- a/product/stores/auths-stores/src/lifecycle.rs +++ b/product/stores/auths-stores/src/lifecycle.rs @@ -268,6 +268,9 @@ pub struct PostgresLifecycleStore { rules: Vec, maximum_records: usize, pub(crate) pool: Pool>, + pub(crate) gateway_lock_timeout: Duration, + pub(crate) gateway_statement_timeout: Duration, + pub(crate) gateway_idle_timeout: Duration, } /// Connection material that is erased when its owner is dropped. @@ -404,7 +407,7 @@ impl PostgresPoolConfig { self.idle_timeout, ] .iter() - .any(|duration| duration.is_zero() || *duration > Duration::from_hours(24)) + .any(|duration| duration.as_millis() == 0 || *duration > Duration::from_hours(24)) { return Err(LifecycleStoreConfigurationError::InvalidPoolConfiguration); } @@ -659,6 +662,9 @@ impl PostgresLifecycleStore { rules, maximum_records, pool: connections, + gateway_lock_timeout: pool.lock_timeout.min(crate::GATEWAY_LOCK_TIMEOUT), + gateway_statement_timeout: pool.statement_timeout.min(crate::GATEWAY_FENCE_DEADLINE), + gateway_idle_timeout: pool.idle_timeout.min(crate::GATEWAY_FENCE_DEADLINE), }) } @@ -1785,6 +1791,13 @@ mod tests { #[test] fn production_pool_and_server_identity_are_bounded() { + for duration in [Duration::ZERO, Duration::from_nanos(999_999)] { + assert_eq!( + PostgresPoolConfig::new(1, 1, duration, duration, duration, duration), + Err(LifecycleStoreConfigurationError::InvalidPoolConfiguration), + "sub-millisecond settings must not truncate to disabled SQL timeouts" + ); + } assert_eq!( PostgresPoolConfig::new( 2, From 8dbd99391b274d8a9589dd28c1ba0187fb9cd90e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 03:42:40 +0000 Subject: [PATCH 013/136] feat(gateway)!: fence shared installation and revocation memory --- .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 8 +- .../gateway/effect-configuration.json | 7 + .../qualification/schema-vectors.json | 24 +- .../qualification/verification-vectors.json | 94 ++-- compliance.toml | 13 +- ...017-bound-effect-and-recovery-ownership.md | 37 ++ docs/plans/0074-implementation-status.md | 31 +- .../0009-bound-effect-and-recovery.md | 7 +- .../src/vectors/mod.rs | 2 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 76 ++- .../src/commissioning_session/tests.rs | 10 + .../auths-gateway/src/configuration.rs | 447 ++++++++++++++++++ product/runtime/auths-gateway/src/effect.rs | 26 +- .../auths-gateway/src/effect_native_tests.rs | 1 + product/runtime/auths-gateway/src/engine.rs | 112 +++++ product/runtime/auths-gateway/src/lib.rs | 1 + .../auths-gateway/src/qualification.rs | 55 ++- .../auths-gateway/src/qualification_tests.rs | 37 ++ .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 7 +- .../migrations/postgres_lifecycle_v7.sql | 70 +++ .../auths-stores/src/gateway_attempt.rs | 9 +- product/stores/auths-stores/src/lifecycle.rs | 6 +- qualification/reference/expand.py | 2 +- qualification/reference/native_observation.py | 2 +- .../tests/test_native_observation.py | 2 +- .../reference/tests/test_reference.py | 2 +- xtask/src/semantic_freeze.rs | 2 +- 31 files changed, 1003 insertions(+), 95 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-configuration.json create mode 100644 product/runtime/auths-gateway/src/configuration.rs create mode 100644 product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 3d20af181..69ca70e3a 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 04846fadf..8a8a7464a 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"tVxnMe0bJwPg9P6NV4a7zGDPy_cgsSXWP5XQIz8J2H2Tur2m38UZUpCuYYThRKKQlyuzEHmjsQnMtT1MlhjrCQ"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"btcyTvL9Z5CXR0v4Q-jUKDfIRYiAolqpurmQFQcBKfcFlm3ExTmW8vXXSzrexPXn_j_Q8-3bG_mTZVVcWWZfAQ"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 114c30508..07f697151 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -1,15 +1,15 @@ { "schema": "auths.effect-fixture/1", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "ddc0f0224d94e452ef06a63695be6aedad36f9947f8677432b0976526d41214b", + "effect_id_hex": "a347c831aca019b89c21aee5afdd929915b0c15402125539c5e11109ada86b0d", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/1\",\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/1\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[221,192,240,34,77,148,228,82,239,6,166,54,149,190,106,237,173,54,249,148,127,134,119,67,43,9,118,82,109,65,33,75],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"tVxnMe0bJwPg9P6NV4a7zGDPy_cgsSXWP5XQIz8J2H2Tur2m38UZUpCuYYThRKKQlyuzEHmjsQnMtT1MlhjrCQ\"}", + "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"btcyTvL9Z5CXR0v4Q-jUKDfIRYiAolqpurmQFQcBKfcFlm3ExTmW8vXXSzrexPXn_j_Q8-3bG_mTZVVcWWZfAQ\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-Approved\",\"auths_echo\":\"auths-e1-e38d866bf40628b9f92313a8dc13515ad20b2b63498935834e2c6c3435545424\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJjZmM4YjNiNjVjN2Q3NjI0ZjVjMDM4ZjQ5ZThkNzk4NzJiMzI1MTZkZmE3M2EwM2E5OWEwMmE3NjIzY2QyY2MxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwtQXBwcm92ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyMjEsMTkyLDI0MCwzNCw3NywxNDgsMjI4LDgyLDIzOSw2LDE2Niw1NCwxNDksMTkwLDEwNiwyMzcsMTczLDU0LDI0OSwxNDgsMTI3LDEzNCwxMTksNjcsNDMsOSwxMTgsODIsMTA5LDY1LDMzLDc1XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6InRWeG5NZTBiSndQZzlQNk5WNGE3ekdEUHlfY2dzU1hXUDVYUUl6OEoySDJUdXIybTM4VVpVcEN1WVlUaFJLS1FseXV6RUhtanNRbk10VDFNbGhqckNRIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIFB1dw6IqVrQ58Oi4P9Re7Ve2MLzFoKpRm-DZAL7NYcvBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAER3htVt3Aoh5hFUwCLzv5OAc6-IN2aZFFm_1p6QH1o0ziEHaxjl3CForY3H-8nhNwDdp-aOC2bQioKpKcpDIPA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg5OBIkJBwGBaheSXK-uLktL2erWkN-lSFRHqnoPFlmWgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFUeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImNmYzhiM2I2NWM3ZDc2MjRmNWMwMzhmNDllOGQ3OTg3MmIzMjUxNmRmYTczYTAzYTk5YTAyYTc2MjNjZDJjYzEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC1BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJjZmM4YjNiNjVjN2Q3NjI0ZjVjMDM4ZjQ5ZThkNzk4NzJiMzI1MTZkZmE3M2EwM2E5OWEwMmE3NjIzY2QyY2MxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwtQXBwcm92ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxNjMsNzEsMjAwLDQ5LDE3MiwxNjAsMjUsMTg0LDE1NiwzMywxNzQsMjI5LDE3NSwyMjEsMTQ2LDE1MywyMSwxNzYsMTkzLDg0LDIsMTgsODUsNTcsMTk3LDIyNSwxNyw5LDE3MywxNjgsMTA3LDEzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImJ0Y3lUdkw5WjVDWFIwdjRRLWpVS0RmSVJZaUFvbHFwdXJtUUZRY0JLZmNGbG0zRXhUbVc4dlhYU3pyZXhQWG5fal9ROC0zYkdfbVRaVlZjV1daZkFRIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIFB1dw6IqVrQ58Oi4P9Re7Ve2MLzFoKpRm-DZAL7NYcvBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAER3htVt3Aoh5hFUwCLzv5OAc6-IN2aZFFm_1p6QH1o0ziEHaxjl3CForY3H-8nhNwDdp-aOC2bQioKpKcpDIPA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg5OBIkJBwGBaheSXK-uLktL2erWkN-lSFRHqnoPFlmWgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFUeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImNmYzhiM2I2NWM3ZDc2MjRmNWMwMzhmNDllOGQ3OTg3MmIzMjUxNmRmYTczYTAzYTk5YTAyYTc2MjNjZDJjYzEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC1BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-configuration.json b/bindings/fixtures/gateway/effect-configuration.json new file mode 100644 index 000000000..5783a0319 --- /dev/null +++ b/bindings/fixtures/gateway/effect-configuration.json @@ -0,0 +1,7 @@ +{ + "schema": "auths.effect-configuration-fixture/1", + "scope": "native configuration encoding and revision identity; no entry claim", + "key_hex": "0a3bda35987386948830389c2d1906d6e256d391582a910aa5c31928bcb3af16", + "record_canonical": "{\"installation\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"qualification\":{\"bundle\":null,\"memory\":{\"accepted_index_issued_at\":0,\"accepted_revocation_sequence\":0,\"blocked\":false,\"revoked_qualifications\":[],\"revoked_signers\":[]}},\"revision\":1,\"schema\":\"auths.effect-configuration/1\"}", + "revision_token_hex": "a2585b2ebe8247f93e4dacb179e0c1e6bbf69b3301c98e4115b0b5827ee09fe1" +} \ No newline at end of file diff --git a/bindings/fixtures/qualification/schema-vectors.json b/bindings/fixtures/qualification/schema-vectors.json index f8db5468e..4f9b614e4 100644 --- a/bindings/fixtures/qualification/schema-vectors.json +++ b/bindings/fixtures/qualification/schema-vectors.json @@ -23,9 +23,9 @@ "trust_root": "{\"public_key_b64\":\"0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzc\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-trust-root/1\",\"signature_suite\":\"ed25519-v1\"}", "signer_certificate": "{\"root_signature_b64\":\"obGs_sPHvOXfTu8emdHu3odSbdq3PEW0XwoKhrOSb1LQTgq9LOvFPrRcuhE6Tis01Ac9ndvtGQiey6UWh0MmBg\",\"statement\":{\"issued_at\":1789913600,\"not_after\":1805465600,\"not_before\":1789913600,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}", "revocation_list": "{\"root_signature_b64\":\"nVaEVMHFGD_kiB0SIdz3uK3Xh0YlYrUJY-PRkV7_sCAc6mGs39yQxxGsiShFyuVrE_NxGHNnX40Lg6mi_w_hAw\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}", - "release_index": "{\"signature_b64\":\"qLnnKRCjNPMQ4E4htzwihMF_RcLGUtZ-QpmUc0xvAf9So4UwLqsqnQ8iE7KQDBPiDDEaT2tXMdXo8UJx7BKoCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", - "record": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}", - "attestation": "{\"signature_b64\":\"RNvz-GVoozTJulLOMogzaDjwNMmNJIciII7dGyYiqv7CLXqD7OeqqnmO4COD_-YI7CtUTuT50ARNLDOYx6HOAw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"F7krnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "record": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}", + "attestation": "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "provider_contract": "{\"api_release\":\"2026-09-01.fixture\",\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"declarations\":{\"idempotency_sha256\":\"d6ee51b4b1b7adbf404892f9326dd33a8d42047c0d7592aa8366ad4fcf99a300\",\"observation_sha256\":\"41eecb260924ac4b305313888b59325a24161b0c9d60ecda92ab26bc10e3fbf5\",\"recovery_sha256\":\"871f9dded4942ff0262f147ca7fd4992b38da2741bac401abf3cd8dc43d4d2d3\",\"retention_sha256\":\"5e783fc5c0cf8950b44fd3095ff0679df34660600d0e7a59cedb2084e850aec7\"},\"environment_class\":\"provider-test-mode\",\"manual_assumptions\":[\"a refund of a refunded payment is rejected, not repeated\",\"the idempotency key is honored for at least 24 hours\"],\"openapi_slice_sha256\":\"b11c8865e81ede17d33a255a677549fa87ba045c67077495b8749fc5455c0b2f\",\"oracle_version\":\"oracle-1\",\"provider\":\"example-payments\",\"schema\":\"auths.provider-contract/1\"}" }, "provider_contract_id": "f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d", @@ -511,21 +511,21 @@ "artifact": "record", "class": "non-canonical", "reason": "non-canonical", - "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}\n" + "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}\n" }, { "id": "record-exponent-time", "artifact": "record", "class": "non-canonical", "reason": "malformed", - "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1.7899928e9,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}" + "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1.7899928e9,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" }, { "id": "record-repeated-member", "artifact": "record", "class": "non-canonical", "reason": "malformed", - "text": "{\"schema\":\"auths.recipe-qualification/1\",\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}" + "text": "{\"schema\":\"auths.recipe-qualification/1\",\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" }, { "id": "certificate-hardware-signer-kind", @@ -833,14 +833,14 @@ "pointer": "/statement/entries", "value": [ { - "attestation_sha256": "00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82", + "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", "qualification_id": "qlf_01010101010101010101010101010101", - "record_sha256": "e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a" + "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" }, { - "attestation_sha256": "00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82", + "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", "qualification_id": "qlf_01010101010101010101010101010101", - "record_sha256": "e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a" + "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" } ] } @@ -858,9 +858,9 @@ "count": 257, "width": 32, "template": { - "attestation_sha256": "00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82", + "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", "qualification_id": "qlf_{}", - "record_sha256": "e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a" + "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" } } ] diff --git a/bindings/fixtures/qualification/verification-vectors.json b/bindings/fixtures/qualification/verification-vectors.json index 62d5ad446..fd62da145 100644 --- a/bindings/fixtures/qualification/verification-vectors.json +++ b/bindings/fixtures/qualification/verification-vectors.json @@ -50,12 +50,12 @@ "trust_root": "{\"public_key_b64\":\"0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzc\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-trust-root/1\",\"signature_suite\":\"ed25519-v1\"}", "signer_certificate": "{\"root_signature_b64\":\"obGs_sPHvOXfTu8emdHu3odSbdq3PEW0XwoKhrOSb1LQTgq9LOvFPrRcuhE6Tis01Ac9ndvtGQiey6UWh0MmBg\",\"statement\":{\"issued_at\":1789913600,\"not_after\":1805465600,\"not_before\":1789913600,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}", "revocation_list": "{\"root_signature_b64\":\"nVaEVMHFGD_kiB0SIdz3uK3Xh0YlYrUJY-PRkV7_sCAc6mGs39yQxxGsiShFyuVrE_NxGHNnX40Lg6mi_w_hAw\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}", - "release_index": "{\"signature_b64\":\"qLnnKRCjNPMQ4E4htzwihMF_RcLGUtZ-QpmUc0xvAf9So4UwLqsqnQ8iE7KQDBPiDDEaT2tXMdXo8UJx7BKoCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"F7krnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" ], "attestations": [ - "{\"signature_b64\":\"RNvz-GVoozTJulLOMogzaDjwNMmNJIciII7dGyYiqv7CLXqD7OeqqnmO4COD_-YI7CtUTuT50ARNLDOYx6HOAw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], "deployment": { "recipe_family": "example-refund-v1", @@ -70,7 +70,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -91,14 +91,14 @@ "class": "valid", "replace": { "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}", - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"aarch64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}", + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"aarch64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" ], "attestations": [ - "{\"signature_b64\":\"RNvz-GVoozTJulLOMogzaDjwNMmNJIciII7dGyYiqv7CLXqD7OeqqnmO4COD_-YI7CtUTuT50ARNLDOYx6HOAw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", - "{\"signature_b64\":\"1Hd7wDEt6bzoXwrcguCBXtcDy32fmhJRgKZVIG5iyFw-vVzLFAE06rP-p786NrT5nTepTF9DXwURduAeTvHSBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"f4eee7e4a2af6f48d64102f768a9e056cf340d9be38cafde6808d8455785b7b7\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "{\"signature_b64\":\"_E6upIbPHumyWVjZBeAs3wF_pwjiokZy0gMFD8PkPzJypu_4mbEdMlBlO2fhQ5vpOEh_JrgBQUKmSWrERb08Aw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"154c748f1fda0e7d97cc79bb64ce126daa879c33993b0afa67f88af382682e3b\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"rrIlocaWjnu0yGZqBctFItRCwBdsQACIBWypqxI4-DaRasCgyU0x354oFpqZT0HTcDQyh1cds1BrtMoslrhnDg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"},{\"attestation_sha256\":\"07660bc891d054fb560be8027aa9d74f489f74a347ede9818f826df7d42711a2\",\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"f4eee7e4a2af6f48d64102f768a9e056cf340d9be38cafde6808d8455785b7b7\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"PpwJSY7n732459aPXuQE0nhAEoE831x4ObEy3UJYc91PISSJkno4S2dK9Sc2mSKnAj_ZIcqDMV48pwAa0hFUDQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"},{\"attestation_sha256\":\"0347ca6cfd561c9e1cf190937b658e3db4391e4dec0594362b5665e0d3c48415\",\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"154c748f1fda0e7d97cc79bb64ce126daa879c33993b0afa67f88af382682e3b\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "deployment": { "recipe_family": "example-refund-v1", "compiled_recipe_sha256": "262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef", @@ -112,7 +112,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -154,9 +154,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"Rdvz-GVoozTJulLOMogzaDjwNMmNJIciII7dGyYiqv7CLXqD7OeqqnmO4COD_-YI7CtUTuT50ARNLDOYx6HOAw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"W5EYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"CA6xsrEbfeBdNhtmWqR01vTD8Rh4tqH9xiKORfNaFa-URL_hS5mF3RqUA-6imag1YMvDcUEU2QLfqsmmu3dpBg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"53e358591892ff3a4733a7c685b5fcc5f36df1073c9813059f217ff28191fe18\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"gstQKaN_329H-IM1AIC81bbINma6jddesBZu3KBjyOmIZuGj9fHYl9ngobgj1YUYLPJMK2x6arDLnTRH8VhUCA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"f58b5ce0a7a3c471535e557d7d6bd5cc4adf97dc307dc4a0ed7f9a181f50dac4\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -169,7 +169,7 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"Byp9otAfoNdjUbZD0Fa0L3phBk8rgRCuRd4OwQdt0ja_anYDYlGYW9tBXAXCv6IX5uRWK_m5qh4RbJKQeHDaDA\",\"statement\":{\"issued_at\":1789992801,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"lgFGj1nFFiSRkZu2Jq5bHK9WVYsO-GZ4ba2IVU0R02XE9qn3LkAOKLFOeH9Ra41I7myx082uZ239YxauJFQVBw\",\"statement\":{\"issued_at\":1789992801,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ] }, "expect": { @@ -183,9 +183,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"xrJ1DFsrecZJ1w6RIfbOj1yQ9l-ZcrDRqHPZYP_Cqo1kj9G1Rc2FTRB6O05b_znhal3O9knMDlDpey-_hC4vBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"_5fxI4CUWG1x39gELCP_b6Tgh0TH_Slt2K9dd6PdCt8Hp7rMB9GLSmqIBCbVYxrZP2wE5RbXaIrZPmzmrt0OAg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8a24fea63afbe047524b68b394f957b8530a6fbbc78ad4defec2d39dd2a4de80\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -197,7 +197,7 @@ "id": "index-signature-forged", "class": "forged", "replace": { - "release_index": "{\"signature_b64\":\"qbnnKRCjNPMQ4E4htzwihMF_RcLGUtZ-QpmUc0xvAf9So4UwLqsqnQ8iE7KQDBPiDDEaT2tXMdXo8UJx7BKoCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"FrkrnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "unqualified", @@ -209,7 +209,7 @@ "id": "index-signed-by-outsider", "class": "forged", "replace": { - "release_index": "{\"signature_b64\":\"1keFTCfs9mQxuQntTNOv_W9vqciC-oCRxxlVQrP2XpM23XoFBpxPEVPX25YGxZxGfByqeTTjvrzqEt8x5M0HCQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"pXqrlE-c_QkMVuKxDEFkaZ5xPkXCgNH2GCN5afzIeejtOcBP4vMNdyBwdMLsr3zUV1QnSJvsrrSeH_Lk3WxABA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "unqualified", @@ -294,9 +294,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"In_Pz4oSQhgTnbrScTBPACd3JNgcw7VDY4468cZMWvsjA-pzYcdCC_SGJHjaHn_LZ4FjVxd4Vv_8EOL41c4hDw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"another-signer\"}}" + "{\"signature_b64\":\"Rv7jMneOVEPB2DC5PsuJh9-UAID4nFlI1Y3S705lWuOVdHPG8ZKyvbcAobd-e53HWRvrQroy4eYYYvT7yr_SAg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"another-signer\"}}" ], - "release_index": "{\"signature_b64\":\"PU3HBBhvW9glWplV0oZMyXhF56jPQagnXK9dXP_9IPNHLkNerKW02skNwEVq-YYiq5XZJb8wqsRYw5d32EBmCg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"b845e328d0333fefb98b407f35e2e7e0f23ad4cdcd2855f60ba858dc16c93b13\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"ksefSEsRRKU8M6176xy8cZm6gtLbTD0ShjT-wG_Tegm0PTxkcRG02YmW6wlbjSNf98BuLnQoCv9K22gmKodoDg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"7080a1a1cff7aa99fb84757ce9083e66f6e5947220e1890ded8c43a06b87da14\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -311,7 +311,7 @@ "attestations": [ "{\"signature_b64\":\"dU8UPdRvQ6Xr6xCtRvpnj5HT5oD_oPcTI1sc3fnHTzNL-eenyjjdJOq0-0wBZicAH4uVvsJV2LmcnPmcRaXXBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"1bc3a22a5bba0537b35bcb4db6ec7a29fafb9deae8f5f964919628c38654c42d\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"C_W4OzY5dDjLR_EZAJYZqTKSJVJgs233eInKoc-aMIEPgO202P8lpu5echZJ7Yboh-_xZOegNojFccXqf2d-AQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"b349ee3d88adb475afa1ffabc89b76c010c1d890cc3ccf8ebe282f0e7cdece3f\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"SvgpIJYiHz8-HdRFw4Cy0ETIbiQt4R_T4Orc_BYB_D0qnvMMn4WnmVqHc30HfalrVaHuUlEdUC4VvHwI6zBbAA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"b349ee3d88adb475afa1ffabc89b76c010c1d890cc3ccf8ebe282f0e7cdece3f\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -324,12 +324,12 @@ "class": "widened-time-bound", "replace": { "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1795176800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/6\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1795176800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" ], "attestations": [ - "{\"signature_b64\":\"llV5lBszVwmOYM3A6diwpACMWJ5B9H9sFvFfnthdn43G-Vv3jlMPEW1L6opboExmUFvpLvVrX85k5sh-y7mWDw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"10cc5b9573f799fbe2edb24ca401950b782e399001276c2a6b010040154499dc\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"AwFLFc3BWQwkgabGaOOZ_Pl1I7kK2Vt0Fir3ngrKO-j3N_UnX61XoP7lxm26zdHuZVyUdH-CwTkQcFST2TZjBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"8c6d91168743e4833127e8121752d634bc99a5b50917c4fd91e14a751e2b1ab0\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"02dWO040SWUrdjFYAEGatWBeF4ISg4xINKvFWUG-q1lY2nN-pHRhyC4-qEib7YaWeSLuvfOFFr5CXuiyCkg8DQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"10dfac2b1176c1a877f5f2cba5ced11a6f2e38f1d634c3d7f764e1651997d568\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"10cc5b9573f799fbe2edb24ca401950b782e399001276c2a6b010040154499dc\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"AkvZARmRLyWHdBZDfe9h4C_RM6zKMy6Y_7ZAylwtfN7-WR6iNn_nwRmx4hn1AL8hJPueq1uLmCsFxjkgVcS6CQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"dccc035572444236f079312739837944911c39180153f2bbae76c009c4423e0e\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"8c6d91168743e4833127e8121752d634bc99a5b50917c4fd91e14a751e2b1ab0\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -342,9 +342,9 @@ "class": "not-yet-valid", "replace": { "attestations": [ - "{\"signature_b64\":\"xhMqiwUs1yCbR0ebhIO4hWPvROOx8HJVvQiAco5fKOF54wRuuJGH6hGsiNdbNPB4PdzsVE4CP8Ufv57b5fl8AQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1792595600,\"not_before\":1790003600,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"kdf21QMMuwNrnjH5blOc06QCr2mywsSLpic0dOcTbvOM0FBFG4L8wy55-VjRTJceoY36e1vXY-Meu-g-40SgBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1792595600,\"not_before\":1790003600,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"Ue5Ra0u17IlVF3otp4TbGtiJgnHSeHUx-RMC-EtR__PKqKA0Gtli-OFtmufJCwiPlK2MNgUGU1gh2KbbTLthBg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0ec2dfd894f7b1809e61d1e9c86a67ad61e83cea5bc7924d12d1dcfc7693f15b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"FuutnsAO-NZvt8t4WXhw7E1U5QR-Ipp2QhxmIx64hcKBT5JEEugRnhCmuYMstSJeXKqD1chrsqImeSxx16hwCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"57fa5d84840f2c5e1b2de90041e2af75b10e234d2862d8802ee9cac9f680eb62\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -368,7 +368,7 @@ "id": "unusable-index-before-revocation", "class": "precedence", "replace": { - "release_index": "{\"signature_b64\":\"qbnnKRCjNPMQ4E4htzwihMF_RcLGUtZ-QpmUc0xvAf9So4UwLqsqnQ8iE7KQDBPiDDEaT2tXMdXo8UJx7BKoCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"FrkrnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "revocation_list": "{\"root_signature_b64\":\"Oe8aY9Lt91XEvAJ86JGwNpAUwVl5WGvXfP3xvBIraeDWf8B0m0OPMVVmAp5WqglK8RDodbQ9g8CfDgAJI3coBg\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[\"qlf_01010101010101010101010101010101\"],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}" }, "expect": { @@ -426,9 +426,9 @@ "class": "precedence", "replace": { "attestations": [ - "{\"signature_b64\":\"xrJ1DFsrecZJ1w6RIfbOj1yQ9l-ZcrDRqHPZYP_Cqo1kj9G1Rc2FTRB6O05b_znhal3O9knMDlDpey-_hC4vBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"_5fxI4CUWG1x39gELCP_b6Tgh0TH_Slt2K9dd6PdCt8Hp7rMB9GLSmqIBCbVYxrZP2wE5RbXaIrZPmzmrt0OAg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8a24fea63afbe047524b68b394f957b8530a6fbbc78ad4defec2d39dd2a4de80\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "now": 1790255601 }, "expect": { @@ -442,9 +442,9 @@ "class": "precedence", "replace": { "attestations": [ - "{\"signature_b64\":\"xrJ1DFsrecZJ1w6RIfbOj1yQ9l-ZcrDRqHPZYP_Cqo1kj9G1Rc2FTRB6O05b_znhal3O9knMDlDpey-_hC4vBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"_5fxI4CUWG1x39gELCP_b6Tgh0TH_Slt2K9dd6PdCt8Hp7rMB9GLSmqIBCbVYxrZP2wE5RbXaIrZPmzmrt0OAg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8a24fea63afbe047524b68b394f957b8530a6fbbc78ad4defec2d39dd2a4de80\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "signer_certificate": "{\"root_signature_b64\":\"AzUQnJwFYUZzLtBZTs8b0R2kt6nvkhJoBbMttBXnyAP7dSk7rVfe7sZQxD4Laerbyc7jgH4yzz1dUWdEOfscDA\",\"statement\":{\"issued_at\":1787408000,\"not_after\":1789999999,\"not_before\":1787408000,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}" }, "expect": { @@ -472,7 +472,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -548,7 +548,7 @@ "id": "index-issued-ahead", "class": "future-issued-at", "replace": { - "release_index": "{\"signature_b64\":\"5taLptZFLigql-wheq4jrzJOZz6psUgXhzyzXzAgIuvuHx7bSgLdWS3PCFCMgooFSKE4-Z-IFgUbVISrNZngCA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"00449fd858186bb6711b8697f6ea376b5c6a99ef79e0443c6ccc23a1a36e8c82\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1790000060,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"1uq26boBL0UHQZSn9lBnT3R61ZIfpbQ2RQ-nrtC5HM0PBbIkKbrkIcZzDll6OTRI9vjfV_apf8PoWD7hOCW0Ag\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1790000060,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "stale", @@ -561,9 +561,9 @@ "class": "future-issued-at", "replace": { "attestations": [ - "{\"signature_b64\":\"1OYEnrP0APZgNIc9VFzQmKyYK-ltQO7ZjTduSVOzkNeQ0S8e2Ek4xFw2O3CyVfsajqVeHgDUPmDFsvWDBg-5Bw\",\"statement\":{\"issued_at\":1790000060,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"K_tNB3s_ibY38Q26cK8RIoG7SrYv58vSesGEZfDntKb7YvO7CI9M7QT5RJnQDbZ8cFsw4D9V5ohkxhCQsKJLDA\",\"statement\":{\"issued_at\":1790000060,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"QMiLn3BFlwLUUJctksJ9mbmwNJ8IEF5A1D-yy13oE2yuxvABWwZT-4Vw_N4onw1SrMY86a650H6xCqSUy9QNBQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9d6bfaadd23e3be7ce7320fa6ad7779384a3187c7713856b5b12aa5728e86c32\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"e5495a2c95356229a778d6781860eed872090ac5f4b6ac447953d353a3592f7a\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"JV3P-5Gtwgl_ldQ4NZ_VpNIh2U38g4zLpuc2GcA42pbFiE7-Fwo2sNzRzOLX9ljtPoQZCz7pAiL0cQfSU1mdBg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"495d11bbb7b5ee3bc7d795db990df7828ec06dfb337031dd66e68232fbd42bb3\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "stale", @@ -637,7 +637,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } }, @@ -740,7 +740,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -768,7 +768,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -796,7 +796,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -824,7 +824,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -852,7 +852,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -880,7 +880,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -908,7 +908,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -936,7 +936,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -964,7 +964,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "245f158f0e08031548685ae415e98194feb1831db12f4563ecd7ab15b2630651", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -992,7 +992,7 @@ "gateway_version": "1.0.0-rc.2", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -1020,7 +1020,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "shared-file-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -1076,7 +1076,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/6", + "store_schema": "auths.lifecycle.postgresql/7", "credential_store_kind": "local-file-v1" } } diff --git a/compliance.toml b/compliance.toml index 8a29dbeef..7cf30d220 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,17 +1600,22 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.bound-effect/1", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/4", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/6", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/4", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] -configuration_inputs = ["commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] +security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +effect-configuration = [ + "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", + "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", + "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", +] operational-diagnostics = [ "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_requires_a_recent_nonfuture_sample", "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_refuses_links_and_untrusted_write_permissions", @@ -1936,7 +1941,7 @@ kind = "cargo" layer = "product" path = "product/stores/auths-stores" core_apis = ["auths-model"] -protocol_versions = ["auths-proof/v1", "auths.lifecycle.postgresql/6"] +protocol_versions = ["auths-proof/v1", "auths.lifecycle.postgresql/7"] wire_objects = ["AttestedDecisionReceipt", "AttestedExecutionReceipt", "LifecycleRecordV1", "GatewayRecordEntry"] fixture_suites = ["product/fixtures/v1/lifecycle"] principal_families = [] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 674245790..bd2d386c5 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -177,3 +177,40 @@ manifest comparison and process-local revocation caches are insufficient. The primitive described here is only preparation: until the shared record, writer participation and grant reducer are connected, the current engine does not claim this final-entry guarantee. + +## Shared installed configuration and permanent qualification memory + +The sixth closed gateway record kind, `effect-configuration`, is non-expiring. +Its key commits to namespace, partition and epoch independently of the candidate +configuration. The installed pin commits to recipe, native verifier trust, +operator effect policy, connection identity, workload, profile, qualification +contract and gateway semantic closure. Bound-effect `/2` includes that pin; +compiler identity `/2` rejects approvals over the earlier binding format. +PostgreSQL schema `/7` directly replaces `/6`; no old-schema reader is retained. + +Only trusted install/join initializes a missing record. Joining an existing +record must match its pin. Changing the pin requires explicit operator review +of both the candidate and a commitment to the entire previous record, followed +by activation under the writer fence. A concurrent publication invalidates that +review token. Application frames expose neither initialization nor activation. + +Qualification import/reload publishes the authenticated bundle identity and +permanent revocation memory through that same fence before reporting success. +Accepted sequence/issue-time floors take maxima; signer and qualification +revocations take unions. The record bounds these sets to the native release +limits (64 signers and 1024 qualifications). Saturation persists a terminal +blocked marker; neither an empty local cache nor configuration activation can +reset it. Each record is canonical and bounded to 128 KiB. Revision saturation +also blocks authorization. This preserves bounded work without forgetting a +revocation and then authorizing from a truncated set. + +A host adopts shared memory and must hold the published bundle identity before +ordinary qualification or separate commissioning-permit verification. Shared +memory itself grants neither. Publishing an unloaded bundle can disable other +hosts until their inputs are synchronized; this is a deliberate fail-closed +availability tradeoff. Earlier local verifier-state files remain rollback +witnesses, not an alternate shared admission authority. + +Compilation and entry preparation now perform early checks. The final grant +must still repeat these checks over the configuration snapshot under its own +attempt fence. No final-entry guarantee is claimed by these early checks. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 4cee3c199..999cd39cf 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -217,13 +217,42 @@ all reservation membership and final native authority under the fence, and issuing/consuming a permit only from a new acknowledged transition. The old Attempting send path is not represented as compliant final entry. +## Shared configuration checkpoint + +- Added the non-expiring shared configuration record and PostgreSQL schema `/7`. + Its installed pin covers recipe, trust, effect policy, connection/workload, + profile, qualification contract and compiled semantic closure. Bound-effect + `/2` and compiler `/2` bind that pin; obsolete binding formats are refused. +- Trusted installation initializes the record. Explicit native operator review + and activation require both candidate identity and the exact prior revision. + Activation and qualification publication share the adapter writer fence. +- Shared qualification memory monotonically retains sequence/time floors and + revoked signers/qualifications across restarts and configuration changes. + Bounded-set or revision saturation persists denial, never authorization with + forgotten entries. Hosts with a different bundle or installation fail closed. +- Compilation and entry preparation use early shared checks. These are not the + final grant transaction. Reserved/EntryGranted, audit facts, reservation + membership checks and consumed transport permits remain outstanding. +- File/PostgreSQL source conformance covers missing state, stale hosts, competing + revision tokens, restart, permanent revocation and saturation. These behavioral + tests are authored, not executed. Qualification test callers now publish + operator reloads explicitly instead of mutating only their process cache. +- Required artifact generation passed on `4e0f435d` plus this configuration + source: `configuration::tests::native_configuration_fixture_is_current`, + `vectors::schemas::schema_vectors_are_current` and + `vectors::verification::verification_vectors_are_current` (one test each). + The native CLI regenerated `effect-approval.json` byte-identically to the + binding corpus and compiled the updated binary. Final source-closure generation + `semantic_closure::tests::semantic_closure_is_current` passed (one test). + These are artifact construction, not adapter race, formal or hosted CI evidence. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | In progress | Finish installed first mutation cutover and native fixtures | -| P2 | Adapter preparation | Shared configuration, reservation/grant reducer and fenced permit wiring | +| P2 | Adapter and shared configuration implemented | Reservation/grant reducer and fenced permit wiring | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 9f4f95108..d27d1048d 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -127,6 +127,7 @@ decision ceilings; tighter installed PostgreSQL deadlines are preserved. The source conformance suite orders replacement, insertion and sweep writers against a held decision and checks failure atomicity. This source has not yet been exercised in hosted CI. The mechanism does not itself interpret effect -identity, grant entry or establish multi-host revocation freshness. Connecting -the shared configuration record and one-use grant owner remains P2 work, as -specified in ADR 0017. +identity, grant entry or establish multi-host revocation freshness. The shared configuration record now participates in the fence, retains bounded +permanent qualification memory and requires explicit operator CAS activation. +Connecting its snapshot to the one-use grant owner remains P2 work, as specified +in ADR 0017. Early host checks are not final-entry evidence. diff --git a/product/qualification/auths-recipe-qualification/src/vectors/mod.rs b/product/qualification/auths-recipe-qualification/src/vectors/mod.rs index 47d3314c2..d37c09620 100644 --- a/product/qualification/auths-recipe-qualification/src/vectors/mod.rs +++ b/product/qualification/auths-recipe-qualification/src/vectors/mod.rs @@ -280,7 +280,7 @@ pub(super) fn target() -> QualificationTarget { gateway_version: bounded("1.0.0-rc.1"), gateway_build_sha256: digest_of("gateway build"), store_kind: LifecycleStoreKind::PostgresqlV1, - store_schema: bounded("auths.lifecycle.postgresql/6"), + store_schema: bounded("auths.lifecycle.postgresql/7"), credential_store_kind: CredentialStoreKind::AwsSecretsManagerV1, } } diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 702e418d2..8ab199d33 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"fa23a962fd90331152eed5edbcdf271955f7aed79b8da1e065bfe69a20b487a9"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"dcd0282db18359bc9ffbb5e61f12c2f61de42e4e79f5ed59f299a8cb022d6a6d"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"1ee30027b3b83a208aa35b1bc01ee2accc1d4f6dc88a758f6b99ee5904d61c59"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2c7bb0181acf6c8706aa1546d51ff58195f39a331eb917d29fe8c98012635c10"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"56a34f797ec7c65c0b0c5d15f415fd4d6aaf14a89a48dc24fd0cc2a43f8adf07"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"298686a44c6c9780eda73d17305def3221ca4d4c19f77d1542ad1603350a378b"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c3eb4f92fcc7b0d453b813c948ed885c006bb2f204d362effdb1dd50b2af29ef"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"6fb307ee3f20236736078f3bcb0e612aed078cf5e45da7e5c453f7f8cc6e06b5"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"f31ed04ac5340590efb00e0962ac580e1a11fda922bebc961d2b3a7c1fe3c96b"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"61e904f5ff9174b6dae75c2cea1896d86f18e5dc8b07db24021f63952420a3a4"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"176764bce092c8d442c30b6c77c3cafa98d089914250d273144410fc3070b0ce"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"63a29c1b74dca778238f69bf6d4e8dc73673cbfe866e5d0d94b020710376e318"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"0418fd85dd7124c1cc1a644e537af889f102992052a36c3374c71457c3414b86"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a7d97bf32205b51eadb52daa9076c6bdbc81e210e34edc8d37128aa00f0a3f3f"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"526273edfcb6bba88896f4e715368024661896eed6f56eb75a0f9f0d946e3eb1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"77dddf1f426441d759deb8844a8a58fc0ddfb915d09e3dbc22a808ec3aa19051"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"21f38bc74329bb6868095e564c844ac24e2e4c51cf656d54cc8efe4c88b2182c"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"455c1a2fe7a9ac2a916f75c95203a3f83f6d39800517dc8aecb85976a0683576"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"07b25d682b7bc1543602e0dea3007d0f1b24d60e11c7f5ebc858170b38f60534"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index b67c6cc4f..85057972c 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -167,6 +167,21 @@ mod unix { #[arg(long)] approver_public_key: String, }, + /// Review the current shared revision and this validated candidate installation. + EffectConfigurationReview { + #[arg(long)] + state_dir: PathBuf, + }, + /// Activate the reviewed candidate using the exact previous revision. + /// This operator-only command preserves permanent revocation memory. + EffectConfigurationActivate { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + expected_revision: String, + #[arg(long)] + expected_candidate: String, + }, /// Private native review of the installed exact effect, with a bounded /// signing request. Does not lease credentials or enter provider transport. EffectReview { @@ -1474,6 +1489,14 @@ mod unix { tokio::task::spawn_blocking(move || floor.initialize(&record)) .await .map_err(|_| "gateway.install.connection-store-unavailable")??; + let initializing = state_dir.clone(); + tokio::task::spawn_blocking(move || -> Result<(), Failure> { + load_engine(&initializing)? + .initialize_effect_configuration() + .map_err(Failure::from) + }) + .await + .map_err(|_| "gateway.configuration.unavailable")??; println!( "{} recipe {} with separate gateway credential custody", if join { "joined" } else { "installed" }, @@ -1792,7 +1815,11 @@ mod unix { let bundle = qualification_bundle(from).map_err(|code| Failure::at(code, from, "unreadable"))?; let candidate = QualificationGate::new( - QualificationPolicy::Required, + qualification_policy( + Some(&manifest.qualification.policy), + production_qualification(manifest.deployment), + ) + .map_err(|_| "gateway.serve.invalid-installation")?, qualification_root(state_dir, &manifest)?, qualification_deployment(state_dir, &manifest), Box::new(DevelopmentClock), @@ -1810,6 +1837,7 @@ mod unix { // What the new inputs establish is recorded before they replace the // old ones. If the replacement then fails, the old inputs meet a // floor they are below and nothing qualifies. + load_engine(state_dir)?.publish_effect_qualification(&candidate)?; write_verifier_state(state_dir, &candidate.verifier_state())?; let staged = state_dir.join(format!("{QUALIFICATION_DIRECTORY}.next")); let retired = state_dir.join(format!("{QUALIFICATION_DIRECTORY}.previous")); @@ -2266,7 +2294,9 @@ mod unix { let reloading = Arc::clone(&engine); let directory = Arc::clone(&state_dir); let reloaded = tokio::task::spawn_blocking(move || { - qualification_reload(&directory, reloading.qualification()) + let local = qualification_reload(&directory, reloading.qualification()); + reloading.publish_effect_qualification(reloading.qualification())?; + local }) .await; match reloaded { @@ -3679,6 +3709,48 @@ mod unix { )] pub async fn run() -> Result<(), Failure> { match Cli::parse().command { + Command::EffectConfigurationReview { state_dir } => { + private_root(&state_dir)?; + tokio::task::spawn_blocking(move || -> Result<(), Failure> { + let engine = load_engine(&state_dir)?; + let review = serde_json::json!({ + "schema": "auths.effect-configuration-review/1", + "previous_revision_hex": hex::encode(engine.effect_configuration_revision()?), + "candidate_hex": hex::encode(engine.effect_configuration_candidate()?), + "installation": installation(&state_dir)?, + }); + let bytes = serde_json_canonicalizer::to_vec(&review).map_err(|_| "gateway.configuration.unavailable")?; + std::io::stdout().write_all(&bytes).map_err(|_| "gateway.configuration.unavailable")?; + Ok(()) + }).await.map_err(|_| "gateway.configuration.unavailable")??; + Ok(()) + } + Command::EffectConfigurationActivate { + state_dir, + expected_revision, + expected_candidate, + } => { + private_root(&state_dir)?; + tokio::task::spawn_blocking(move || -> Result<(), Failure> { + let parse = |text: &str| -> Result<[u8; 32], Failure> { + let mut value = [0; 32]; + hex::decode_to_slice(text, &mut value) + .map_err(|_| "gateway.configuration.invalid-review")?; + Ok(value) + }; + let revision = parse(&expected_revision)?; + let candidate = parse(&expected_candidate)?; + let engine = load_engine(&state_dir)?; + if engine.effect_configuration_candidate()? != candidate { + return Err("gateway.configuration.changed".into()); + } + engine.activate_effect_configuration(revision)?; + Ok(()) + }) + .await + .map_err(|_| "gateway.configuration.unavailable")??; + Ok(()) + } Command::EffectReview { state_dir, proof, diff --git a/product/runtime/auths-gateway/src/commissioning_session/tests.rs b/product/runtime/auths-gateway/src/commissioning_session/tests.rs index 42a8a899d..36b7dd148 100644 --- a/product/runtime/auths-gateway/src/commissioning_session/tests.rs +++ b/product/runtime/auths-gateway/src/commissioning_session/tests.rs @@ -144,6 +144,16 @@ impl Setup { Box::new(clock.clone()), VerifierState::default(), )); + let configuration = engine.shared_configuration().expect("configuration"); + let activation_gate = Arc::clone(&engine.qualification); + tokio::task::spawn_blocking(move || { + let revision = configuration.current_revision().expect("current revision"); + configuration + .activate(revision, &activation_gate) + .expect("operator activation"); + }) + .await + .expect("activation task"); let operator = Signer::new(0x44); let statement = OperatorStatement { schema: crate::OPERATOR_ATTESTATION_SCHEMA.to_owned(), diff --git a/product/runtime/auths-gateway/src/configuration.rs b/product/runtime/auths-gateway/src/configuration.rs new file mode 100644 index 000000000..b28ddf24b --- /dev/null +++ b/product/runtime/auths-gateway/src/configuration.rs @@ -0,0 +1,447 @@ +//! Shared installed configuration and permanent qualification memory. +//! +//! This record participates in the same writer fence as attempts and connection +//! changes. A local manifest or cached qualification bundle cannot replace it. + +use crate::{ + GatewayAttemptError, GatewayAttemptKey, GatewayAttemptStore, GatewayRecordEntry, + GatewayRecordKind, QualificationGate, +}; +use auths_recipe_qualification::{ + MAX_REVOKED_QUALIFICATIONS, MAX_REVOKED_SIGNERS, QualificationId, QualificationSignerId, + VerifierState, +}; +use serde::{Deserialize, Serialize}; +use std::{collections::BTreeSet, sync::Arc}; + +const SCHEMA: &str = "auths.effect-configuration/1"; +const MAX_BYTES: usize = 131_072; +const MAX_INTEGER: u64 = (1 << 53) - 1; +const UNAVAILABLE: &str = "gateway.configuration.unavailable"; +const CHANGED: &str = "gateway.configuration.changed"; + +/// Bounded union of authenticated revocation memories. Saturation is terminal +/// denial, never truncation followed by authorization with forgotten entries. +#[derive(Clone, Default, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct QualificationMemory { + pub(crate) accepted_revocation_sequence: u64, + pub(crate) accepted_index_issued_at: u64, + pub(crate) revoked_signers: BTreeSet, + pub(crate) revoked_qualifications: BTreeSet, + pub(crate) blocked: bool, +} + +impl QualificationMemory { + pub(crate) fn merge(&mut self, state: &VerifierState) { + self.accepted_revocation_sequence = self + .accepted_revocation_sequence + .max(state.accepted_revocation_sequence); + self.accepted_index_issued_at = self + .accepted_index_issued_at + .max(state.accepted_index_issued_at); + if self.accepted_revocation_sequence > MAX_INTEGER + || self.accepted_index_issued_at > MAX_INTEGER + { + self.blocked = true; + self.accepted_revocation_sequence = self.accepted_revocation_sequence.min(MAX_INTEGER); + self.accepted_index_issued_at = self.accepted_index_issued_at.min(MAX_INTEGER); + } + for signer in &state.revoked_signers { + if !self.revoked_signers.contains(signer) + && self.revoked_signers.len() == MAX_REVOKED_SIGNERS + { + self.blocked = true; + break; + } + self.revoked_signers.insert(signer.clone()); + } + for qualification in &state.revoked_qualifications { + if !self.revoked_qualifications.contains(qualification) + && self.revoked_qualifications.len() == MAX_REVOKED_QUALIFICATIONS + { + self.blocked = true; + break; + } + self.revoked_qualifications.insert(qualification.clone()); + } + } + + pub(crate) fn state(&self) -> VerifierState { + VerifierState { + accepted_revocation_sequence: self.accepted_revocation_sequence, + accepted_index_issued_at: self.accepted_index_issued_at, + revoked_signers: self.revoked_signers.clone(), + revoked_qualifications: self.revoked_qualifications.clone(), + } + } + + fn valid(&self) -> bool { + self.accepted_revocation_sequence <= MAX_INTEGER + && self.accepted_index_issued_at <= MAX_INTEGER + && self.revoked_signers.len() <= MAX_REVOKED_SIGNERS + && self.revoked_qualifications.len() <= MAX_REVOKED_QUALIFICATIONS + } +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct QualificationSnapshot { + pub(crate) bundle: Option<[u8; 32]>, + pub(crate) memory: QualificationMemory, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Record { + schema: String, + installation: [u8; 32], + revision: u64, + qualification: QualificationSnapshot, +} + +fn encode(record: &Record) -> Result, &'static str> { + let bytes = serde_json_canonicalizer::to_vec(record).map_err(|_| UNAVAILABLE)?; + if bytes.len() > MAX_BYTES { + return Err(UNAVAILABLE); + } + Ok(bytes) +} + +fn decode_record(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_BYTES { + return Err(UNAVAILABLE); + } + let record: Record = serde_json::from_slice(bytes).map_err(|_| UNAVAILABLE)?; + if record.schema != SCHEMA + || !(1..=MAX_INTEGER).contains(&record.revision) + || !record.qualification.memory.valid() + || encode(&record)? != bytes + { + return Err(UNAVAILABLE); + } + Ok(record) +} + +fn decode(bytes: &[u8], installation: &[u8; 32]) -> Result { + let record = decode_record(bytes)?; + if &record.installation != installation { + return Err(CHANGED); + } + Ok(record) +} + +pub(crate) fn digest(domain: &str, value: &T) -> Result<[u8; 32], &'static str> { + let bytes = serde_json_canonicalizer::to_vec(value).map_err(|_| UNAVAILABLE)?; + if bytes.len() > MAX_BYTES { + return Err(UNAVAILABLE); + } + auths_codec::domain_commitment(domain, &bytes) + .map(|digest| *digest.as_bytes()) + .map_err(|_| UNAVAILABLE) +} + +/// Trusted installation owner; not exposed on the application channel. +#[derive(Clone)] +pub(crate) struct SharedConfiguration { + store: Arc, + key: GatewayAttemptKey, + installation: [u8; 32], +} + +impl SharedConfiguration { + pub(crate) fn new( + store: Arc, + key: [u8; 32], + installation: [u8; 32], + ) -> Self { + Self { + store, + key: GatewayAttemptKey::from_bytes(key), + installation, + } + } + + pub(crate) fn candidate(&self) -> [u8; 32] { + self.installation + } + + /// Only the trusted install/join command may create a missing record. + pub(crate) fn initialize(&self, gate: &QualificationGate) -> Result<(), &'static str> { + let record = Record { + schema: SCHEMA.to_owned(), + installation: self.installation, + revision: 1, + qualification: gate.shared_snapshot(&QualificationMemory::default()), + }; + match self.store.insert(&GatewayRecordEntry { + kind: GatewayRecordKind::EffectConfiguration, + key: self.key, + record: encode(&record)?, + expires_at: None, + }) { + Ok(()) => Ok(()), + Err(GatewayAttemptError::Replay) => self.publish(gate), + Err(_) => Err(UNAVAILABLE), + } + } + + /// Publishes already authenticated local inputs under the shared fence. + /// It merges permanent memory even when the candidate no longer qualifies. + /// Invalid/unloaded candidates disable entry; they cannot erase revocation. + pub(crate) fn publish(&self, gate: &QualificationGate) -> Result<(), &'static str> { + let mut refusal = UNAVAILABLE; + self.store + .fenced_replace( + &[(GatewayRecordKind::EffectConfiguration, self.key)], + &mut |snapshots| { + let current = snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?; + let mut record = decode(current, &self.installation).map_err(|code| { + refusal = code; + GatewayAttemptError::Corrupt + })?; + let mut next = gate.shared_snapshot(&record.qualification.memory); + if next == record.qualification { + return Ok(current.to_vec()); + } + if record.revision == MAX_INTEGER { + next.memory.blocked = true; + } else { + record.revision += 1; + } + record.qualification = next; + encode(&record).map_err(|_| GatewayAttemptError::Corrupt) + }, + ) + .map_err(|_| refusal) + } + + /// Private operator review token over the current record, including its + /// revision and remembered revocations. This token grants no authority. + pub(crate) fn current_revision(&self) -> Result<[u8; 32], &'static str> { + let bytes = self + .store + .load(GatewayRecordKind::EffectConfiguration, &self.key) + .map_err(|_| UNAVAILABLE)? + .ok_or(UNAVAILABLE)?; + let record = decode_record(&bytes)?; + digest("auths.effect-configuration-revision/1", &record) + } + + /// Explicit trusted operator activation. A stale review token loses the + /// CAS; replacing configuration never resets permanent revocation memory. + pub(crate) fn activate( + &self, + expected: [u8; 32], + gate: &QualificationGate, + ) -> Result<(), &'static str> { + self.store + .fenced_replace( + &[(GatewayRecordKind::EffectConfiguration, self.key)], + &mut |snapshots| { + let mut record = decode_record( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if digest("auths.effect-configuration-revision/1", &record) + .map_err(|_| GatewayAttemptError::Corrupt)? + != expected + { + return Err(GatewayAttemptError::Conflict); + } + // A saturated record cannot be reactivated by a new configuration. + if record.revision == MAX_INTEGER || record.qualification.memory.blocked { + return Err(GatewayAttemptError::InvalidTransition); + } + record.installation = self.installation; + record.revision += 1; + record.qualification = gate.shared_snapshot(&record.qualification.memory); + encode(&record).map_err(|_| GatewayAttemptError::Corrupt) + }, + ) + .map_err(|_| CHANGED) + } + + /// Validates an already fenced snapshot; performs no nested store read. + pub(crate) fn check_snapshot( + &self, + bytes: &[u8], + gate: &QualificationGate, + ) -> Result<(), &'static str> { + let record = decode(bytes, &self.installation)?; + gate.accept_shared(&record.qualification) + } + + /// Early availability check. Final entry must repeat this against the + /// snapshot acquired inside its own attempt transaction. + pub(crate) fn check(&self, gate: &QualificationGate) -> Result<(), &'static str> { + let bytes = self + .store + .load(GatewayRecordKind::EffectConfiguration, &self.key) + .map_err(|_| UNAVAILABLE)? + .ok_or(UNAVAILABLE)?; + self.check_snapshot(&bytes, gate) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; + + fn gate(state: VerifierState) -> QualificationGate { + QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(crate::DevelopmentClock), + state, + ) + } + + #[test] + fn native_configuration_fixture_is_current() { + let policy = crate::effect::fixture_policy().expect("policy"); + let namespace = + crate::OperatorNamespace::parse("synthetic-configuration").expect("namespace"); + let key = policy.configuration_key(&namespace).expect("key"); + let record = Record { + schema: SCHEMA.to_owned(), + installation: [11; 32], + revision: 1, + qualification: gate(VerifierState::default()) + .shared_snapshot(&QualificationMemory::default()), + }; + let canonical = encode(&record).expect("record"); + assert_eq!(decode(&canonical, &[11; 32]).expect("decode").revision, 1); + assert!(decode(&canonical, &[12; 32]).is_err()); + let mut padded = canonical.clone(); + padded.push(b' '); + assert!(decode(&padded, &[11; 32]).is_err()); + let fixture = serde_json::to_vec_pretty(&serde_json::json!({ + "schema": "auths.effect-configuration-fixture/1", + "scope": "native configuration encoding and revision identity; no entry claim", + "key_hex": hex::encode(key), + "record_canonical": String::from_utf8(canonical).expect("UTF-8"), + "revision_token_hex": hex::encode(digest("auths.effect-configuration-revision/1", &record).expect("revision")), + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/effect-configuration.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write native fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); + } + + async fn shared_configuration_conformance(backend: Backend) { + let store = TestAttempts::open(backend); + let (first, second) = (store.raw(), store.raw()); + tokio::task::spawn_blocking(move || { + let key = crate::effect::fixture_policy() + .expect("policy") + .configuration_key( + &crate::OperatorNamespace::parse("shared-config").expect("namespace"), + ) + .expect("key"); + let original = SharedConfiguration::new(first, key, [11; 32]); + let candidate = SharedConfiguration::new(second, key, [12; 32]); + let old_gate = gate(VerifierState::default()); + assert!( + original.check(&old_gate).is_err(), + "application cannot initialize missing state" + ); + original.initialize(&old_gate).expect("operator install"); + let stale = original.current_revision().expect("revision"); + let signer = QualificationSignerId::parse("synthetic-revoked-signer").expect("signer"); + let revoked = VerifierState { + accepted_revocation_sequence: 3, + accepted_index_issued_at: 4, + revoked_signers: BTreeSet::from([signer.clone()]), + ..VerifierState::default() + }; + original + .publish(&gate(revoked)) + .expect("publish shared memory"); + original.check(&old_gate).expect("adopt shared memory"); + assert!(old_gate.verifier_state().revoked_signers.contains(&signer)); + assert!( + candidate.initialize(&old_gate).is_err(), + "joining cannot overwrite a different configuration" + ); + assert!( + candidate.activate(stale, &old_gate).is_err(), + "stale operator review loses CAS" + ); + candidate + .activate( + original.current_revision().expect("fresh revision"), + &old_gate, + ) + .expect("operator activation"); + assert_eq!(original.check(&old_gate), Err(CHANGED)); + assert_eq!(original.publish(&old_gate), Err(CHANGED)); + let restarted = gate(VerifierState::default()); + candidate.check(&restarted).expect("restarted host"); + assert!(restarted.verifier_state().revoked_signers.contains(&signer)); + assert_eq!(restarted.verifier_state().accepted_revocation_sequence, 3); + candidate + .publish(&gate(VerifierState::default())) + .expect("older empty local memory"); + let retained = gate(VerifierState::default()); + candidate.check(&retained).expect("retained shared memory"); + assert!(retained.verifier_state().revoked_signers.contains(&signer)); + let mut saturated = VerifierState::default(); + saturated.revoked_signers = (0..=MAX_REVOKED_SIGNERS) + .map(|n| { + QualificationSignerId::parse(format!("synthetic-signer-{n}")).expect("signer") + }) + .collect(); + candidate + .publish(&gate(saturated)) + .expect("durable saturated denial"); + assert!(candidate.check(&retained).is_err()); + candidate + .publish(&gate(VerifierState::default())) + .expect("still saturated"); + assert!( + candidate.check(&retained).is_err(), + "publishing cannot forget saturation" + ); + assert!( + candidate + .activate(candidate.current_revision().expect("revision"), &retained) + .is_err(), + "activation cannot reset permanent memory" + ); + assert_eq!( + candidate + .store + .sweep_expired(u64::MAX / 2, 64) + .expect("sweep"), + 0 + ); + assert!( + candidate.current_revision().is_ok(), + "configuration never expires" + ); + }) + .await + .expect("shared configuration conformance"); + } + + #[tokio::test] + async fn file_configuration_changes_fence_stale_hosts_and_retain_revocations() { + shared_configuration_conformance(Backend::File).await; + } + + #[tokio::test] + #[ignore = "requires the TLS PostgreSQL fixture"] + async fn postgres_configuration_changes_fence_stale_hosts_and_retain_revocations() { + assert!(postgres_configured()); + shared_configuration_conformance(Backend::Postgres).await; + } +} diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index aba830caa..68ce202c9 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -19,12 +19,12 @@ use std::fmt; use zeroize::Zeroizing; /// Only accepted effect binding schema. Old disposable state is rejected. -pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/1"; +pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/2"; /// Maximum private canonical binding or compiler projection bytes. pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/1"; +const COMPILER: &str = "auths.gateway-effect-compiler/2"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -72,6 +72,17 @@ impl EffectPolicy { ) } + pub(crate) fn configuration_key( + &self, + namespace: &OperatorNamespace, + ) -> Result<[u8; 32], EffectBindingError> { + self.validate()?; + commitment( + "auths.effect-configuration-key/1", + &canonical(&(namespace.as_str(), &self.partition, self.epoch))?, + ) + } + pub(crate) fn contains(&self, binding: &EffectBinding) -> bool { self.partition == binding.wire.partition && self.epoch == binding.wire.epoch } @@ -143,6 +154,7 @@ impl EffectPolicy { context: &'a TrustedContext, connection: &'a ConnectionRecord, qualification: QualificationPolicy, + configuration: [u8; 32], ) -> EffectInstallation<'a> { EffectInstallation { recipe, @@ -151,6 +163,7 @@ impl EffectPolicy { partition: &self.partition, epoch: self.epoch, qualification, + configuration, approver: self.approver, } } @@ -257,6 +270,7 @@ pub(crate) fn store_binding_fixture( connection: [0; 32], credential_generation: 1, qualification_policy: "optional".to_owned(), + configuration: [0; 32], approval_policy: ApprovalPolicy::Exact { approver: policy.approver, }, @@ -389,6 +403,7 @@ struct BindingWire { connection: [u8; 32], credential_generation: u64, qualification_policy: String, + configuration: [u8; 32], approval_policy: ApprovalPolicy, reservations: Vec, protocol: Protocol, @@ -951,6 +966,8 @@ pub struct EffectInstallation<'a> { pub epoch: u64, /// Installed recipe qualification requirement. pub qualification: QualificationPolicy, + /// Exact native commitment to the operator's shared installed configuration. + pub configuration: [u8; 32], /// Exact human approver key pinned independently by installation policy. pub approver: [u8; 32], } @@ -1025,6 +1042,7 @@ fn bind_mutation( connection: commitment("auths.effect-installation/1", &connection)?, credential_generation: installed.connection.credential_generation().get(), qualification_policy: installed.qualification.as_str().to_owned(), + configuration: installed.configuration, approval_policy: ApprovalPolicy::Exact { approver: installed.approver, }, @@ -1194,6 +1212,7 @@ mod tests { connection: [4; 32], credential_generation: 1, qualification_policy: "required".to_owned(), + configuration: [12; 32], approval_policy: ApprovalPolicy::Exact { approver: SigningKey::from_bytes(&[19; 32]).verifying_key().to_bytes(), }, @@ -1259,7 +1278,7 @@ mod tests { #[test] fn every_binding_dimension_changes_identity_without_evading_replay_key() { let original = EffectBinding::new(wire()).expect("binding"); - for dimension in 0..13 { + for dimension in 0..14 { let mut changed = wire(); match dimension { 0 => changed.action[0] ^= 1, @@ -1278,6 +1297,7 @@ mod tests { 9 => changed.reservations[0].window_index += 1, 10 => changed.reservations[0].window_seconds += 1, 11 => changed.protocol = Protocol::Mutation { request: [8; 32] }, + 12 => changed.configuration[0] ^= 1, _ => { changed.approval_policy = ApprovalPolicy::Exact { approver: SigningKey::from_bytes(&[20; 32]).verifying_key().to_bytes(), diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index bafa270aa..74a9d8a39 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -73,6 +73,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { &context, &connection, crate::QualificationPolicy::Optional, + [12; 32], ); let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) .expect("native effect"); diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index aee1f86da..9589cf5a1 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -444,6 +444,101 @@ impl GatewayEngine { }) } + pub(crate) fn shared_configuration( + &self, + ) -> Result { + let trust = auths_codec::encode_verifier_context(&self.trusted_context) + .map_err(|_| "gateway.configuration.unavailable")?; + let trust = auths_codec::domain_commitment("auths.gateway-installed-trust/1", &trust) + .map_err(|_| "gateway.configuration.unavailable")?; + let pin = crate::configuration::digest( + "auths.effect-installed-configuration/1", + &( + self.recipe.digest(), + trust.as_bytes(), + &self.effect_policy, + self.connection.provider().as_str(), + self.connection.alias().as_str(), + &self.workload_id, + self.profile.id().as_str(), + self.profile.version(), + self.qualification.contract_digest()?, + crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, + ), + )?; + let key = self + .effect_policy + .configuration_key(self.recipe.namespace()) + .map_err(|_| "gateway.configuration.unavailable")?; + Ok(crate::configuration::SharedConfiguration::new( + self.attempts.store(), + key, + pin, + )) + } + + /// Pins operator-validated installation inputs in the shared attempt store. + /// Only trusted install/join callers may initialize a missing record. This + /// blocks on the store and must run off the async executor. + /// + /// # Errors + /// Refuses unavailable storage or a different already-installed policy. + pub fn initialize_effect_configuration(&self) -> Result<(), &'static str> { + self.shared_configuration()?.initialize(&self.qualification) + } + + /// Returns the private native commitment to this candidate installation. + /// This is review data, never permission to replace shared configuration. + /// + /// # Errors + /// Refuses an invalid configuration encoding. + pub fn effect_configuration_candidate(&self) -> Result<[u8; 32], &'static str> { + Ok(self.shared_configuration()?.candidate()) + } + + /// Returns a private CAS token for explicit operator configuration review. + /// It grants no application or entry authority. This call blocks on storage. + /// + /// # Errors + /// Refuses missing or malformed shared configuration. + pub fn effect_configuration_revision(&self) -> Result<[u8; 32], &'static str> { + self.shared_configuration()?.current_revision() + } + + /// Activates this independently validated installation after an operator + /// reviews the exact previous revision. Retains permanent revocation memory. + /// This trusted operator API blocks on storage and is absent from app frames. + /// + /// # Errors + /// Refuses a stale review token, corrupt state or persistence failure. + pub fn activate_effect_configuration(&self, expected: [u8; 32]) -> Result<(), &'static str> { + self.shared_configuration()? + .activate(expected, &self.qualification) + } + + /// Publishes authenticated qualification changes before reporting an + /// operator import/reload successful. This blocks on the shared store. + /// + /// # Errors + /// Refuses a different trust/deployment contract or unavailable persistence. + pub fn publish_effect_qualification( + &self, + gate: &crate::QualificationGate, + ) -> Result<(), &'static str> { + if gate.contract_digest()? != self.qualification.contract_digest()? { + return Err("gateway.configuration.changed"); + } + self.shared_configuration()?.publish(gate) + } + + async fn check_effect_configuration(&self) -> Result<(), &'static str> { + let configuration = self.shared_configuration()?; + let gate = Arc::clone(&self.qualification); + tokio::task::spawn_blocking(move || configuration.check(&gate)) + .await + .map_err(|_| "gateway.configuration.unavailable")? + } + /// Development builds only: sends provider requests to a plain-HTTP /// provider double on `127.0.0.1:port` instead of the approved origin. #[cfg(feature = "loopback-provider")] @@ -1174,6 +1269,9 @@ impl GatewayEngine { proof: &[u8], action: &[u8], ) -> Result { + self.check_effect_configuration() + .await + .map_err(not_entered)?; let loaded = match self.connection.load().await { Ok(Some(loaded)) => loaded, Err(SharedConnectionError::Rollback) => { @@ -1194,6 +1292,7 @@ impl GatewayEngine { &self.trusted_context, loaded.record(), self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, ), now, proof, @@ -1273,6 +1372,7 @@ impl GatewayEngine { &self, check_authority: impl FnOnce() -> Result<(), &'static str>, ) -> Result { + self.check_effect_configuration().await?; let loaded = match self.connection.load().await { Ok(Some(loaded)) => loaded, Err(SharedConnectionError::Rollback) => { @@ -1466,6 +1566,9 @@ impl SubmitIo for EngineIo<'_> { &self.engine.trusted_context, approved.connection(), self.engine.qualification.policy(), + self.engine + .effect_configuration_candidate() + .map_err(not_entered)?, ), now, )?; @@ -1492,6 +1595,9 @@ impl SubmitIo for EngineIo<'_> { &self.engine.trusted_context, prepared.loaded.record(), self.engine.qualification.policy(), + self.engine + .effect_configuration_candidate() + .map_err(not_entered)?, ), now, ) @@ -2188,6 +2294,12 @@ pub(crate) mod tests { ) .await .expect("install"); + let configuration = first.engine.shared_configuration().expect("configuration"); + let gate = Arc::clone(&first.engine.qualification); + tokio::task::spawn_blocking(move || configuration.initialize(&gate)) + .await + .expect("initialize task") + .expect("initialize configuration"); Installation { attempts, connection_id, diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index e8c4f7a7f..af2b1c1a3 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -21,6 +21,7 @@ pub use engine::{ GatewaySubmissionReview, commissioning_principal_sha256, review_submission, }; mod connection; +mod configuration; mod credential_journal; mod echo_verify; pub mod effect; diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index dd22cbb69..fa437efd3 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -23,7 +23,7 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-policy"; /// The schema identifier of the production lifecycle store. -pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/6"; +pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/7"; /// The schema identifier of the development file store. pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/4"; @@ -383,6 +383,59 @@ impl QualificationGate { } } + pub(crate) fn contract_digest(&self) -> Result<[u8; 32], &'static str> { + crate::configuration::digest( + "auths.effect-qualification-contract/1", + &( + self.policy.as_str(), + self.root.as_ref().map(|root| root.digest().to_hex()), + &self.deployment, + ), + ) + } + + pub(crate) fn shared_snapshot( + &self, + previous: &crate::configuration::QualificationMemory, + ) -> crate::configuration::QualificationSnapshot { + let mut memory = previous.clone(); + memory.merge(&self.verifier_state()); + let held = self.held(); + if let Some(held) = &held { + let mut remembered = memory.state(); + held.verified.remember(&mut remembered); + memory.merge(&remembered); + } + crate::configuration::QualificationSnapshot { + bundle: held.map(|held| held.digest), + memory, + } + } + + /// Adopts shared monotonic memory, but grants no qualification. Ordinary + /// entry must still call the native qualification check; commissioning + /// must verify its separate exact permit against this same memory. + pub(crate) fn accept_shared( + &self, + shared: &crate::configuration::QualificationSnapshot, + ) -> Result<(), &'static str> { + if shared.memory.blocked { + return Err("gateway.configuration.qualification-unavailable"); + } + let held = self.held(); + if shared.bundle != held.as_ref().map(|held| held.digest) { + return Err("gateway.configuration.qualification-changed"); + } + let mut local = self.state.lock().unwrap_or_else(PoisonError::into_inner); + let mut merged = shared.memory.clone(); + merged.merge(&local); + if merged.blocked { + return Err("gateway.configuration.qualification-unavailable"); + } + *local = merged.state(); + Ok(()) + } + /// The installation's policy. #[must_use] pub const fn policy(&self) -> QualificationPolicy { diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 2b45dcd4b..a731c05e2 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -92,9 +92,33 @@ async fn host_with(gate: &Arc) -> (Installation, ()) { .first .engine .set_qualification(Arc::clone(gate)); + let configuration = installation + .first + .engine + .shared_configuration() + .expect("configuration"); + let gate = Arc::clone(gate); + tokio::task::spawn_blocking(move || { + let revision = configuration.current_revision().expect("current revision"); + configuration + .activate(revision, &gate) + .expect("operator activation"); + }) + .await + .expect("activation task"); (installation, ()) } +// Operator import/reload publishes its authenticated snapshot before entry. +async fn publish(host: &Host, gate: &Arc) { + let configuration = host.engine.shared_configuration().expect("configuration"); + let gate = Arc::clone(gate); + tokio::task::spawn_blocking(move || configuration.publish(&gate)) + .await + .expect("publication task") + .expect("operator publication"); +} + async fn refusal(host: &Host) -> Option { let before = host.leases.load(Ordering::SeqCst); let result = host.entry_refusal().await; @@ -240,6 +264,7 @@ async fn operator_bootstrap_qualification_simulation() { let mut unsigned = attested_bundle.clone(); unsigned.attestations.clear(); assert!(gate.load(&unsigned)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.missing") @@ -247,6 +272,7 @@ async fn operator_bootstrap_qualification_simulation() { assert_eq!(host.leases.load(Ordering::SeqCst), 0); let before_signature_leases = host.leases.load(Ordering::SeqCst); assert!(gate.load(&attested_bundle)); + publish(host, &gate).await; assert_eq!(refusal(host).await, None); assert_eq!(host.leases.load(Ordering::SeqCst), 1); let after_verified_import_leases = host.leases.load(Ordering::SeqCst); @@ -254,6 +280,7 @@ async fn operator_bootstrap_qualification_simulation() { let position = forged.attestations[0].len() / 2; forged.attestations[0][position] ^= 1; assert!(gate.load(&forged)); + publish(host, &gate).await; // The untouched second record may remain qualified. A corrupt member // cannot enable the record whose attestation was changed. if deployment.recipe_family == proposals[0].record().body().tuple.recipe_family { @@ -261,6 +288,7 @@ async fn operator_bootstrap_qualification_simulation() { assert_eq!(host.leases.load(Ordering::SeqCst), 1); } assert!(gate.load(&attested_bundle)); + publish(host, &gate).await; clock.set(NOW + 13 * HOUR); assert_eq!( refusal(host).await.as_deref(), @@ -345,6 +373,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() Some("gateway.qualification.unavailable") ); assert!(gate.load(&bundle)); + publish(host, &gate).await; assert_eq!(refusal(host).await, None, "a qualified deployment leases"); assert!(!gate.load(&bundle), "equal inputs are not verified again"); assert_eq!(gate.status().state, RecipeQualificationState::Qualified); @@ -383,6 +412,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() let mut expired = bundle.clone(); expired.revocation_list = release.list(2, after, &[]); assert!(gate.load(&expired)); + publish(host, &gate).await; clock.set(after); assert_eq!( refusal(host).await.as_deref(), @@ -397,6 +427,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() let last = forged.release_index.len() - 3; forged.release_index[last] ^= 1; assert!(gate.load(&forged)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.unavailable") @@ -405,6 +436,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() unsigned.release_index.clear(); unsigned.attestations.clear(); assert!(gate.load(&unsigned)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.unavailable"), @@ -415,6 +447,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() let mut revoking = bundle.clone(); revoking.revocation_list = release.list(3, NOW, &[&qualification_id]); assert!(gate.load(&revoking)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.revoked") @@ -422,6 +455,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() let mut omitting = bundle.clone(); omitting.revocation_list = release.list(4, NOW, &[]); assert!(gate.load(&omitting)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.revoked"), @@ -434,6 +468,7 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() ); assert_eq!(gate.verifier_state().accepted_revocation_sequence, 4); assert!(gate.load(&bundle)); + publish(host, &gate).await; assert_eq!( refusal(host).await.as_deref(), Some("gateway.qualification.revoked"), @@ -441,8 +476,10 @@ async fn a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease() ); assert!(!gate.inputs_usable(), "an older list is not importable"); assert!(gate.load(&omitting)); + publish(host, &gate).await; assert!(gate.inputs_usable()); assert!(gate.load(&unsigned)); + publish(host, &gate).await; assert!( !gate.inputs_usable(), "an unsigned record is not importable" diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 20623429c..6f0d08539 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "5bcbbf6cbde0a906dd7b05f69fdf02d1ee23e9463fd0bd0d9b9f3d8cd3e003fc"; + "cf4a1f70f598419b180d5776a8c822dd9d487438fd80230c3bdcf442da1b8e22"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index fc1902b07..e64e3945e 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -7,7 +7,7 @@ //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none //! insert-once, compare-and-swap, and sweep mechanism over opaque bounded -//! bytes of five closed kinds: [`FileGatewayAttemptStore`] for one host, and +//! bytes of six closed kinds: [`FileGatewayAttemptStore`] for one host, and //! the multi-host `PostgresLifecycleStore`, whose production qualification is //! still open. @@ -970,7 +970,7 @@ fn fence_keys( Ok(keys) } -/// Durable storage of opaque gateway records of five closed kinds. +/// Durable storage of opaque gateway records of six closed kinds. /// Implementations never interpret the bytes. /// /// Every implementation must pass the same conformance suite: one winner per @@ -1141,6 +1141,7 @@ impl FileGatewayAttemptStore { GatewayRecordKind::SumSlot => "sum-", GatewayRecordKind::Connection => "conn-", GatewayRecordKind::CommissioningBudget => "commission-", + GatewayRecordKind::EffectConfiguration => "config-", }; format!("{prefix}{}.json", hex::encode(key.as_bytes())) } @@ -1391,7 +1392,7 @@ impl FileGatewayAttemptStore { /// A record or batch file name this store writes. fn valid_file_name(name: &str) -> bool { - let Some(rest) = ["claim-", "slot-", "sum-", "conn-", "commission-"] + let Some(rest) = ["claim-", "slot-", "sum-", "conn-", "commission-", "config-"] .iter() .find_map(|prefix| name.strip_prefix(prefix)) else { diff --git a/product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql b/product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql new file mode 100644 index 000000000..c9800a223 --- /dev/null +++ b/product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql @@ -0,0 +1,70 @@ +CREATE TABLE auths_lifecycle_store_meta ( + singleton BOOLEAN PRIMARY KEY DEFAULT TRUE CHECK (singleton), + schema_version INTEGER NOT NULL CHECK (schema_version = 7), + contract_id TEXT NOT NULL CHECK ( + contract_id = 'auths.lifecycle.transactional-store/4' + ) +); + +INSERT INTO auths_lifecycle_store_meta (singleton, schema_version, contract_id) +VALUES (TRUE, 7, 'auths.lifecycle.transactional-store/4'); + +CREATE TABLE auths_lifecycle_records ( + workflow_id TEXT PRIMARY KEY CHECK ( + octet_length(workflow_id) BETWEEN 1 AND 256 + ), + revision BIGINT NOT NULL CHECK (revision >= 1), + lifecycle_state SMALLINT NOT NULL CHECK ( + lifecycle_state BETWEEN 0 AND 8 + ), + record_bytes BYTEA NOT NULL CHECK ( + octet_length(record_bytes) BETWEEN 1 AND 262144 + ), + record_sha256 BYTEA NOT NULL CHECK ( + octet_length(record_sha256) = 32 + ) +); + +CREATE TABLE auths_recovery_references ( + recovery_reference_digest BYTEA PRIMARY KEY CHECK ( + octet_length(recovery_reference_digest) = 32 + ), + workflow_id TEXT UNIQUE NOT NULL CHECK ( + octet_length(workflow_id) BETWEEN 1 AND 256 + ), + profile_id TEXT NOT NULL CHECK ( + octet_length(profile_id) BETWEEN 1 AND 256 + ) +); + +CREATE INDEX auths_recovery_profile_workflow +ON auths_recovery_references (profile_id, workflow_id); + +CREATE TABLE auths_recovery_leases ( + workflow_id TEXT PRIMARY KEY CHECK ( + octet_length(workflow_id) BETWEEN 1 AND 256 + ), + profile_id TEXT NOT NULL CHECK ( + octet_length(profile_id) BETWEEN 1 AND 256 + ), + expected_revision BIGINT NOT NULL CHECK (expected_revision >= 1), + expires_at BIGINT NOT NULL CHECK (expires_at >= 0), + lease_digest BYTEA NOT NULL CHECK (octet_length(lease_digest) = 32) +); + +CREATE TABLE auths_gateway_records ( + record_key BYTEA PRIMARY KEY CHECK (octet_length(record_key) = 32), + record_kind TEXT NOT NULL CHECK ( + record_kind IN ('attempt', 'count-slot', 'sum-slot', 'connection', 'commissioning-budget', 'effect-configuration') + ), + expires_at BIGINT NULL CHECK (expires_at IS NULL OR expires_at >= 0), + record_bytes BYTEA NOT NULL CHECK ( + octet_length(record_bytes) BETWEEN 1 AND 262144 + ), + record_sha256 BYTEA NOT NULL CHECK (octet_length(record_sha256) = 32), + CHECK ((record_kind IN ('count-slot', 'sum-slot')) = (expires_at IS NOT NULL)) +); + +CREATE INDEX auths_gateway_records_expiry +ON auths_gateway_records (expires_at) +WHERE record_kind IN ('count-slot', 'sum-slot'); diff --git a/product/stores/auths-stores/src/gateway_attempt.rs b/product/stores/auths-stores/src/gateway_attempt.rs index c8fba4555..24a389510 100644 --- a/product/stores/auths-stores/src/gateway_attempt.rs +++ b/product/stores/auths-stores/src/gateway_attempt.rs @@ -2,7 +2,7 @@ //! //! This is a mechanism only: all-or-none insert-once batches, a //! compare-and-swap replacement, and a bounded sweep of expired slots, over -//! bounded bytes tagged with one of five closed record kinds. The gateway +//! bounded bytes tagged with one of six closed record kinds. The gateway //! owns every record format, its stages, and which replacements are valid. use crate::lifecycle::{PostgresLifecycleStore, map_postgres_error}; @@ -95,6 +95,8 @@ pub enum GatewayRecordKind { Connection, /// A commissioning run's immutable binding and consumed leases; never swept. CommissioningBudget, + /// Installed effect policy/configuration and shared qualification memory. + EffectConfiguration, } impl GatewayRecordKind { @@ -107,6 +109,7 @@ impl GatewayRecordKind { Self::SumSlot => "sum-slot", Self::Connection => "connection", Self::CommissioningBudget => "commissioning-budget", + Self::EffectConfiguration => "effect-configuration", } } @@ -119,6 +122,7 @@ impl GatewayRecordKind { "sum-slot" => Some(Self::SumSlot), "connection" => Some(Self::Connection), "commissioning-budget" => Some(Self::CommissioningBudget), + "effect-configuration" => Some(Self::EffectConfiguration), _ => None, } } @@ -504,7 +508,7 @@ mod tests { bounded(&vec![0; MAX_GATEWAY_RECORD_BYTES + 1]), Err(StoreError::LimitExceeded) ); - let schema = include_str!("../migrations/postgres_lifecycle_v6.sql"); + let schema = include_str!("../migrations/postgres_lifecycle_v7.sql"); assert!( schema.contains("octet_length(record_bytes) BETWEEN 1 AND 262144"), "the schema bound and the Rust bound are the same" @@ -515,6 +519,7 @@ mod tests { "sum-slot", "connection", "commissioning-budget", + "effect-configuration", ] { assert_eq!( GatewayRecordKind::parse(kind).map(GatewayRecordKind::as_str), diff --git a/product/stores/auths-stores/src/lifecycle.rs b/product/stores/auths-stores/src/lifecycle.rs index 16608124c..9469fe0fb 100644 --- a/product/stores/auths-stores/src/lifecycle.rs +++ b/product/stores/auths-stores/src/lifecycle.rs @@ -34,9 +34,9 @@ use tokio_postgres_rustls::MakeRustlsConnect; const DATABASE_MAGIC: &[u8; 8] = b"AUTHSLF1"; const MAX_DATABASE_BYTES: usize = 256 * 1024 * 1024; const MAX_RECORD_BYTES: usize = auths_lifecycle::MAX_LIFECYCLE_RECORD_BYTES; -const SCHEMA_VERSION: i32 = 6; +const SCHEMA_VERSION: i32 = 7; const CONTRACT_ID: &str = "auths.lifecycle.transactional-store/4"; -const POSTGRES_SCHEMA: &str = include_str!("../migrations/postgres_lifecycle_v6.sql"); +const POSTGRES_SCHEMA: &str = include_str!("../migrations/postgres_lifecycle_v7.sql"); /// One closed capacity rule configured by a domain registration. #[derive(Clone, Debug, Eq, PartialEq)] @@ -536,7 +536,7 @@ impl PostgresStoreSummary { /// Returns the physical schema identity. #[must_use] pub const fn schema_id(self) -> &'static str { - "auths.lifecycle.postgresql/6" + "auths.lifecycle.postgresql/7" } /// Returns the transactional store contract identity. diff --git a/qualification/reference/expand.py b/qualification/reference/expand.py index 716859a5d..20e30d162 100644 --- a/qualification/reference/expand.py +++ b/qualification/reference/expand.py @@ -94,7 +94,7 @@ def expand(args): target = tuple_value['target'] require(target['os'] == 'linux' and target['arch'] == 'x86_64' and target['store_kind'] == 'postgresql-v1' - and target['store_schema'] == 'auths.lifecycle.postgresql/6' + and target['store_schema'] == 'auths.lifecycle.postgresql/7' and target['credential_store_kind'] == 'aws-secrets-manager-v1', 'qualification.reference.production-target') require(sha256(read(args.candidate, 256 * 1024 * 1024)) == target['gateway_build_sha256'], diff --git a/qualification/reference/native_observation.py b/qualification/reference/native_observation.py index 000c5b45c..3c2a64ce9 100644 --- a/qualification/reference/native_observation.py +++ b/qualification/reference/native_observation.py @@ -78,7 +78,7 @@ def interrupted_state(tuple_value, reviewed, trusted_context_sha256, support): and support['deployment'] == 'production' and support['credential_store_kind'] == target['credential_store_kind'] and target['store_kind'] == 'postgresql-v1' - and target['store_schema'] == 'auths.lifecycle.postgresql/6' + and target['store_schema'] == 'auths.lifecycle.postgresql/7' and target['credential_store_kind'] == 'aws-secrets-manager-v1', 'qualification.observation.interrupted-tuple') qualification = support['qualification'] diff --git a/qualification/reference/tests/test_native_observation.py b/qualification/reference/tests/test_native_observation.py index 64d2170c2..35636d481 100644 --- a/qualification/reference/tests/test_native_observation.py +++ b/qualification/reference/tests/test_native_observation.py @@ -83,7 +83,7 @@ def support(self): self.tuple.update(profile_lock_sha256='3' * 64, gateway_semantic_closure_sha256='4' * 64, target={'gateway_package': 'auths-gateway', 'gateway_version': 'synthetic-only', 'gateway_build_sha256': '5' * 64, 'store_kind': 'postgresql-v1', - 'store_schema': 'auths.lifecycle.postgresql/6', 'credential_store_kind': 'aws-secrets-manager-v1'}) + 'store_schema': 'auths.lifecycle.postgresql/7', 'credential_store_kind': 'aws-secrets-manager-v1'}) key = sha256(b'auths.gateway-logical-operation/1\0' + self.arguments['operator_namespace'].encode() + b'\0' + self.arguments['operation_id'].encode()) return {'schema': 'auths.gateway-support-bundle/1', 'gateway_package': 'auths-gateway', diff --git a/qualification/reference/tests/test_reference.py b/qualification/reference/tests/test_reference.py index 2808c47a6..fd14f5780 100644 --- a/qualification/reference/tests/test_reference.py +++ b/qualification/reference/tests/test_reference.py @@ -211,7 +211,7 @@ def test_binding_is_rederived_and_altered_source_or_native_observations_refuse(s tuple_value['recipe_family'] = stripe.FAMILY tuple_value['compiled_recipe_sha256'] = DIGEST tuple_value['target']['gateway_build_sha256'] = sha256((work / 'candidate').read_bytes()) - tuple_value['target']['store_schema'] = 'auths.lifecycle.postgresql/6' + tuple_value['target']['store_schema'] = 'auths.lifecycle.postgresql/7' (work / 'tuple.json').write_bytes(canonical(tuple_value)) tuple_digest = sha256(b'auths.qualification-tuple/1\0' + canonical(tuple_value)) for member_name in ['conformance', 'differential']: diff --git a/xtask/src/semantic_freeze.rs b/xtask/src/semantic_freeze.rs index ccd1514e0..647ccaa56 100644 --- a/xtask/src/semantic_freeze.rs +++ b/xtask/src/semantic_freeze.rs @@ -527,7 +527,7 @@ fn generate_inventory() -> Result { "product/fixtures/v1/lifecycle/registry.toml".to_owned(), "product/runtime/auths-lifecycle/src".to_owned(), "product/stores/auths-stores/src/lifecycle.rs".to_owned(), - "product/stores/auths-stores/migrations/postgres_lifecycle_v6.sql".to_owned(), + "product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql".to_owned(), "product/stores/auths-stores/tests/postgres_lifecycle.rs".to_owned(), "product/stores/auths-stores/tests/postgres_tls".to_owned(), ], From 558a68e18a4a37d154c851387745f82d6921d838 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 03:45:31 +0000 Subject: [PATCH 014/136] chore(formal): regenerate qualification artifacts Source-SHA: 8dbd99391b274d8a9589dd28c1ba0187fb9cd90e Workflow-Run: 40628243754 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 9c4e0205f..003e34c54 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "2a5b02a1ceeaa15c63cca7e083875f84bf7a483a8d0c63db87aee19697d8c3f5", + "digest": "bd1d82a3172d544cad6ecb8c917eded9b94dc0550721ec63f4fd2999d8a7441b", "files": [ { "path": ".cargo/config.toml", @@ -401,7 +401,7 @@ }, { "path": "xtask/src/semantic_freeze.rs", - "sha256": "9e36c78ae7ed8ce11bbc545ef7db8c1741c826038d01a7fb66d6e7fa5c91b18b" + "sha256": "c57617cd19351f71e145974e9c134717ce3d9e816510a8a03c922746b66bb9b0" }, { "path": "xtask/src/stripe.rs", From 3cbe3ad823bdd5f455a421a6ae994fe07beea368 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 03:46:17 +0000 Subject: [PATCH 015/136] fix(stores): report the active PostgreSQL schema version --- docs/plans/0074-implementation-status.md | 5 +++++ product/runtime/auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/semantic_closure.rs | 2 +- product/stores/auths-stores/src/lifecycle.rs | 2 +- 4 files changed, 8 insertions(+), 3 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 999cd39cf..c6dc70480 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -246,6 +246,11 @@ Attempting send path is not represented as compliant final entry. `semantic_closure::tests::semantic_closure_is_current` passed (one test). These are artifact construction, not adapter race, formal or hosted CI evidence. +The configuration checkpoint is committed and pushed as `8dbd9939`. A follow-up +source audit found the PostgreSQL health projection still reported literal schema +6; it now derives the version from the active schema constant. Required semantic +closure regeneration passed after that correction (one artifact-generation test). + ## Phase gates | Phase | State | Outstanding gate | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 8ab199d33..3d4ac5803 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"0418fd85dd7124c1cc1a644e537af889f102992052a36c3374c71457c3414b86"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a7d97bf32205b51eadb52daa9076c6bdbc81e210e34edc8d37128aa00f0a3f3f"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"526273edfcb6bba88896f4e715368024661896eed6f56eb75a0f9f0d946e3eb1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"77dddf1f426441d759deb8844a8a58fc0ddfb915d09e3dbc22a808ec3aa19051"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"21f38bc74329bb6868095e564c844ac24e2e4c51cf656d54cc8efe4c88b2182c"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"455c1a2fe7a9ac2a916f75c95203a3f83f6d39800517dc8aecb85976a0683576"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"07b25d682b7bc1543602e0dea3007d0f1b24d60e11c7f5ebc858170b38f60534"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"0418fd85dd7124c1cc1a644e537af889f102992052a36c3374c71457c3414b86"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a7d97bf32205b51eadb52daa9076c6bdbc81e210e34edc8d37128aa00f0a3f3f"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"526273edfcb6bba88896f4e715368024661896eed6f56eb75a0f9f0d946e3eb1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"77dddf1f426441d759deb8844a8a58fc0ddfb915d09e3dbc22a808ec3aa19051"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"21f38bc74329bb6868095e564c844ac24e2e4c51cf656d54cc8efe4c88b2182c"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"455c1a2fe7a9ac2a916f75c95203a3f83f6d39800517dc8aecb85976a0683576"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 6f0d08539..c1a599c80 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "cf4a1f70f598419b180d5776a8c822dd9d487438fd80230c3bdcf442da1b8e22"; + "9c37f9c5c5ff0a6f0b3920c0262e6b5c5d00425865f1de3a384c889161b0b4da"; #[cfg(test)] mod tests { diff --git a/product/stores/auths-stores/src/lifecycle.rs b/product/stores/auths-stores/src/lifecycle.rs index 9469fe0fb..b00620fd6 100644 --- a/product/stores/auths-stores/src/lifecycle.rs +++ b/product/stores/auths-stores/src/lifecycle.rs @@ -711,7 +711,7 @@ impl PostgresLifecycleStore { } let state = self.pool.state(); Ok(PostgresStoreHealth { - schema_version: 6, + schema_version: u16::try_from(SCHEMA_VERSION).map_err(|_| StoreError::Corrupt)?, pool_connections: state.connections, pool_idle_connections: state.idle_connections, }) From fd8803c0737b2a2ddd39aed8e365b46440c8bb6d Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 04:06:43 +0000 Subject: [PATCH 016/136] feat(gateway)!: require fenced durable grants for provider entry --- .../gateway/attempt-scenarios-v3.json | 81 +++--- bindings/fixtures/gateway/effect-entry.json | 15 + compliance.toml | 9 +- ...017-bound-effect-and-recovery-ownership.md | 38 +++ docs/plans/0074-implementation-status.md | 32 +- .../0009-bound-effect-and-recovery.md | 9 + .../runtime/auths-gateway-kernel/src/order.rs | 53 +++- .../auths-gateway-kernel/src/outcome.rs | 18 +- .../auths-gateway-kernel/src/transition.rs | 220 +++++++------- ...solete-record-not-entered-refund-5-window} | 0 ...bsolete-record-response-recorded-refund-1} | 0 ...bsolete-record-response-recorded-refund-4} | 0 ...attempting-to-not-entered-refund-5-window} | Bin ...-attempting-to-response-recorded-refund-1} | Bin ...-attempting-to-response-recorded-refund-4} | Bin .../record-entry-granted-synthetic-entry | 1 + .../record-not-entered-synthetic-entry | 1 + .../record-reserved-synthetic-entry | 1 + .../record-response-recorded-synthetic-entry | 1 + .../record-unknown-synthetic-entry | 1 + ...anted-to-response-recorded-synthetic-entry | Bin 0 -> 5287 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 0 -> 5170 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 0 -> 5021 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 0 -> 4899 bytes .../fuzz_targets/target_gateway_attempt.rs | 30 +- .../auths-gateway/fuzz/tests/corpus.rs | 17 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/commissioning_budget.rs | 28 ++ .../src/commissioning_session.rs | 86 +++++- .../auths-gateway/src/configuration.rs | 13 + .../runtime/auths-gateway/src/connection.rs | 4 + product/runtime/auths-gateway/src/engine.rs | 39 ++- product/runtime/auths-gateway/src/entry.rs | 146 ++++++++++ .../runtime/auths-gateway/src/entry_tests.rs | 226 +++++++++++++++ product/runtime/auths-gateway/src/harness.rs | 17 +- product/runtime/auths-gateway/src/lib.rs | 1 + product/runtime/auths-gateway/src/observer.rs | 17 +- .../src/pending_vectors/attempts.rs | 39 +-- .../auths-gateway/src/property_tests.rs | 49 ++-- .../auths-gateway/src/qualification.rs | 62 +++- .../src/qualification_simulation.rs | 5 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../runtime/auths-gateway/src/recipe/tests.rs | 33 ++- .../auths-gateway/src/scenario_tests.rs | 31 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 274 +++++++++++++++++- product/runtime/auths-gateway/src/submit.rs | 64 ++-- product/runtime/auths-gateway/src/support.rs | 3 +- .../runtime/auths-gateway/src/transport.rs | 55 +++- 49 files changed, 1425 insertions(+), 300 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-entry.json rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{record-not-entered-refund-5-window => obsolete-record-not-entered-refund-5-window} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{record-response-recorded-refund-1 => obsolete-record-response-recorded-refund-1} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{record-response-recorded-refund-4 => obsolete-record-response-recorded-refund-4} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{transition-attempting-to-not-entered-refund-5-window => obsolete-transition-attempting-to-not-entered-refund-5-window} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{transition-attempting-to-response-recorded-refund-1 => obsolete-transition-attempting-to-response-recorded-refund-1} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/{transition-attempting-to-response-recorded-refund-4 => obsolete-transition-attempting-to-response-recorded-refund-4} (100%) create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry create mode 100644 product/runtime/auths-gateway/src/entry.rs create mode 100644 product/runtime/auths-gateway/src/entry_tests.rs diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index e9381b8c9..27d6481e8 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/4", + "attempt_schema": "auths.gateway-attempt/5", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { @@ -174,7 +174,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.pre-entry.condition-false", @@ -189,8 +189,9 @@ "recipe": "airtable-pre-entry", "setup": {}, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", + "entry-granted", "response-recorded", "observed-by-provider" ], @@ -214,7 +215,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.pre-entry.unavailable", @@ -258,7 +259,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.relative-ceiling.above", @@ -273,8 +274,9 @@ "recipe": "stripe", "setup": {}, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", + "entry-granted", "response-recorded", "observed-by-provider" ], @@ -303,7 +305,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.relative-ceiling.unavailable", @@ -331,7 +333,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.relative-ceiling.unavailable", @@ -357,7 +359,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.relative-ceiling.unavailable", @@ -385,7 +387,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.relative-ceiling.binding-mismatch", @@ -402,7 +404,7 @@ "leased_secret_prefix": "sk_test_" }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.mode-guard", @@ -429,7 +431,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.account-mismatch", @@ -453,7 +455,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.account-unavailable", @@ -479,7 +481,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.capability-excess", @@ -503,7 +505,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.capability-unavailable", @@ -525,7 +527,7 @@ } }, "stages": [ - "attempting", + "reserved", "not-entered" ], "code": "gateway.credential.capability-unavailable", @@ -600,8 +602,9 @@ "recipe": "stripe", "setup": {}, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", + "entry-granted", "response-recorded", "observed-by-provider" ], @@ -705,8 +708,9 @@ "validity_seconds": 86340 }, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", + "entry-granted", "response-recorded", "observed-by-provider" ], @@ -726,8 +730,8 @@ } }, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", "not-entered" ], "code": "gateway.attempt.entry-deadline", @@ -743,11 +747,12 @@ "write_transport": "refused-before-send" }, "stages": [ - "attempting", - "attempting", - "not-entered" + "reserved", + "reserved", + "entry-granted", + "unknown" ], - "code": "gateway.transport.not-entered", + "code": null, "leases": 1, "credential_reads": 3, "action_reads": 1, @@ -761,8 +766,9 @@ "replay": "fresh-proof" }, "stages": [ - "attempting", - "attempting", + "reserved", + "reserved", + "entry-granted", "unknown" ], "code": null, @@ -779,7 +785,8 @@ "replay": "same-binding" }, "stages": [ - "attempting", + "reserved", + "entry-granted", "observed-by-provider" ], "code": null, @@ -792,32 +799,32 @@ "record_cases": [ { "id": "first-claim", - "transition": "unclaimed->attempting", + "transition": "unclaimed->reserved", "provider_entries": 0 }, { "id": "same-id-fresh-challenge", - "transition": "attempting->binding-conflict", + "transition": "reserved->binding-conflict", "provider_entries": 0 }, { "id": "changed-action-same-id", - "transition": "attempting->binding-conflict", + "transition": "reserved->binding-conflict", "provider_entries": 0 }, { "id": "crash-after-claim", - "transition": "attempting->unknown-on-restart", + "transition": "reserved->reserved-on-restart", "provider_entries": 0 }, { "id": "complete-http-response", - "transition": "attempting->response-recorded", + "transition": "entry-granted->response-recorded", "provider_entries": 1 }, { "id": "ambiguous-transport", - "transition": "attempting->unknown", + "transition": "entry-granted->unknown", "provider_entries": 1 }, { diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json new file mode 100644 index 000000000..eab5700d5 --- /dev/null +++ b/bindings/fixtures/gateway/effect-entry.json @@ -0,0 +1,15 @@ +{ + "schema": "auths.effect-entry-fixture/1", + "scope": "native synthetic post-verification grant; no provider entry or installed authority claim", + "reserved_stage": "reserved", + "granted_stage": "entry-granted", + "restart_projection": "unknown", + "second_grant_refused": true, + "post_grant_nonentry_refused": true, + "entry_audit": { + "schema": "auths.effect-entry/1", + "granted_at": 1790000000, + "effect_id": "ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3", + "dependencies": [] + } +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 7cf30d220..f7d1eb8de 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/4", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/5", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/4", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-entry/1", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/5", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,11 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +effect-entry = [ + "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_grant_has_one_winner_and_no_restart_permit", +] effect-configuration = [ "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index bd2d386c5..6bfe47428 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -214,3 +214,41 @@ witnesses, not an alternate shared admission authority. Compilation and entry preparation now perform early checks. The final grant must still repeat these checks over the configuration snapshot under its own attempt fence. No final-entry guarantee is claimed by these early checks. + +## Mutation grant source cutover + +Attempt schema `/5` separates `Reserved` from `EntryGranted`. Admission creates +only a reservation. The existing kernel transition owner requires immutable +entry-audit bytes for every post-grant stage and forbids post-grant non-entry. +The existing submission step machine now has an explicit `GrantEntry` action; +only its successful acknowledgement can lead to `Send`. + +`ClaimedGatewayAttempt::grant_entry` holds the common adapter fence while it +checks the exact attempt bytes, installed connection, shared configuration and +every reserved count/sum slot. Commissioning additionally reads its permanent +budget record and checks it against the acknowledged pre-custody floor. The +native validation samples the deployment clock after lock acquisition, freezes +one published qualification bundle plus monotonic memory, re-runs the original +proof and exact approval, and checks the connection/workload/profile and time +bounds. A concurrent process-local reload cannot replace that frozen evidence. +No provider, custody or nested store I/O runs in the decision. Deployment clock +sampling retains the clock implementation's explicit platform assumptions. + +Reservation membership checks cover exact key, kind, operation, window, slot, +amount and capacity, including the one-to-one correspondence with native count +and sum obligations. The grant allocates no second slot. Its private immutable +audit includes the effect identity, grant time and domain-separated commitments +to dependency snapshots. The adapter must acknowledge durable publication before +one non-cloneable/non-deserializable permit is constructed. Every managed write +port, through the final HTTPS transport, consumes that permit and obtains its +request from the retained native command. Callers cannot supply substitute bytes. + +After a grant, even a transport failure before a socket opens is unknown; it +cannot become `NotEntered`. A lost commit acknowledgement returns no permit. +Reading a granted record after restart projects unknown and never remints one. +The native corpus exercises one file-backed grant, stale-grant refusal and +crash-before-send projection; separate file/PostgreSQL race tests are authored. +This is not yet full P2 evidence. Reopening a reservation with fresh approval, +explicit journal revisions, installed after-lock expiry/revocation races, +ambiguous-commit fault injection and translated/refinement regeneration remain +open. Acquisition/disclosure and independent recovery are later cutovers. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c6dc70480..85533ee64 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -251,13 +251,43 @@ source audit found the PostgreSQL health projection still reported literal schem 6; it now derives the version from the active schema constant. Required semantic closure regeneration passed after that correction (one artifact-generation test). +## Mutation entry grant checkpoint + +- Attempt `/5` now creates `Reserved`; the existing transition owner alone + permits `Reserved -> EntryGranted` and freezes its private grant audit. + Post-grant state cannot become `NotEntered`. A restart projects a grant to + unknown while retaining reservations as reservations in the journal. +- The existing step machine requires an acknowledged `GrantEntry` before `Send`. + The runtime checks native original authority, exact approval, connection, + configuration, qualification, time and all count/sum slots under one fence. + Qualification evidence is frozen once to exclude process-local reload races. + Commissioning checks the current permanent budget against its acknowledged + pre-custody floor and merges retained revocation state in the same read set. +- Every managed write port, including HTTPS, consumes a sealed one-use permit + and derives the request from its retained command. An ambiguous commit yields + no permit. Transport failures after the grant retain unknown, even before send. +- Native `effect-entry.json` generation passed on `3cbe3ad8` plus this source: + one file-backed grant, stale second-grant refusal, immutable audit and + crash-before-send projection. The generator also emits valid native stage and + transition fuzz seeds; previous-schema seeds are retained as negative inputs. + This synthetic post-verification corpus does not prove installed authority. +- Updated attempt-scenario and final semantic-closure generators passed. Native + CLI approval-envelope generation also passed and matched the unchanged corpus. New + file/PostgreSQL concurrent-grant, reducer and property-test source is authored; + broad suites, installed races, formal gates and hosted CI remain unexecuted. +- P2 remains open: resumable reservations with fresh authority/approval, explicit + revisions, full private audit/projection treatment, installed clock/revocation + races and all persistence/transport failpoints. Formal translated output must + be regenerated against the changed shipping predicates. P3/P4 and all complete + acceptance gates remain open. No AP073 or delegation work was performed. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | In progress | Finish installed first mutation cutover and native fixtures | -| P2 | Adapter and shared configuration implemented | Reservation/grant reducer and fenced permit wiring | +| P2 | Mutation grant wired | Reservation restart/revisions, full installed fault/race evidence and formal links | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index d27d1048d..f6a52acd2 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -131,3 +131,12 @@ identity, grant entry or establish multi-host revocation freshness. The shared c permanent qualification memory and requires explicit operator CAS activation. Connecting its snapshot to the one-use grant owner remains P2 work, as specified in ADR 0017. Early host checks are not final-entry evidence. + + +The mutation source now connects this primitive to the existing transition and +submission owners: reservation and durable grant are separate, fixed grant audit +bytes cannot change, and transport consumes a capability issued only after the +fenced replacement acknowledges. The same retained command supplies the request. +Slot membership is checked without reallocation. The native synthetic grant +corpus proves its narrow file-store sequence; it does not establish installed +multi-process fencing, all fault boundaries or the still-open recovery cutover. diff --git a/product/runtime/auths-gateway-kernel/src/order.rs b/product/runtime/auths-gateway-kernel/src/order.rs index 22f76a58c..479b1482e 100644 --- a/product/runtime/auths-gateway-kernel/src/order.rs +++ b/product/runtime/auths-gateway-kernel/src/order.rs @@ -102,6 +102,8 @@ pub enum Phase { EntryReload, /// Awaiting the entry-deadline check. Deadline, + /// Awaiting a newly acknowledged durable entry grant. + Grant, /// Awaiting the provider write. Send, /// Awaiting the store write of the response. @@ -204,8 +206,6 @@ pub enum CeilingRead { /// The result of the provider write. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum WriteResult { - /// Refused before network entry. - NotEntered, /// Transport may have been entered; no complete response. Unknown, /// A complete bounded response was received. @@ -261,6 +261,8 @@ pub enum SubmitEvent { Recorded(bool), /// Entry is within the deadline. Deadline(bool), + /// A new durable grant was acknowledged and yielded its one-use permit. + Granted(bool), /// The provider write result. Write(WriteResult), /// The response record result. @@ -311,7 +313,7 @@ pub enum Stop { ClaimRefused, /// `not-entered` was recorded after the claim. NotEntered, - /// The stored record is `attempting` or `unknown`. + /// The stored record is `entry-granted` or `unknown`. Unknown, /// The response is recorded and no read-back transition was. Response, @@ -354,12 +356,14 @@ pub enum SubmitAction { PreEntryRead, /// Run the relative-ceiling read. CeilingRead, - /// Record what was read in one `attempting → attempting`. + /// Record what was read in one `reserved → reserved`. RecordCheckpoint, /// Reload the connection record before entry. ReloadBeforeEntry, /// Check the entry deadline. CheckDeadline, + /// Validate and durably grant entry under the common writer fence. + GrantEntry, /// Send the one write. Send, /// Record the response. @@ -609,7 +613,6 @@ pub const fn after_ceiling(state: SubmitState, read: CeilingRead) -> SubmitDecis #[must_use] pub const fn after_write(state: SubmitState, result: WriteResult) -> SubmitDecision { match result { - WriteResult::NotEntered => not_entered(state, Refusal::TransportNotEntered), WriteResult::Unknown => go(state, Phase::RecordUnknown, SubmitAction::RecordUnknown), WriteResult::Response => go(state, Phase::RecordResponse, SubmitAction::RecordResponse), } @@ -803,13 +806,18 @@ pub const fn entry_step(state: SubmitState, event: SubmitEvent) -> SubmitDecisio Phase::Deadline => match event { SubmitEvent::Deadline(within) => { if within { - go(state, Phase::Send, SubmitAction::Send) + go(state, Phase::Grant, SubmitAction::GrantEntry) } else { not_entered(state, Refusal::EntryDeadline) } } _ => halt(state), }, + Phase::Grant => match event { + SubmitEvent::Granted(true) => go(state, Phase::Send, SubmitAction::Send), + SubmitEvent::Granted(false) => stop(state, Stop::Unknown), + _ => halt(state), + }, Phase::Send => match event { SubmitEvent::Write(result) => after_write(state, result), _ => halt(state), @@ -864,6 +872,7 @@ pub const fn next_step(state: SubmitState, event: SubmitEvent) -> SubmitDecision | Phase::Checkpoint | Phase::EntryReload | Phase::Deadline + | Phase::Grant | Phase::Send | Phase::RecordResponse | Phase::RecordUnknown @@ -927,6 +936,7 @@ mod tests { SubmitEvent::Recorded(true), SubmitEvent::Reload(true), SubmitEvent::Deadline(true), + SubmitEvent::Granted(true), SubmitEvent::Write(WriteResult::Response), SubmitEvent::Response(ResponseRecord::Recorded { observable: true }), SubmitEvent::Reload(true), @@ -957,6 +967,7 @@ mod tests { SubmitAction::RecordCheckpoint, SubmitAction::ReloadBeforeEntry, SubmitAction::CheckDeadline, + SubmitAction::GrantEntry, SubmitAction::Send, SubmitAction::RecordResponse, SubmitAction::Reload(back), @@ -1046,6 +1057,36 @@ mod tests { assert!(!refused.contains(&SubmitAction::Claim)); } + #[test] + fn sending_requires_a_new_acknowledged_grant() { + let state = SubmitState { + plan: STRIPE, + phase: Phase::Grant, + argument: 500, + }; + assert_eq!( + next_step(state, SubmitEvent::Granted(true)).action, + SubmitAction::Send + ); + assert_eq!( + next_step(state, SubmitEvent::Granted(false)).action, + SubmitAction::Stop(Stop::Unknown) + ); + assert_eq!( + next_step(state, SubmitEvent::Write(WriteResult::Response)).action, + SubmitAction::Stop(Stop::Halted) + ); + let after = SubmitState { + plan: STRIPE, + phase: Phase::Send, + argument: 500, + }; + assert_eq!( + next_step(after, SubmitEvent::Granted(true)).action, + SubmitAction::Stop(Stop::Halted) + ); + } + #[test] fn an_unexpected_event_halts_without_io() { let decision = next_step(start(STRIPE), SubmitEvent::Write(WriteResult::Response)); diff --git a/product/runtime/auths-gateway-kernel/src/outcome.rs b/product/runtime/auths-gateway-kernel/src/outcome.rs index 9a323fb68..a7e0f5fb5 100644 --- a/product/runtime/auths-gateway-kernel/src/outcome.rs +++ b/product/runtime/auths-gateway-kernel/src/outcome.rs @@ -42,13 +42,14 @@ pub struct OutcomeFacts { pub relative_basis_digest: bool, } -/// Whether an outcome may name `stage`: every stage but `attempting`, which +/// Whether an outcome may name `stage`: every stage but `entry-granted`, which /// an outcome reports as `unknown`. #[must_use] pub const fn outcome_stage(stage: Stage) -> bool { match stage { - Stage::Attempting => false, - Stage::NotEntered + Stage::EntryGranted => false, + Stage::Reserved + | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded | Stage::Observed @@ -122,7 +123,7 @@ mod tests { ..NONE } )); - assert!(!outcome_facts_present(Stage::Attempting, NONE)); + assert!(!outcome_facts_present(Stage::EntryGranted, NONE)); } #[test] @@ -166,12 +167,13 @@ mod proofs { use super::*; fn any_stage() -> Stage { - match kani::any::() % 6 { - 0 => Stage::Attempting, + match kani::any::() % 7 { + 0 => Stage::EntryGranted, 1 => Stage::NotEntered, 2 => Stage::Unknown, 3 => Stage::ResponseRecorded, 4 => Stage::Observed, + 5 => Stage::Reserved, _ => Stage::ObservedByProvider, } } @@ -196,11 +198,11 @@ mod proofs { let pairs = facts.http_status == facts.response_digest && facts.relative_basis == facts.relative_basis_digest; let table = match stage { - Stage::Attempting => false, + Stage::EntryGranted => false, Stage::NotEntered => { facts.refusal && !facts.http_status && !facts.observation && !facts.evidence_digest } - Stage::Unknown => { + Stage::Reserved | Stage::Unknown => { !facts.refusal && !facts.http_status && !facts.observation && !facts.evidence_digest } Stage::ResponseRecorded => { diff --git a/product/runtime/auths-gateway-kernel/src/transition.rs b/product/runtime/auths-gateway-kernel/src/transition.rs index d5064a032..75ea3c4fc 100644 --- a/product/runtime/auths-gateway-kernel/src/transition.rs +++ b/product/runtime/auths-gateway-kernel/src/transition.rs @@ -17,8 +17,10 @@ use alloc::vec::Vec; /// The stage of an attempt record. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum Stage { - /// Claimed; transport may have been entered after the last checkpoint. - Attempting, + /// Capacity is reserved, but external entry is forbidden. + Reserved, + /// A unique durable grant exists; external entry may have occurred. + EntryGranted, /// Transport entry was excluded; terminal. NotEntered, /// Transport may have been entered and no complete response exists. @@ -60,6 +62,8 @@ pub enum Link { pub struct AttemptView { /// Canonical bytes of the fields no transition may change. pub fixed: Vec, + /// Immutable canonical grant/audit bytes; empty before entry. + pub entry: Vec, /// The stage. pub stage: Stage, /// Whether a refusal code is recorded. @@ -113,7 +117,7 @@ pub fn same_bytes(left: &[u8], right: &[u8]) -> bool { } } -/// Whether a link lets an `attempting` or `unknown` record reach +/// Whether a link lets an `entry-granted` or `unknown` record reach /// `observed-by-provider`: only a verified-locator link. #[must_use] pub const fn resolves_unknown(link: Link) -> bool { @@ -137,7 +141,8 @@ pub const fn has_link(link: Link) -> bool { pub const fn refusal_stage(stage: Stage) -> bool { match stage { Stage::NotEntered => true, - Stage::Attempting + Stage::Reserved + | Stage::EntryGranted | Stage::Unknown | Stage::ResponseRecorded | Stage::Observed @@ -150,7 +155,11 @@ pub const fn refusal_stage(stage: Stage) -> bool { pub const fn requires_response(stage: Stage) -> bool { match stage { Stage::ResponseRecorded | Stage::Observed => true, - Stage::Attempting | Stage::NotEntered | Stage::Unknown | Stage::ObservedByProvider => false, + Stage::Reserved + | Stage::EntryGranted + | Stage::NotEntered + | Stage::Unknown + | Stage::ObservedByProvider => false, } } @@ -159,7 +168,7 @@ pub const fn requires_response(stage: Stage) -> bool { pub const fn permits_response(stage: Stage) -> bool { match stage { Stage::ResponseRecorded | Stage::Observed | Stage::ObservedByProvider => true, - Stage::Attempting | Stage::NotEntered | Stage::Unknown => false, + Stage::Reserved | Stage::EntryGranted | Stage::NotEntered | Stage::Unknown => false, } } @@ -168,7 +177,8 @@ pub const fn permits_response(stage: Stage) -> bool { pub const fn observed_stage(stage: Stage) -> bool { match stage { Stage::Observed => true, - Stage::Attempting + Stage::Reserved + | Stage::EntryGranted | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded @@ -181,7 +191,8 @@ pub const fn observed_stage(stage: Stage) -> bool { pub const fn provider_stage(stage: Stage) -> bool { match stage { Stage::ObservedByProvider => true, - Stage::Attempting + Stage::Reserved + | Stage::EntryGranted | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded @@ -194,7 +205,7 @@ pub const fn provider_stage(stage: Stage) -> bool { pub const fn terminal_stage(stage: Stage) -> bool { match stage { Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider => true, - Stage::Attempting | Stage::Unknown | Stage::ResponseRecorded => false, + Stage::Reserved | Stage::EntryGranted | Stage::Unknown | Stage::ResponseRecorded => false, } } @@ -216,7 +227,8 @@ pub const fn has_reading(reading: Reading) -> bool { #[must_use] pub fn consistent(view: &AttemptView) -> bool { let has_response = !absent(&view.response); - refusal_stage(view.stage) == view.refusal + requires_entry(view.stage) == !absent(&view.entry) + && refusal_stage(view.stage) == view.refusal && (!requires_response(view.stage) || has_response) && (!has_response || permits_response(view.stage)) && (absent(&view.locator) || has_response) @@ -227,96 +239,72 @@ pub fn consistent(view: &AttemptView) -> bool { && (!view.evidence || has_response || resolves_unknown(view.link)) } -/// The closed stage table: which stage may follow which, given the stored -/// plan's link. `attempting → attempting` is the single checkpoint of -/// pre-entry evidence; an `attempting` or `unknown` record reaches -/// `observed-by-provider` only for a verified-locator link. +/// Whether the state requires an immutable entry grant. +#[must_use] +pub const fn requires_entry(stage: Stage) -> bool { + match stage { + Stage::Reserved | Stage::NotEntered => false, + Stage::EntryGranted + | Stage::Unknown + | Stage::ResponseRecorded + | Stage::Observed + | Stage::ObservedByProvider => true, + } +} + +/// The one transition table: a reservation cannot acquire response evidence +/// or become unknown until it has received a durable entry grant. #[must_use] pub const fn stage_transition_allowed(from: Stage, to: Stage, link: Link) -> bool { match from { - Stage::Attempting => match to { - Stage::Attempting | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded => { - true - } + Stage::Reserved => matches!( + to, + Stage::Reserved | Stage::NotEntered | Stage::EntryGranted + ), + Stage::EntryGranted => match to { + Stage::Unknown | Stage::ResponseRecorded => true, Stage::ObservedByProvider => resolves_unknown(link), - Stage::Observed => false, + _ => false, }, Stage::Unknown => match to { + Stage::ResponseRecorded => true, Stage::ObservedByProvider => resolves_unknown(link), - Stage::Attempting - | Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed => false, - }, - Stage::ResponseRecorded => match to { - Stage::Observed | Stage::ObservedByProvider => true, - Stage::Attempting | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded => { - false - } + _ => false, }, + Stage::ResponseRecorded => matches!(to, Stage::Observed | Stage::ObservedByProvider), Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider => false, } } -/// Whether a transition from `from` to `to` may add pre-entry evidence: -/// only the checkpoint and a refusal before transport entry. +/// Only a reservation may add pre-entry observations. #[must_use] pub const fn adds_pre_entry(from: Stage, to: Stage) -> bool { - match from { - Stage::Attempting => match to { - Stage::Attempting | Stage::NotEntered => true, - Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed - | Stage::ObservedByProvider => false, - }, - Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed - | Stage::ObservedByProvider => false, - } + matches!(from, Stage::Reserved) && matches!(to, Stage::Reserved | Stage::NotEntered) } -/// Whether a transition from `from` to `to` records the response. +/// Only an existing grant may acquire a late or immediate response. #[must_use] pub const fn adds_response(from: Stage, to: Stage) -> bool { - match from { - Stage::Attempting => match to { - Stage::ResponseRecorded => true, - Stage::Attempting - | Stage::NotEntered - | Stage::Unknown - | Stage::Observed - | Stage::ObservedByProvider => false, - }, - Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed - | Stage::ObservedByProvider => false, - } + matches!(from, Stage::EntryGranted | Stage::Unknown) && matches!(to, Stage::ResponseRecorded) } -/// Whether the checkpoint condition holds: `attempting → attempting` adds -/// pre-entry evidence exactly once and changes nothing else. +/// A reservation checkpoint adds its pre-entry record exactly once. #[must_use] pub fn checkpoint_valid(old: &AttemptView, new: &AttemptView) -> bool { - match old.stage { - Stage::Attempting => match new.stage { - Stage::Attempting => absent(&old.pre_entry) && !absent(&new.pre_entry), - Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed - | Stage::ObservedByProvider => true, - }, - Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::Observed - | Stage::ObservedByProvider => true, + if matches!(old.stage, Stage::Reserved) && matches!(new.stage, Stage::Reserved) { + absent(&old.pre_entry) && !absent(&new.pre_entry) + } else { + true + } +} + +/// Grant bytes are added only at the single reservation-to-entry transition. +#[must_use] +pub fn entry_kept(old: &AttemptView, new: &AttemptView) -> bool { + if matches!(old.stage, Stage::Reserved) && matches!(new.stage, Stage::EntryGranted) { + absent(&old.entry) && !absent(&new.entry) + } else { + same_bytes(&old.entry, &new.entry) } } @@ -371,7 +359,9 @@ pub const fn link_equal(left: Link, right: Link) -> bool { /// consistent with its stage. #[must_use] pub fn valid_transition(old: &AttemptView, new: &AttemptView) -> bool { - same_bytes(&old.fixed, &new.fixed) + consistent(old) + && entry_kept(old, new) + && same_bytes(&old.fixed, &new.fixed) && plan_kept(old, new) && stage_transition_allowed(old.stage, new.stage, old.link) && checkpoint_valid(old, new) @@ -385,8 +375,9 @@ mod tests { use super::*; use alloc::vec; - const STAGES: [Stage; 6] = [ - Stage::Attempting, + const STAGES: [Stage; 7] = [ + Stage::Reserved, + Stage::EntryGranted, Stage::NotEntered, Stage::Unknown, Stage::ResponseRecorded, @@ -401,6 +392,11 @@ mod tests { Vec::new() }; AttemptView { + entry: if requires_entry(stage) { + alloc::vec![7] + } else { + Vec::new() + }, fixed: vec![7; 4], stage, refusal: refusal_stage(stage), @@ -439,7 +435,8 @@ mod tests { let allowed = valid_transition(&view(Stage::Unknown, link), &view(to, link)); assert_eq!( allowed, - to == Stage::ObservedByProvider && link == Link::Verified, + to == Stage::ResponseRecorded + || (to == Stage::ObservedByProvider && link == Link::Verified), "{link:?} {to:?}" ); } @@ -448,7 +445,7 @@ mod tests { #[test] fn checkpoint_adds_pre_entry_once_and_changes_nothing_else() { - let old = view(Stage::Attempting, Link::Verified); + let old = view(Stage::Reserved, Link::Verified); let mut checkpoint = old.clone(); checkpoint.pre_entry = vec![9]; assert!(valid_transition(&old, &checkpoint)); @@ -469,7 +466,16 @@ mod tests { !valid_transition(&old, &responded), "added only before entry" ); - assert!(valid_transition(&checkpoint, &responded)); + assert!(!valid_transition(&checkpoint, &responded)); + let mut grant = view(Stage::EntryGranted, Link::Verified); + grant.pre_entry = checkpoint.pre_entry.clone(); + assert!(valid_transition(&checkpoint, &grant)); + assert!(valid_transition(&grant, &responded)); + assert!(!valid_transition(&grant, &refused)); + assert!(!valid_transition(&grant, &grant), "no second grant"); + let mut changed = responded.clone(); + changed.entry = vec![8]; + assert!(!valid_transition(&grant, &changed), "grant is immutable"); } #[test] @@ -483,7 +489,7 @@ mod tests { let mut changed = view(Stage::Observed, Link::AfterResponse); changed.response = vec![2]; assert!(!valid_transition(&old, &changed)); - let attempting = view(Stage::Attempting, Link::AfterResponse); + let attempting = view(Stage::EntryGranted, Link::AfterResponse); assert!(!valid_transition( &attempting, &view(Stage::ObservedByProvider, Link::AfterResponse) @@ -500,12 +506,13 @@ mod proofs { use alloc::vec::Vec; fn any_stage() -> Stage { - match kani::any::() % 6 { - 0 => Stage::Attempting, + match kani::any::() % 7 { + 0 => Stage::EntryGranted, 1 => Stage::NotEntered, 2 => Stage::Unknown, 3 => Stage::ResponseRecorded, 4 => Stage::Observed, + 5 => Stage::Reserved, _ => Stage::ObservedByProvider, } } @@ -539,6 +546,7 @@ mod proofs { fn any_view() -> AttemptView { AttemptView { + entry: any_bytes(), fixed: any_bytes(), stage: any_stage(), refusal: kani::any(), @@ -557,16 +565,20 @@ mod proofs { matches!( (from, to), ( - Stage::Attempting, - Stage::Attempting | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded + Stage::EntryGranted, + Stage::Unknown | Stage::ResponseRecorded ) | ( - Stage::ResponseRecorded, - Stage::Observed | Stage::ObservedByProvider - ) + Stage::Reserved, + Stage::Reserved | Stage::NotEntered | Stage::EntryGranted + ) | (Stage::Unknown, Stage::ResponseRecorded) + | ( + Stage::ResponseRecorded, + Stage::Observed | Stage::ObservedByProvider + ) ) || (matches!( (from, to), ( - Stage::Attempting | Stage::Unknown, + Stage::EntryGranted | Stage::Unknown, Stage::ObservedByProvider ) ) && link == Link::Verified) @@ -578,7 +590,7 @@ mod proofs { let reading = view.reading != Reading::None; let shape = match view.stage { Stage::NotEntered => view.refusal && !response && !reading && !view.evidence, - Stage::Attempting | Stage::Unknown => { + Stage::Reserved | Stage::EntryGranted | Stage::Unknown => { !view.refusal && !response && !reading && !view.evidence } Stage::ResponseRecorded => !view.refusal && response && !reading && !view.evidence, @@ -593,7 +605,9 @@ mod proofs { && (response || view.link == Link::Verified) } }; - shape && (view.locator.is_empty() || response) + shape + && (view.locator.is_empty() || response) + && (matches!(view.stage, Stage::Reserved | Stage::NotEntered) == view.entry.is_empty()) } /// Exhaustive over every stage, link, and reading pair: the closed stage @@ -625,19 +639,29 @@ mod proofs { let old = any_view(); let new = any_view(); let pre_entry = match (old.stage, new.stage) { - (Stage::Attempting, Stage::Attempting) => { + (Stage::Reserved, Stage::Reserved) => { old.pre_entry.is_empty() && !new.pre_entry.is_empty() } - (Stage::Attempting, Stage::NotEntered) => { + (Stage::Reserved, Stage::NotEntered) => { old.pre_entry.is_empty() || old.pre_entry == new.pre_entry } _ => old.pre_entry == new.pre_entry, }; let response = matches!( (old.stage, new.stage), - (Stage::Attempting, Stage::ResponseRecorded) + ( + Stage::EntryGranted | Stage::Unknown, + Stage::ResponseRecorded + ) ) || (old.response == new.response && old.locator == new.locator); + let entry = if old.stage == Stage::Reserved && new.stage == Stage::EntryGranted { + old.entry.is_empty() && !new.entry.is_empty() + } else { + old.entry == new.entry + }; let expected = old.fixed == new.fixed + && entry + && fields_match_stage(&old) && old.observation == new.observation && old.link == new.link && table(old.stage, new.stage, old.link) diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-refund-5-window b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-not-entered-refund-5-window similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-refund-5-window rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-not-entered-refund-5-window diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-refund-1 b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-response-recorded-refund-1 similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-refund-1 rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-response-recorded-refund-1 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-refund-4 b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-response-recorded-refund-4 similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-refund-4 rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-record-response-recorded-refund-4 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-not-entered-refund-5-window b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-not-entered-refund-5-window similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-not-entered-refund-5-window rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-not-entered-refund-5-window diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-response-recorded-refund-1 b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-response-recorded-refund-1 similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-response-recorded-refund-1 rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-response-recorded-refund-1 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-response-recorded-refund-4 b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-response-recorded-refund-4 similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-attempting-to-response-recorded-refund-4 rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/obsolete-transition-attempting-to-response-recorded-refund-4 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry new file mode 100644 index 000000000..5912259f9 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -0,0 +1 @@ +{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry new file mode 100644 index 000000000..1819a947c --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -0,0 +1 @@ +{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry new file mode 100644 index 000000000..36f0d0a5b --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -0,0 +1 @@ +{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry new file mode 100644 index 000000000..32698c165 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -0,0 +1 @@ +{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry new file mode 100644 index 000000000..31848cb65 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -0,0 +1 @@ +{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry new file mode 100644 index 0000000000000000000000000000000000000000..aa92b1f6669c7bd2264112d4cdf2d4f23d3ba236 GIT binary patch literal 5287 zcmeHKT~FjT6y4|kgg)lk!`RNJd7~|quBz?=tFBZAMULaln9U?1$qcZF|K4*mAFzYe z57BB{X$X?z_}V_c=iKW%Z{B?K?St2unVoCz(9?^4)*VcBZ*TSeNcX*+H~l#Dn3uUK zchxjCx~eN@bP4N+iKk8P>T2R0UJAkf&HpQg&6=jIm%2=wx^(6qyAp!oqiqR;^d*xb zVM;L(1x!dZ5fgsMBgZ(F-y@Nw0-Xp%5dfvElzy*+B_|+DLHT`H~F_sf=m{1jNx@h&r zqny3!Az-GiDr~i;=vB+H;iRUuxvhE!5~jAYTd)F~*`_u#xPjg)J-1z>jUC*gUEAxd zw4>b4>*25!PPw!x`K4}MPh4L91MuqR3DU&t?yG)gduK*~++q&^YjoSYwL>OeZ@Yf< z>=PNZbzhsh1R|(w%j|s7uZe+8Yi|~qNud3NNgoP?rkXS|`wwWU*p0 zAoD?3B)5PB3PnX|!w91+M9)_sUc?kniqR06M(9TTij;M;(4{L7gLI6iSeSTqLtiwY z4;YPW$o-ch!KS2tU_dAc<&*AZ2<-VXP@D*<$g!qEgh*S}RH{uLN#I6i{^0&Qf9C%1I=~cvvbM8mLfFP~= zG_ytBlB-uE7^IOG91V$W&CzJ%`mtE0y3S1z&x_WkSrlNYiFf*L?!Q0z`MkU4yJ0(FQ1~BJc>@<=3#nve13Lcp8M7JCt`LTz5keq+xzA5=(dBg+5jWk7MR1q3uwe@)v z<${h`SH==Lj<}V+9|U0-MRA-YN@<;8hdj5?7ECSf#0Bo`92|c^q}TO&N{bBnZ!~Rn z1uL3C`4Hi?d-JbvreSzYDArS6EW9#YdD&_%O_C!`NX3n>;#{gA2hJk#<2Vqa(6N%S zFku)<5zA0y(g>ABDh~@=_}C`5jjeF87-u_56OW)W+oq1RDRo6?aaBwm-n?1gH{IcQ ztQ&W*(ZB&n#ZsM}60fw(!;rpV4*A#RayU7;iafI9xTXKd03!czeDQ$-V)zq(V&7-w z-?E2fcI~g2H?umo?cf9EU3Wu%cOb0=2QJ6csKNLWlILit4;o Usk1G_xq97$I%;2te*Hr9cf)ZU0<>R znigr%KCEqkB4ma z^UK_5-*{(q4ei@Spv~YKzX*;lgkb;X-+PA3+O})1be*?N?aT(Zk_FSE?Z^fhN+w0d zlwu-@n2;C}Cc>CW&M}RcjG=*1L6l}JB_&9Bh7p<~g=WOkkO?{iLnc_3vLs~KfcHr# zayk-6(U@{F>;s&G`xk+|fkPI-9o9^=a+G6YAq^vH-f2n4Pe*rj5&;|aJVS*n8;^IDwSKn1u?!i!x^@*}ke=}v3yYv>X+^{I z$wuQ^a{qBQ!+hcQN$2E#CM7p5p(Q8+|U@3sW4AO40}jl z5&f~3;wDxUP1|UI0tE<774fgLz3r|hLwhoX*0#w8v-_|pn$efDZBXoDp*KJhDo+s@ z{j`ceySqa|dPoL)8R-$5|4DM#K8#*3i4AZKTq-z&|06hCvKWq(F-=l@k+b1a0a8u) zgF^&8B!ECrN>VAyu!=7LLU@5{1geOE8({_|LRUs1`P<&K4mjkR_$pGxIS&)qfFNy# zys%Z%k*l{72ubo8MpI(jVKlpU{akEQUGJ8N=drVSkwiFZ5xji84&R*oeAZv`dUZbj z`s2s?mk-HG9w#TS$~ZrLadx_?&qDwGiCA4GZ{B6%dUN$+_UiPzV=*&lFFW79{{6T9 zr+T=4xs1Bm^*bkzuW=iIe@HDtjfiw*RcLscNF#X>XQ@g|S!rvOEE66XZltLaqpH{#t8K`W zq!jeb#v4o4am1|*!zha5BuUdOQ%dUsHPYA#cs=I2X7U(UbdP`la)vlQgIWiw3I3;VP}YwgKel!~RpSFjp}wm+KB zb?ctrbKp5Z#ZkRo60UU2?UcTu4*ECs)%0?56?x=}qe}mo0!aS$#razbi0MasL4PRf zzoie#?CZa0!OH5=c9RcSaM@4!-2t=?CeJHp>$0E!fFgR1YBctQefLzPu0s literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry new file mode 100644 index 0000000000000000000000000000000000000000..686d7a84945c2dc7bebe49bc7f3479f3ded9158f GIT binary patch literal 5021 zcmeHK+iu)85Y20UL(g06h-Ya(MpO$`H~>$ulJ0!zQh6A z6mHQxtk(cVaY!D{IWrtRdGg&KAA`Yc>{bVdfgb&4I9O|MFZK08dvCX$U&a9o3fGjb zS?5MKZR3otVf}FxXyaYmtb)TcA=rQUf6lO3*Y)j%uJf*~ow>%YgkXAUd%_??$)w1b zQcNTf6B13rL>M#4Il2*(F)Yw345b-M$p|AnLkmlh!ZKoM$ONr{CKD`6SrRf#!1*K$ zIW38$s7*Nmdk5!W|5aeG;E+}D3GYn1?OZ+K0?5z&YOBf`zqqkj%2hB;XezfJdwt_k z&K~t6V5V&vY_+54QOmLEq^7r}ZM*{sYungcumYRet~DFDfu0+^wL_rR|+3F3m>;Yh%?!DVNWEFTj_{F_f zWYD+1HEj(5R{Ts$}+sg69^%`AT=UY#NdrMgAuVSqmcY{_^--jJ0amjn`QARn(Co`Q|{-Eg>E>dqb9IQjsd!y>s(6L@sq4pS0!jki4@ zFDqy3a#;R|o9Y!({y31&t~%VJIND*b3XbN219=D|TYcrW<2HwbyS5n+0oS-wKtd8` z5hj{Viwym6@u?ihX%M+=Uw-Y&udk`}D3|Zcuer3@mtXtx>np#__T|^U{QAGkuc_u* ztb2_j<6aH+#mzr!b^cmiQW3bD@`hMmq?QC7myu(W&*njzV#jsh^wDnpQSyLBQZ?G#N7+#u|Fi2lADH4{Z zOhf?_5>3Q}A2P`~x&f0REYPMHiW3%-5k`1|7M3E0Wx!&e30eb9B3Kf$$Y+><^GO(T zS`tf98*>8o3C_X(Gtb~})0I){2&Tbtt^PK724S zXlqyNx&R`mYsYNayDc%WY0XWKnFQKTnDn8MQ632i2Z6v-26d$&+v)^bk}OV{49I*C z7RfCjfkIIc+AzW>3(@ma5HDhir#sS&9n1aHI{jEG$s_~dVM*I4k7DblNmQ_i^`0Rw`xcG=u4 z>XuwRj$n{R{>0Ic*tQ%^9$h~bW2)=y67k%(CYwhAmYR8|?@Isu$xr9qH7`~d{VzY< z6hD88R`Mu1d7FpX+41?=ra1Sj?@q+(I(q*x5x1N5@#O8j$r1OO`I+c0E1I@M6i%6%7P-~-%&!Z?8 zbj-TahR|`ut@QmM2*W6f<0MH_rRLZn&keK%Q-eFP$DN&nduyZnZdzLU3G|n4ek_>5cx@f ziF#EdL%&>nC<{_pY&g*JVH j8hkvztiW2c=)2*+DfBIRFqY$!Wvft{?(4I!p+5Tq(fDqW literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs index 9c186ae29..702bc6aab 100644 --- a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs +++ b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs @@ -23,22 +23,25 @@ const fn listed(from: Stage, to: Stage) -> bool { matches!( (from, to), ( - Stage::Attempting, - Stage::Attempting - | Stage::NotEntered - | Stage::Unknown - | Stage::ResponseRecorded - | Stage::ObservedByProvider - ) | (Stage::Unknown, Stage::ObservedByProvider) - | ( - Stage::ResponseRecorded, - Stage::Observed | Stage::ObservedByProvider - ) + Stage::Reserved, + Stage::Reserved | Stage::EntryGranted | Stage::NotEntered + ) | ( + Stage::EntryGranted, + Stage::Unknown | Stage::ResponseRecorded | Stage::ObservedByProvider + ) | ( + Stage::Unknown, + Stage::ResponseRecorded | Stage::ObservedByProvider + ) | ( + Stage::ResponseRecorded, + Stage::Observed | Stage::ObservedByProvider + ) ) } -const FIXED: [&str; 8] = [ +const FIXED: [&str; 10] = [ "schema", + "binding_canonical", + "approval_canonical", "namespace", "operation_id", "action_commitment", @@ -68,6 +71,9 @@ fuzz_target!(|data: &[u8]| { ) else { panic!("valid records are JSON"); }; + if from != Stage::Reserved || to != Stage::EntryGranted { + assert_eq!(old.get("entry"), new.get("entry"), "entry grant changed"); + } for field in FIXED { assert_eq!(old.get(field), new.get(field), "{field} changed"); } diff --git a/product/runtime/auths-gateway/fuzz/tests/corpus.rs b/product/runtime/auths-gateway/fuzz/tests/corpus.rs index ca4e00b5d..80d7e45fe 100644 --- a/product/runtime/auths-gateway/fuzz/tests/corpus.rs +++ b/product/runtime/auths-gateway/fuzz/tests/corpus.rs @@ -97,11 +97,26 @@ fn request_seeds_build_a_closed_request() { #[test] fn attempt_seeds_are_records_and_valid_transitions() { for (name, data) in seeds("target_gateway_attempt") { + if name.starts_with("obsolete-transition-") { + let (old, new) = split(&data); + assert!(fuzzing::attempt_stage(old).is_none(), "obsolete {name}"); + assert!(fuzzing::attempt_stage(new).is_none(), "obsolete {name}"); + continue; + } + if name.starts_with("obsolete-record-") { + assert!(fuzzing::attempt_stage(&data).is_none(), "obsolete {name}"); + continue; + } + if name.starts_with("transition-") { let (old, new) = split(&data); assert_eq!( fuzzing::attempt_stage(old), - Some(GatewayAttemptStage::Attempting), + Some(if name.starts_with("transition-reserved-") { + GatewayAttemptStage::Reserved + } else { + GatewayAttemptStage::EntryGranted + }), "{name}" ); assert_eq!(fuzzing::attempt_transition(old, new), Some(true), "{name}"); diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 3d4ac5803..4ba0e1c2c 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"fab29da3269438cc62330f3eab7b5bd4dc482b4db8af243aae47df5d3aa1deb8"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"76ebf2ecc2cc6188c7e4867cd765c710168753004d4a1394315634c10a095664"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"0418fd85dd7124c1cc1a644e537af889f102992052a36c3374c71457c3414b86"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"e8d24277d7e4a53610e091fe78b373b841245d8e59a2bc788716b76e7d912441"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a7d97bf32205b51eadb52daa9076c6bdbc81e210e34edc8d37128aa00f0a3f3f"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"77e6e41a0ec253fa8636b5eae4838da9e09bb669a1cd1133e47eb7e43c523003"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"526273edfcb6bba88896f4e715368024661896eed6f56eb75a0f9f0d946e3eb1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"562ffcaea071c3856e0708dc2fe33516917e145d2438aabb75af0a2b6ba01046"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2dbece190c23e2960f89d0d60abb941e4d88a8929675f6117ee11f886f48a2ad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"c1e2ac312bc93cc1851a17723730f2e1ef6d90abfd17b66d956891104924d67f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"77dddf1f426441d759deb8844a8a58fc0ddfb915d09e3dbc22a808ec3aa19051"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a271fa896059c2c6b05a146a72b4ef0eb14ef5876422f224bb82ed607263caa1"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"21f38bc74329bb6868095e564c844ac24e2e4c51cf656d54cc8efe4c88b2182c"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"6f07a18366d8ab111458e274c3c36e215ccebf3d82a9c63d506a68fa1f752b13"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d5b7db992f8ea4c669cb083a213b5e24871e71bc7eb4dc5d5503e9b7e3ef870a"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"455c1a2fe7a9ac2a916f75c95203a3f83f6d39800517dc8aecb85976a0683576"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"b0ca0fb6291a4e9e6aa5cdaae4c66d2948fcf8acc41bc728cb13743d01537b37"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"9fd979029793a22b15d9776a7fc172476fd7c126a80d4080c65d720845becbcb"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"978fc9fb34a33b3db265b5d1c3ce11696a5b9f08529e46dd2a1e7bb62afb9220"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"fc7861008f4d0a991b7461cef2a9b6a872424f5b8f177561efd248f776bf8ab7"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"607c8538f98554238c1a0dd83e09c1da6198ae72e3ff5870fce93cd54a133445"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"b3cc4dab24c192dc1b2da74797f7be3e1d4d08ec9e6f02ddd7d96b86972df707"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"dd2c2ec65ce92b260d3391fcdc633320940d21dfe2640164d768908b1db5b6de"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3146ff7ac9fb9db2cd6f56a04ae4a53d4d83e772c322fb6373bcc455fe854bc0"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"b72cc8e8a17548c92e0300e27191ee311d3b6ee935d3fe68f7ef973c75b8411f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2a870baff07f28ef5b38d3111771c744390684feda7a78046d960c6e2bc50c18"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"1293a51118855763f232dc3c143ee4917fe291429e6bbc400f722e3aa23faced"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"83f66e6a1436ef9277ed96ffca24dc2c514f00cd66957a6e696ccb21bb741c2e"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"9625881fb44399a3a1af8d5d57eb9932b2893767b0fcfcb7a853b891852af1ec"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36a740907783c636934d3cdf95d7c53dc04e7752e440f6ce4ca06adb85ce0012"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"91d5179cd0c6dd34212f9231294a1f603490d3db2d54416f288bf64f6c857744"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ee714dd929994be0ad87e6025e7509c1bb5fadaa5caad278df351077bb27548"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/commissioning_budget.rs b/product/runtime/auths-gateway/src/commissioning_budget.rs index c36ae65a9..62b88739e 100644 --- a/product/runtime/auths-gateway/src/commissioning_budget.rs +++ b/product/runtime/auths-gateway/src/commissioning_budget.rs @@ -177,6 +177,31 @@ impl CommissioningBudgetSnapshot { Ok(()) } + pub(crate) fn entry_state( + &self, + floor: &Self, + now: u64, + state: &VerifierState, + ) -> Result { + if !self.not_below(floor) + || floor.record.consumed_credential_leases == 0 + || now < self.record.latest_verifier_time + { + return Err(CommissioningBudgetRefusal::Rollback); + } + let mut memory = crate::configuration::QualificationMemory::default(); + memory.merge(state); + memory.merge(&VerifierState { + accepted_revocation_sequence: self.record.accepted_revocation_sequence, + revoked_signers: self.record.revoked_signers.clone(), + ..VerifierState::default() + }); + if memory.blocked { + return Err(CommissioningBudgetRefusal::Corrupt); + } + Ok(memory.state()) + } + pub(crate) fn not_below(&self, floor: &Self) -> bool { self.record.budget_scope_sha256 == floor.record.budget_scope_sha256 && self.record.budget_binding_sha256 == floor.record.budget_binding_sha256 @@ -224,6 +249,9 @@ pub struct CommissioningBudget { } impl CommissioningBudget { + pub(crate) fn key(&self) -> GatewayAttemptKey { + self.key + } /// Names the stable run/family key and its immutable reviewed binding. /// /// # Errors diff --git a/product/runtime/auths-gateway/src/commissioning_session.rs b/product/runtime/auths-gateway/src/commissioning_session.rs index 971da6562..d6ab031d0 100644 --- a/product/runtime/auths-gateway/src/commissioning_session.rs +++ b/product/runtime/auths-gateway/src/commissioning_session.rs @@ -54,10 +54,66 @@ pub struct CommissioningSession<'a> { /// Obtained only from exact authorized branches and the closed verified request. pub(super) struct CommissionedAction { + claimed: OnceLock, principal_sha256: Sha256Digest, canonical_action_sha256: Sha256Digest, } +// Owned authenticated inputs for re-evaluation inside the attempt fence. +// It performs no budget allocation or local floor I/O. +pub(crate) struct EntryAuthority { + authority: VerifiedCommissioningPermit, + tuple: QualificationTuple, + protected_run: BoundedText<256>, + principal: Sha256Digest, + action: Sha256Digest, + trust: Sha256Digest, + resources: Sha256Digest, + pub(crate) budget_key: crate::GatewayAttemptKey, + claimed: crate::commissioning_budget::CommissioningBudgetSnapshot, +} + +impl EntryAuthority { + pub(crate) fn check( + &self, + gate: &crate::qualification::FencedQualification, + budget: &[u8], + ) -> Result<(), &'static str> { + let (now, trusted) = (gate.now, gate.trusted); + let current = + crate::commissioning_budget::CommissioningBudgetSnapshot::from_canonical_json( + budget, + &self.authority.permit().body().statement.binding, + ) + .map_err(CommissioningBudgetRefusal::code)?; + let state = current + .entry_state(&self.claimed, now, &gate.state) + .map_err(CommissioningBudgetRefusal::code)?; + self.authority + .evaluate( + &CommissioningRequest { + source_commit: &self + .authority + .permit() + .body() + .statement + .binding + .source_commit, + tuple: &self.tuple, + protected_run: &self.protected_run, + principal_sha256: self.principal, + trusted_context_sha256: self.trust, + resources_sha256: self.resources, + canonical_action_sha256: self.action, + }, + now, + trusted, + &state, + ) + .map_err(permit_code) + } +} + impl GatewayEngine { /// Authenticates a private commissioning session against installed trust. /// This does not initialize capacity or alter the ordinary application gate. @@ -227,6 +283,7 @@ impl CommissioningSession<'_> { return Err("gateway.commissioning.binding-mismatch"); }; let action = CommissionedAction { + claimed: OnceLock::new(), principal_sha256: commissioning_principal_sha256(actor), canonical_action_sha256: Sha256Digest::from_bytes(*command.request.action_commitment()), }; @@ -234,6 +291,27 @@ impl CommissioningSession<'_> { Ok(action) } + pub(super) fn entry_authority( + &self, + action: &CommissionedAction, + ) -> Result { + Ok(EntryAuthority { + budget_key: self.budget.key(), + claimed: action + .claimed + .get() + .cloned() + .ok_or("gateway.commissioning.registration-missing")?, + authority: self.authority.clone(), + tuple: self.tuple.clone(), + protected_run: self.protected_run.clone(), + principal: action.principal_sha256, + action: action.canonical_action_sha256, + trust: self.engine.trusted_context_sha256, + resources: self.resources_sha256, + }) + } + pub(super) fn check(&self, action: &CommissionedAction) -> Result<(), &'static str> { let (now, trusted) = self.engine.qualification.commissioning_time(); self.authority @@ -295,7 +373,13 @@ impl CommissioningSession<'_> { Some(refusal) => Err(refusal.code()), // A queued host lock or durable store write can outlast the permit // window. Capacity stays spent, but custody requires fresh time. - None => self.check(action), + None => { + action + .claimed + .set(update.snapshot().clone()) + .map_err(|_| "gateway.commissioning.binding-mismatch")?; + self.check(action) + } } } } diff --git a/product/runtime/auths-gateway/src/configuration.rs b/product/runtime/auths-gateway/src/configuration.rs index b28ddf24b..841b48b2d 100644 --- a/product/runtime/auths-gateway/src/configuration.rs +++ b/product/runtime/auths-gateway/src/configuration.rs @@ -162,6 +162,10 @@ impl SharedConfiguration { } } + pub(crate) fn key(&self) -> GatewayAttemptKey { + self.key + } + pub(crate) fn candidate(&self) -> [u8; 32] { self.installation } @@ -266,6 +270,15 @@ impl SharedConfiguration { .map_err(|_| CHANGED) } + pub(crate) fn entry_snapshot( + &self, + bytes: &[u8], + gate: &QualificationGate, + ) -> Result { + let record = decode(bytes, &self.installation)?; + gate.entry_snapshot(&record.qualification) + } + /// Validates an already fenced snapshot; performs no nested store read. pub(crate) fn check_snapshot( &self, diff --git a/product/runtime/auths-gateway/src/connection.rs b/product/runtime/auths-gateway/src/connection.rs index 15bda3cef..e35aa3391 100644 --- a/product/runtime/auths-gateway/src/connection.rs +++ b/product/runtime/auths-gateway/src/connection.rs @@ -54,6 +54,10 @@ pub struct LoadedConnection { } impl LoadedConnection { + pub(crate) fn private_bytes(&self) -> &[u8] { + &self.bytes + } + /// The decoded record. #[must_use] pub const fn record(&self) -> &ConnectionRecord { diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 9589cf5a1..1fac44300 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -48,7 +48,7 @@ use thiserror::Error; #[cfg(unix)] #[path = "commissioning_session.rs"] -mod commissioning; +pub(crate) mod commissioning; #[cfg(unix)] pub use commissioning::{ CommissioningSession, CommissioningSessionInputs, commissioning_principal_sha256, @@ -1545,6 +1545,39 @@ struct EngineIo<'a> { impl SubmitIo for EngineIo<'_> { type Lease = StoredSecretLease; + fn entry_validation(&self) -> Result { + let prepared = self.prepared.get().ok_or("gateway.entry.unprepared")?; + #[cfg(unix)] + let commissioning = self + .commissioning + .map(|session| { + self.commissioned_action + .get() + .ok_or("gateway.commissioning.binding-mismatch") + .and_then(|action| session.entry_authority(action)) + }) + .transpose()?; + Ok(crate::entry::EntryValidation::Installed(Box::new( + crate::entry::InstalledEntry { + recipe: self.engine.recipe.clone(), + trust: self.engine.trusted_context.clone(), + policy: self.engine.effect_policy.clone(), + configuration: self.engine.shared_configuration()?, + connection: prepared.loaded.clone(), + connection_key: crate::connection_key( + self.engine.connection.provider(), + self.engine.connection.alias(), + ), + qualification: Arc::clone(&self.engine.qualification), + workload: self.engine.workload_id.clone(), + profile: self.engine.profile.clone(), + started: self.started, + #[cfg(unix)] + commissioning, + }, + ))) + } + fn clock(&self) -> Option { self.engine.qualification.effect_time() } @@ -1720,7 +1753,7 @@ impl SubmitIo for EngineIo<'_> { async fn write( &self, lease: &StoredSecretLease, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { match self.prepared.get() { Some(prepared) => { @@ -1728,7 +1761,7 @@ impl SubmitIo for EngineIo<'_> { transport: &prepared.transport, lease, } - .write(request) + .write(permit) .await } None => Err(GatewayTransportError::NotEntered), diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs new file mode 100644 index 000000000..165049753 --- /dev/null +++ b/product/runtime/auths-gateway/src/entry.rs @@ -0,0 +1,146 @@ +//! Native final-entry validation over snapshots held by the attempt writer fence. +//! No credential, provider or nested store I/O occurs here. The installed +//! deployment clock retains its explicit platform trust assumptions. + +use crate::configuration::SharedConfiguration; +use crate::effect::{ApprovedEffect, EffectPolicy}; +use crate::{CompiledRecipe, GatewayAttemptKey, GatewayRecordKind, LoadedConnection}; +use auths_connections::ConnectionProfile; +use auths_model::TrustedContext; +use std::{ + sync::Arc, + time::{Duration, Instant}, +}; + +pub(crate) struct InstalledEntry { + pub(crate) recipe: CompiledRecipe, + pub(crate) trust: TrustedContext, + pub(crate) policy: EffectPolicy, + pub(crate) configuration: SharedConfiguration, + pub(crate) connection: LoadedConnection, + pub(crate) connection_key: GatewayAttemptKey, + pub(crate) qualification: Arc, + pub(crate) workload: String, + pub(crate) profile: ConnectionProfile, + pub(crate) started: Instant, + #[cfg(unix)] + pub(crate) commissioning: Option, +} + +pub(crate) enum EntryValidation { + Installed(Box), + /// A post-native driver oracle, never available in a production build. + #[cfg(any(test, feature = "testkit-harness"))] + Oracle { + now: u64, + }, +} + +impl EntryValidation { + pub(crate) fn dependencies(&self) -> Vec<(GatewayRecordKind, GatewayAttemptKey)> { + match self { + Self::Installed(entry) => { + let mut keys = vec![ + (GatewayRecordKind::Connection, entry.connection_key), + ( + GatewayRecordKind::EffectConfiguration, + entry.configuration.key(), + ), + ]; + #[cfg(unix)] + if let Some(authority) = &entry.commissioning { + keys.push((GatewayRecordKind::CommissioningBudget, authority.budget_key)); + } + keys + } + #[cfg(any(test, feature = "testkit-harness"))] + Self::Oracle { .. } => Vec::new(), + } + } + + /// Samples time after lock acquisition and re-runs native authority and + /// approval against the exact connection/configuration snapshots. + pub(crate) fn validate( + &self, + approved: &ApprovedEffect, + snapshots: &[Option>], + evaluated_at: u64, + ) -> Result { + match self { + Self::Installed(entry) => { + if snapshots.len() != self.dependencies().len() { + return Err("gateway.entry.dependencies-unavailable"); + } + let connection = snapshots[0] + .as_deref() + .ok_or("gateway.connection.unavailable")?; + if connection != entry.connection.private_bytes() { + return Err("gateway.connection.changed"); + } + let configuration = snapshots[1] + .as_deref() + .ok_or("gateway.configuration.unavailable")?; + let qualification = entry + .configuration + .entry_snapshot(configuration, &entry.qualification)?; + let now = qualification.now; + if now < evaluated_at + || now > evaluated_at.saturating_add(crate::recipe::ENTRY_DEADLINE_SECONDS) + || entry.started.elapsed() + > Duration::from_secs(crate::recipe::ENTRY_DEADLINE_SECONDS) + { + return Err("gateway.entry.deadline"); + } + if !crate::connection::authorizes_entry( + entry.connection.record(), + &entry.workload, + &entry.profile, + ) { + return Err("gateway.connection.unavailable"); + } + #[cfg(unix)] + match &entry.commissioning { + Some(authority) => authority.check( + &qualification, + snapshots + .get(2) + .and_then(Option::as_deref) + .ok_or("gateway.commissioning.registration-missing")?, + ), + None => qualification.check(), + }?; + #[cfg(not(unix))] + qualification.check()?; + approved + .validate_for_entry( + &entry.policy.installation( + &entry.recipe, + &entry.trust, + entry.connection.record(), + entry.qualification.policy(), + entry.configuration.candidate(), + ), + now, + ) + .map_err(|_| "gateway.effect.authority-unavailable")?; + Ok(now) + } + #[cfg(any(test, feature = "testkit-harness"))] + Self::Oracle { now } => { + if !snapshots.is_empty() + || *now < evaluated_at + || *now > evaluated_at.saturating_add(crate::recipe::ENTRY_DEADLINE_SECONDS) + { + return Err("test.entry.deadline"); + } + let key = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + approved + .validate_approval(&key, *now) + .map_err(|_| "test.entry.approval")?; + Ok(*now) + } + } + } +} diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs new file mode 100644 index 000000000..6fcf1b1ab --- /dev/null +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -0,0 +1,226 @@ +//! Native grant corpus and adapter conformance. Synthetic post-verification +//! commands exercise persistence, never claim installed resource authority. +use super::*; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; + +const NOW: u64 = 1_790_000_000; + +fn approved() -> Arc { + let recipe = crate::CompiledRecipe::compile( + include_bytes!("../../../../bindings/fixtures/gateway/airtable/recipe.json"), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), + ) + .expect("recipe"); + let arguments = serde_json::json!({ + "operation_id": "synthetic-entry", "record_id": "recTEST0000000001", "replacement": "Approved", + "operator_namespace": recipe.namespace().as_str(), "recipe_digest": recipe.digest_hex(), + }); + let command = crate::scenario_tests::admitted( + &recipe, + arguments.as_object().expect("arguments"), + [11; 32], + Vec::new(), + 60, + Vec::new(), + NOW, + ) + .expect("post-native command"); + Arc::new( + crate::effect::approve_driver_fixture(command, *recipe.digest(), NOW, None) + .expect("approval"), + ) +} + +async fn reserved( + attempts: &GatewayAttempts, + approved: &Arc, +) -> ClaimedGatewayAttempt { + let BoundedClaim::Claimed(claim) = attempts.claim_bounded(approved, NOW).await.expect("claim") + else { + panic!("claim refused") + }; + *claim +} + +fn stale_copy(claim: &ClaimedGatewayAttempt) -> ClaimedGatewayAttempt { + ClaimedGatewayAttempt { + attempt: Attempt { + store: Arc::clone(&claim.attempt.store), + key: claim.attempt.key, + stored: claim.attempt.stored.clone(), + record: claim.attempt.record.clone(), + }, + } +} + +#[tokio::test] +async fn native_entry_fixture_is_current() { + let store = TestAttempts::open(Backend::File); + let approved = approved(); + let claim = reserved(store.attempts(), &approved).await; + assert_eq!(claim.attempt.record.stage, GatewayAttemptStage::Reserved); + assert!(claim.attempt.record.entry.is_none()); + let stale = stale_copy(&claim); + let (granted, permit) = claim + .grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await + .expect("grant"); + assert_eq!( + granted.attempt.record.stage, + GatewayAttemptStage::EntryGranted + ); + assert_eq!(permit.request().body(), approved.command().request.body()); + let audit = serde_json::to_value(granted.attempt.record.entry.as_ref().expect("audit")) + .expect("audit JSON"); + drop(permit); // A crash before send still consumes the one grant. + assert!( + stale + .grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_err() + ); + let read = store + .reopen() + .read( + approved.command().request.namespace(), + approved.command().request.operation_id(), + ) + .await + .expect("read") + .expect("retained"); + assert_eq!(read.stage(), GatewayAttemptStage::Unknown); + let mut next = granted.attempt.record.clone(); + next.stage = GatewayAttemptStage::NotEntered; + next.refusal = Some("test.no-send".to_owned()); + assert!(!valid_transition(&granted.attempt.record, &next).expect("transition")); + // Canonical native records also seed the shipping decoder/transition fuzzer. + // The nonce is private replay evidence, independent of signed effect bytes; + // a fixed synthetic value makes the corpus reproducible. + let mut entry = granted.attempt.record.clone(); + entry.nonce = "00112233445566778899aabbccddeeff".to_owned(); + let mut reserved = entry.clone(); + reserved.stage = GatewayAttemptStage::Reserved; + reserved.entry = None; + let mut refused = reserved.clone(); + refused.stage = GatewayAttemptStage::NotEntered; + refused.refusal = Some("test.before-grant".to_owned()); + let mut unknown = entry.clone(); + unknown.stage = GatewayAttemptStage::Unknown; + let mut response = entry.clone(); + response.stage = GatewayAttemptStage::ResponseRecorded; + response.response_status = Some(200); + response.response_digest = Some(hex::encode([9; 32])); + let root = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/target_gateway_attempt"); + let write_seed = |name: &str, bytes: &[u8]| { + let path = root.join(name); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, bytes).expect("seed"); + } + assert_eq!(std::fs::read(path).expect("seed"), bytes); + }; + for (name, record) in [ + ("reserved", &reserved), + ("entry-granted", &entry), + ("not-entered", &refused), + ("unknown", &unknown), + ("response-recorded", &response), + ] { + record.snapshot(false).expect("valid native record"); + write_seed( + &format!("record-{name}-synthetic-entry"), + &encode(record).expect("encode"), + ); + } + for (name, old, new) in [ + ("reserved-to-entry-granted", &reserved, &entry), + ("reserved-to-not-entered", &reserved, &refused), + ("entry-granted-to-unknown", &entry, &unknown), + ("entry-granted-to-response-recorded", &entry, &response), + ] { + assert!(valid_transition(old, new).expect("transition")); + let old = encode(old).expect("old"); + let mut bytes = u32::try_from(old.len()) + .expect("bounded length") + .to_be_bytes() + .to_vec(); + bytes.extend_from_slice(&old); + bytes.extend_from_slice(&encode(new).expect("new")); + write_seed(&format!("transition-{name}-synthetic-entry"), &bytes); + } + let fixture = serde_json::to_vec_pretty(&serde_json::json!({ + "schema": "auths.effect-entry-fixture/1", + "scope": "native synthetic post-verification grant; no provider entry or installed authority claim", + "reserved_stage": "reserved", "granted_stage": "entry-granted", "restart_projection": "unknown", + "second_grant_refused": true, "post_grant_nonentry_refused": true, "entry_audit": audit, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/effect-entry.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} + +async fn grant_conformance(backend: Backend) { + let store = TestAttempts::open(backend); + let approved = approved(); + let claim = reserved(store.attempts(), &approved).await; + let stale = stale_copy(&claim); + let (left, right) = tokio::join!( + claim.grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: NOW } + ), + stale.grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: NOW } + ), + ); + assert_eq!( + usize::from(left.is_ok()) + usize::from(right.is_ok()), + 1, + "one acknowledged permit" + ); + let (claim, permit) = left.or(right).expect("winner"); + drop(permit); + assert!( + claim + .record_not_entered("test.no-send", None) + .await + .is_err(), + "even unsent grants retain uncertainty" + ); + let snapshot = store + .reopen() + .read( + approved.command().request.namespace(), + approved.command().request.operation_id(), + ) + .await + .expect("reopen") + .expect("retained"); + assert_eq!(snapshot.stage(), GatewayAttemptStage::Unknown); + assert!(matches!( + store.attempts().claim_bounded(&approved, NOW).await, + Err(GatewayAttemptError::Replay) + )); +} + +#[tokio::test] +async fn file_grant_has_one_winner_and_no_restart_permit() { + grant_conformance(Backend::File).await; +} + +#[tokio::test] +#[ignore = "requires the TLS PostgreSQL fixture"] +async fn postgres_grant_has_one_winner_and_no_restart_permit() { + assert!(postgres_configured()); + grant_conformance(Backend::Postgres).await; +} diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 5983a1449..942e9a96b 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -20,8 +20,8 @@ use crate::transport::{ GatewayTransportError, ProviderPort, ProviderResponse, WriteTransportOutcome, }; use crate::{ - ClosedCredentialRead, ClosedProviderRequest, CompiledRecipe, FileGatewayAttemptStore, - GatewayAttempts, GatewayObserver, RequestHeader, + ClosedCredentialRead, CompiledRecipe, FileGatewayAttemptStore, GatewayAttempts, + GatewayObserver, RequestHeader, }; use auths_codec::{encode_observation_requirements, evidence_id, grant_signing_preimage}; use auths_model::{ @@ -657,8 +657,9 @@ impl CountingProvider { impl ProviderPort for CountingProvider { async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { + let request = permit.request(); self.writes.fetch_add(1, Ordering::SeqCst); let body: Value = serde_json::from_slice(request.body()) .map_err(|_| GatewayTransportError::NotEntered)?; @@ -723,6 +724,12 @@ struct HarnessIo<'a> { impl SubmitIo for HarnessIo<'_> { type Lease = (); + fn entry_validation(&self) -> Result { + Ok(crate::entry::EntryValidation::Oracle { + now: self.clock().ok_or("test.clock")?, + }) + } + fn clock(&self) -> Option { Some(self.now) } @@ -795,9 +802,9 @@ impl SubmitIo for HarnessIo<'_> { async fn write( &self, _lease: &(), - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { - self.harness.provider.write(request).await + self.harness.provider.write(permit).await } async fn action_read( diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index af2b1c1a3..bd75c50ef 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -25,6 +25,7 @@ mod configuration; mod credential_journal; mod echo_verify; pub mod effect; +mod entry; mod engine; mod execution_witness; pub use execution_witness::GatewayExecutionWitness; diff --git a/product/runtime/auths-gateway/src/observer.rs b/product/runtime/auths-gateway/src/observer.rs index ef344294b..facb21daf 100644 --- a/product/runtime/auths-gateway/src/observer.rs +++ b/product/runtime/auths-gateway/src/observer.rs @@ -24,7 +24,7 @@ //! declares an echo field and the record carries one, `echo`; //! - `auths.gateway-outcome/2`, subject //! `auths-gateway:///operations/`, whose facts -//! are the stored attempt's commitment, stage (a stored `attempting` is +//! are the stored attempt's commitment, stage (a stored `entry-granted` is //! reported as `unknown`), evaluation time, and recipe digest, and, as the //! record holds them, its counter-set digest, refusal, response status and //! digest, read-back comparison, evidence digest, pre-entry digest, and @@ -522,11 +522,11 @@ fn bytes_fact(value: &[u8; 32]) -> Result { .map_err(|_| GatewayObserverError::Unrepresentable) } -/// The stage an outcome names for a stored stage: a stored `attempting` +/// The stage an outcome names for a stored stage: a stored `entry-granted` /// record is reported as `unknown`, because transport may have been entered. const fn outcome_stage(stage: GatewayAttemptStage) -> GatewayAttemptStage { match stage { - GatewayAttemptStage::Attempting => GatewayAttemptStage::Unknown, + GatewayAttemptStage::EntryGranted => GatewayAttemptStage::Unknown, other => other, } } @@ -534,7 +534,8 @@ const fn outcome_stage(stage: GatewayAttemptStage) -> GatewayAttemptStage { const fn kernel_stage(stage: GatewayAttemptStage) -> Stage { match stage { GatewayAttemptStage::NotEntered => Stage::NotEntered, - GatewayAttemptStage::Attempting => Stage::Attempting, + GatewayAttemptStage::Reserved => Stage::Reserved, + GatewayAttemptStage::EntryGranted => Stage::EntryGranted, GatewayAttemptStage::ResponseRecorded => Stage::ResponseRecorded, GatewayAttemptStage::Unknown => Stage::Unknown, GatewayAttemptStage::Observed => Stage::Observed, @@ -545,7 +546,8 @@ const fn kernel_stage(stage: GatewayAttemptStage) -> Stage { fn stage_name(stage: GatewayAttemptStage) -> &'static str { match stage { GatewayAttemptStage::NotEntered => "not-entered", - GatewayAttemptStage::Attempting => "attempting", + GatewayAttemptStage::Reserved => "reserved", + GatewayAttemptStage::EntryGranted => "entry-granted", GatewayAttemptStage::ResponseRecorded => "response-recorded", GatewayAttemptStage::Unknown => "unknown", GatewayAttemptStage::Observed => "observed", @@ -555,6 +557,7 @@ fn stage_name(stage: GatewayAttemptStage) -> &'static str { fn parse_stage(name: &str) -> Option { Some(match name { + "reserved" => GatewayAttemptStage::Reserved, "not-entered" => GatewayAttemptStage::NotEntered, "unknown" => GatewayAttemptStage::Unknown, "response-recorded" => GatewayAttemptStage::ResponseRecorded, @@ -571,7 +574,7 @@ fn parse_stage(name: &str) -> Option { pub(crate) struct OutcomeRecord { /// Lowercase hex of the stored action commitment. pub(crate) commitment: String, - /// The stage the outcome names; never `attempting`. + /// The stage the outcome names; never `entry-granted`. pub(crate) stage: GatewayAttemptStage, /// The gateway clock when native verification ran. pub(crate) evaluated_at: u64, @@ -709,7 +712,7 @@ impl OutcomeRecord { fn from_facts(facts: &[ObservationFact]) -> Option { let mut record = Self { commitment: String::new(), - stage: GatewayAttemptStage::Attempting, + stage: GatewayAttemptStage::EntryGranted, evaluated_at: 0, recipe_digest: String::new(), counters_digest: None, diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index a03c2bb14..f1f426219 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -20,7 +20,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/4"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/5"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; @@ -167,13 +167,14 @@ fn plain_response(key: &str, status: u16, body: Value) -> Value { setup } -const FULL: [&str; 4] = [ - "attempting", - "attempting", +const FULL: [&str; 5] = [ + "reserved", + "reserved", + "entry-granted", "response-recorded", "observed-by-provider", ]; -const REFUSED_AFTER_BASIS: [&str; 2] = ["attempting", "not-entered"]; +const REFUSED_AFTER_BASIS: [&str; 2] = ["reserved", "not-entered"]; fn relative_ceiling_cases() -> Vec { let intent = format!("GET /v1/payment_intents/{INTENT}"); @@ -250,7 +251,7 @@ fn relative_ceiling_cases() -> Vec { } fn credential_cases() -> Vec { - let refused = ["attempting", "not-entered"]; + let refused = ["reserved", "not-entered"]; let version = plain_response("GET /v1/customers", 403, Value::Null); vec![ scenario( @@ -389,7 +390,7 @@ fn pre_entry_cases() -> Vec { "pre-entry-replaced-after-observation", "airtable-pre-entry", plain_response(&record, 200, json!({"fields": {"DemoStatus": "Approved"}})), - &["attempting", "not-entered"], + &["reserved", "not-entered"], Some("gateway.pre-entry.condition-false"), &counts(1, 0, 1, 0), ); @@ -410,7 +411,7 @@ fn pre_entry_cases() -> Vec { "pre-entry-unavailable", "airtable-pre-entry", plain_response(&record, 404, Value::Null), - &["attempting", "not-entered"], + &["reserved", "not-entered"], Some("gateway.pre-entry.unavailable"), &counts(1, 0, 1, 0), ), @@ -435,7 +436,7 @@ fn pre_entry_cases() -> Vec { fn entry_and_recovery_cases() -> Vec { let none: [&str; 0] = []; - let refused_at_entry = ["attempting", "attempting", "not-entered"]; + let refused_at_entry = ["reserved", "reserved", "not-entered"]; vec![ scenario( "idempotency-window-exceeds-retention", @@ -465,15 +466,15 @@ fn entry_and_recovery_cases() -> Vec { "transport-not-entered", "stripe", json!({"write_transport": "refused-before-send"}), - &refused_at_entry, - Some("gateway.transport.not-entered"), + &["reserved", "reserved", "entry-granted", "unknown"], + None, &counts(1, 3, 1, 0), ), scenario( "response-locator-unknown-stays-unknown", "stripe", json!({"write_transport": "timeout-after-send", "replay": "fresh-proof"}), - &["attempting", "attempting", "unknown"], + &["reserved", "reserved", "entry-granted", "unknown"], None, &counts(1, 3, 1, 1), ), @@ -481,7 +482,7 @@ fn entry_and_recovery_cases() -> Vec { "linked-attempting-reobserved", "airtable", json!({"crash": "after-write-before-response", "replay": "same-binding"}), - &["attempting", "observed-by-provider"], + &["reserved", "entry-granted", "observed-by-provider"], None, &counts(2, 0, 1, 1), ), @@ -490,12 +491,12 @@ fn entry_and_recovery_cases() -> Vec { /// The `/2` record scenarios: id, transition, and provider entries. const RECORD_CASES: &[(&str, &str, u64)] = &[ - ("first-claim", "unclaimed->attempting", 0), - ("same-id-fresh-challenge", "attempting->binding-conflict", 0), - ("changed-action-same-id", "attempting->binding-conflict", 0), - ("crash-after-claim", "attempting->unknown-on-restart", 0), - ("complete-http-response", "attempting->response-recorded", 1), - ("ambiguous-transport", "attempting->unknown", 1), + ("first-claim", "unclaimed->reserved", 0), + ("same-id-fresh-challenge", "reserved->binding-conflict", 0), + ("changed-action-same-id", "reserved->binding-conflict", 0), + ("crash-after-claim", "reserved->reserved-on-restart", 0), + ("complete-http-response", "entry-granted->response-recorded", 1), + ("ambiguous-transport", "entry-granted->unknown", 1), ("matching-read-back", "response-recorded->observed-match", 1), ( "mismatching-read-back", diff --git a/product/runtime/auths-gateway/src/property_tests.rs b/product/runtime/auths-gateway/src/property_tests.rs index f87be573e..c65af08aa 100644 --- a/product/runtime/auths-gateway/src/property_tests.rs +++ b/product/runtime/auths-gateway/src/property_tests.rs @@ -286,7 +286,7 @@ proptest! { /// Against the file store and a pure model: at most one claim, and so at /// most one write, per logical operation; a recorded stage never /// changes; `not-entered` never follows a write; and a claim held by a - /// crashed process reads as `unknown`. + /// crashed process remains reserved until a grant exists. #[test] fn attempt_store_follows_the_model(steps in proptest::collection::vec(step(), 1..24)) { let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build().expect("runtime"); @@ -296,42 +296,33 @@ proptest! { let root = std::fs::canonicalize(directory.path()).expect("canonical").join("attempts"); let open = || GatewayAttempts::new(Arc::new(FileGatewayAttemptStore::open(root.clone()).expect("store")), crate::effect::fixture_policy().expect("policy")).expect("attempts"); let mut attempts = open(); - let mut held: BTreeMap = BTreeMap::new(); + let mut held: BTreeMap)> = BTreeMap::new(); let mut writes: BTreeMap = BTreeMap::new(); let mut recorded: BTreeMap = BTreeMap::new(); for step in steps { match step { Step::Claim(operation) => { - let request = recipe - .closed_request_from_arguments( - &arguments(&format!("op-{operation}"), "recTEST0000000001", "Approved"), - [operation; 32], - ) - .expect("request"); - match runtime.block_on(attempts.claim(&request, digest, 1_790_000_000)) { - Ok(claim) => { - *writes.entry(operation).or_default() += 1; - held.insert(operation, claim); - } + let values = arguments(&format!("op-{operation}"), "recTEST0000000001", "Approved"); + let command = crate::scenario_tests::admitted(&recipe, &values, [operation; 32], Vec::new(), 60, Vec::new(), 1_790_000_000).expect("command"); + let approved = Arc::new(crate::effect::approve_driver_fixture(command, digest, 1_790_000_000, None).expect("approval")); + match runtime.block_on(attempts.claim_bounded(&approved, 1_790_000_000)) { + Ok(crate::store::BoundedClaim::Claimed(claim)) => { held.insert(operation, (*claim, approved)); } Err(GatewayAttemptError::Replay) => {} - Err(error) => prop_assert!(false, "claim failed: {error:?}"), + other => prop_assert!(matches!(other, Err(GatewayAttemptError::Replay)), "unexpected claim result"), } } Step::Finish(operation, kind) => { - let Some(claim) = held.remove(&operation) else { continue }; - let stage = match kind { - 0 => runtime.block_on(claim.record_not_entered("gateway.transport.not-entered", None)).map(|snapshot| snapshot.stage()), - 1 => runtime.block_on(claim.record_unknown()).map(|snapshot| snapshot.stage()), - 2 => runtime - .block_on(claim.record_response(200, [9; 32], None)) - .and_then(|observable| observable.snapshot()) - .map(|snapshot| snapshot.stage()), - _ => { - drop(claim); - continue; - } - }; - let stage = stage.expect("recorded"); + let Some((claim, approved)) = held.remove(&operation) else { continue }; + if kind >= 3 { drop(claim); continue; } + let stage = if kind == 0 { + runtime.block_on(claim.record_not_entered("test.before-grant", None)).map(|snapshot| snapshot.stage()) + } else { + let (claim, permit) = runtime.block_on(claim.grant_entry(approved, crate::entry::EntryValidation::Oracle { now: 1_790_000_000 })).expect("grant"); + *writes.entry(operation).or_default() += 1; + drop(permit); + if kind == 1 { runtime.block_on(claim.record_unknown()).map(|snapshot| snapshot.stage()) } + else { runtime.block_on(claim.record_response(200, [9; 32], None)).and_then(|observable| observable.snapshot()).map(|snapshot| snapshot.stage()) } + }.expect("recorded"); prop_assert!(!recorded.contains_key(&operation), "a recorded stage changed"); recorded.insert(operation, stage); } @@ -353,7 +344,7 @@ proptest! { .expect("readable"); match (recorded.get(&operation), stored) { (Some(stage), Some(snapshot)) => prop_assert_eq!(snapshot.stage(), *stage), - (None, Some(snapshot)) => prop_assert_eq!(snapshot.stage(), GatewayAttemptStage::Unknown), + (None, Some(snapshot)) => prop_assert_eq!(snapshot.stage(), GatewayAttemptStage::Reserved), (None, None) => prop_assert!(!writes.contains_key(&operation)), (Some(_), None) => prop_assert!(false, "a recorded attempt vanished"), } diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index fa437efd3..f44bc394b 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/7"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/4"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/5"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone @@ -412,6 +412,37 @@ impl QualificationGate { } } + /// Freezes the published bundle and monotonic memory once inside the + /// writer fence. Concurrent local reloads cannot change the evidence used + /// later in this same grant decision. + pub(crate) fn entry_snapshot( + &self, + shared: &crate::configuration::QualificationSnapshot, + ) -> Result { + let held = self.held(); + if shared.memory.blocked || shared.bundle != held.as_ref().map(|held| held.digest) { + return Err("gateway.configuration.qualification-changed"); + } + let mut memory = shared.memory.clone(); + memory.merge(&self.verifier_state()); + if memory.blocked { + return Err("gateway.configuration.qualification-unavailable"); + } + let now = self.clock.now().ok_or("gateway.verify.clock-unavailable")?; + let trusted = self.clock.trust() == ClockTrustState::Trusted; + if self.policy == QualificationPolicy::Required && !trusted { + return Err("gateway.qualification.clock-untrusted"); + } + Ok(FencedQualification { + policy: self.policy, + deployment: self.deployment.clone(), + held, + state: memory.state(), + now, + trusted, + }) + } + /// Adopts shared monotonic memory, but grants no qualification. Ordinary /// entry must still call the native qualification check; commissioning /// must verify its separate exact permit against this same memory. @@ -585,6 +616,35 @@ impl QualificationGate { } } +/// Immutable qualification evidence sampled under the attempt fence. +pub(crate) struct FencedQualification { + policy: QualificationPolicy, + deployment: Option, + held: Option>, + pub(crate) state: VerifierState, + pub(crate) now: u64, + pub(crate) trusted: bool, +} + +impl FencedQualification { + pub(crate) fn check(&self) -> Result<(), &'static str> { + if self.policy == QualificationPolicy::Optional { + return Ok(()); + } + let (Some(deployment), Some(held)) = (&self.deployment, &self.held) else { + return Err("gateway.qualification.unavailable"); + }; + match held + .verified + .evaluate(deployment, self.now, self.trusted, &self.state) + .refusal + { + Some(refusal) => Err(qualification_code(refusal)), + None => Ok(()), + } + } +} + /// What a gateway process knows about itself and its installed recipe, from /// which its qualification tuple is derived. #[derive(Clone, Debug)] diff --git a/product/runtime/auths-gateway/src/qualification_simulation.rs b/product/runtime/auths-gateway/src/qualification_simulation.rs index 973a55664..a87624dfd 100644 --- a/product/runtime/auths-gateway/src/qualification_simulation.rs +++ b/product/runtime/auths-gateway/src/qualification_simulation.rs @@ -163,15 +163,16 @@ impl SimulationProvider for RecordProvider { impl ProviderPort for OracleProvider

{ async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { + let request = permit.request(); assert_eq!( request_facts(request), self.expected, "independent wire oracle" ); self.checked.fetch_add(1, Ordering::SeqCst); - self.inner.write(request).await + self.inner.write(permit).await } async fn action_read( diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index a731c05e2..9a24c1a56 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/4", + "store_schema": "auths.gateway-attempt/5", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index 7e65fc91b..45368a891 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -735,7 +735,7 @@ async fn durable_claim_is_one_use_across_races_and_restart() { .await .expect("read") .expect("retained claim"); - assert_eq!(snapshot.stage(), GatewayAttemptStage::Unknown); + assert_eq!(snapshot.stage(), GatewayAttemptStage::Reserved); assert!(matches!( restarted .claim(&request, *recipe.digest(), 1_790_000_000) @@ -763,10 +763,35 @@ async fn response_and_observation_are_distinct_durable_stages() { crate::effect::fixture_policy().expect("policy"), ) .expect("attempts"); - let claim = store - .claim(&request, *recipe.digest(), 1_790_000_000) + let command = crate::scenario_tests::admitted( + &recipe, + &args, + [9; 32], + Vec::new(), + 60, + Vec::new(), + 1_790_000_000, + ) + .expect("command"); + let approved = Arc::new( + crate::effect::approve_driver_fixture(command, *recipe.digest(), 1_790_000_000, None) + .expect("approval"), + ); + let crate::store::BoundedClaim::Claimed(claim) = store + .claim_bounded(&approved, 1_790_000_000) + .await + .expect("claim") + else { + panic!("claim refused") + }; + let (claim, permit) = claim + .grant_entry( + approved, + crate::entry::EntryValidation::Oracle { now: 1_790_000_000 }, + ) .await - .expect("claim"); + .expect("grant"); + drop(permit); let response = claim .record_response(200, [3; 32], None) .await diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index ef72ad217..2aa28b5ef 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -222,6 +222,12 @@ impl<'a, P> TestIo<'a, P> { impl SubmitIo for TestIo<'_, P> { type Lease = (); + fn entry_validation(&self) -> Result { + Ok(crate::entry::EntryValidation::Oracle { + now: self.clock().ok_or("test.clock")?, + }) + } + fn clock(&self) -> Option { Some(self.clock.load(Ordering::SeqCst)) } @@ -282,9 +288,9 @@ impl SubmitIo for TestIo<'_, P> { async fn write( &self, _lease: &(), - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { - self.provider.write(request).await + self.provider.write(permit).await } async fn action_read( @@ -489,8 +495,9 @@ impl RecordProvider { impl ProviderPort for RecordProvider { async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { + let request = permit.request(); self.writes.fetch_add(1, Ordering::SeqCst); self.idempotency_keys .lock() @@ -678,7 +685,7 @@ async fn run_claim_case(id: &str, backend: Backend) -> (String, usize) { .expect("first claim"), ); let transition = match id { - "first-claim" => "unclaimed->attempting".to_owned(), + "first-claim" => "unclaimed->reserved".to_owned(), "same-id-fresh-challenge" | "changed-action-same-id" => { let replacement = if id == "same-id-fresh-challenge" { "Approved" @@ -690,14 +697,11 @@ async fn run_claim_case(id: &str, backend: Backend) -> (String, usize) { record.submit(&second, &provider).await, crate::engine::not_entered("gateway.effect.operation-conflict") ); - "attempting->binding-conflict".to_owned() + "reserved->binding-conflict".to_owned() } "crash-after-claim" => { record.store.restart(); - format!( - "attempting->{}-on-restart", - record.describe(&original).await - ) + format!("reserved->{}-on-restart", record.describe(&original).await) } _ => panic!("unhandled claim scenario {id}"), }; @@ -733,7 +737,7 @@ async fn run_first_attempt_case(id: &str, backend: Backend) -> (String, usize) { let from = if matches!(result, GatewaySubmitResult::Unknown) || !record.recipe.review().has_observation() { - "attempting" + "entry-granted" } else { "response-recorded" }; @@ -1061,8 +1065,9 @@ fn substitute(value: &mut Value, amount: &Value, echo: &Value) { impl ProviderPort for TableProvider { async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { + let request = permit.request(); self.log( request.method().as_str(), request.url(), @@ -1354,7 +1359,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/4"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/5"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1483,7 +1488,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/4", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/5", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index c1a599c80..221bd29a5 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9c37f9c5c5ff0a6f0b3920c0262e6b5c5d00425865f1de3a384c889161b0b4da"; + "b92b03244d4f4f5e3d7360f06c2dcbe53d57e294b06f231f6c2706666e0dd801"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index e64e3945e..457ae19f2 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/4`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/5`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/4"; +const SCHEMA: &str = "auths.gateway-attempt/5"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -65,8 +65,10 @@ const MAX_JSON_INTEGER: u64 = (1 << 53) - 1; pub enum GatewayAttemptStage { /// Transport entry was durably excluded after a claim. NotEntered, - /// Transport may have started; restart projects this to `Unknown`. - Attempting, + /// Durable admission and capacity reservation; no provider entry yet. + Reserved, + /// A unique durable grant exists; external entry may have occurred. + EntryGranted, /// A complete bounded HTTP response was durably recorded. ResponseRecorded, /// Entry or effect is ambiguous; no automatic retry. @@ -83,7 +85,8 @@ impl GatewayAttemptStage { const fn kernel(self) -> Stage { match self { Self::NotEntered => Stage::NotEntered, - Self::Attempting => Stage::Attempting, + Self::Reserved => Stage::Reserved, + Self::EntryGranted => Stage::EntryGranted, Self::ResponseRecorded => Stage::ResponseRecorded, Self::Unknown => Stage::Unknown, Self::Observed => Stage::Observed, @@ -485,6 +488,7 @@ struct Record { nonce: String, evaluated_at: u64, stage: GatewayAttemptStage, + entry: Option, #[serde(default, skip_serializing_if = "Option::is_none")] refusal: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] @@ -507,6 +511,17 @@ struct Record { pre_entry: Option, } +/// Private immutable evidence of the unique acknowledged grant. It does not +/// attest to a socket send and cannot be deserialized into a transport permit. +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct EntryAudit { + schema: String, + granted_at: u64, + effect_id: String, + dependencies: Vec, +} + /// The fields no transition may change, in a fixed order. #[derive(Serialize)] struct FixedFields<'a> { @@ -561,6 +576,12 @@ impl Record { _ => return Err(GatewayAttemptError::Corrupt), }; Ok(AttemptView { + entry: self + .entry + .as_ref() + .map(canonical) + .transpose()? + .unwrap_or_default(), fixed: canonical(&FixedFields { schema: &self.schema, binding_canonical: &self.binding_canonical, @@ -625,6 +646,102 @@ impl Record { Ok(counters) } + fn validate_reservations( + &self, + key: GatewayAttemptKey, + bound: Option<&crate::bounds::BoundAdmission>, + snapshots: &[Option>], + now: u64, + ) -> Result<(), GatewayAttemptError> { + let counters = self.counters()?; + let Some(bound) = bound else { + return if counters.is_empty() && snapshots.is_empty() { + Ok(()) + } else { + Err(GatewayAttemptError::Corrupt) + }; + }; + if counters.len() != bound.counts.len() + bound.sums.len() + || snapshots.len() != counters.len() + || bound.window_seconds == 0 + || bound.counts.iter().any(|bound| { + counters + .iter() + .filter(|counter| { + counter.kind == GatewayCounterKind::Count && counter.counter == bound.key + }) + .count() + != 1 + }) + || bound.sums.iter().any(|bound| { + counters + .iter() + .filter(|counter| { + counter.kind == GatewayCounterKind::Sum && counter.counter == bound.key + }) + .count() + != 1 + }) + || now >= bound.window_end + || now / bound.window_seconds != bound.window_index + { + return Err(GatewayAttemptError::InvalidTransition); + } + let claim = hex::encode(key.as_bytes()); + for (counter, bytes) in counters.iter().zip(snapshots) { + let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; + let valid = match counter.kind { + GatewayCounterKind::Count => { + let slot: CountSlotRecord = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + let limit = bound + .counts + .iter() + .find(|candidate| candidate.key == counter.counter) + .ok_or(GatewayAttemptError::Corrupt)?; + canonical(&slot)? == bytes + && slot.schema == COUNT_SLOT_SCHEMA + && slot.counter == hex::encode(counter.counter) + && slot.slot == counter.slot + && slot.slot < limit.capacity + && slot.namespace == self.namespace + && slot.operation_id == self.operation_id + && slot.claim == claim + && slot.window_seconds == bound.window_seconds + && slot.window_index == bound.window_index + && slot.window_end == bound.window_end + } + GatewayCounterKind::Sum => { + let slot: SumSlotRecord = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + let limit = bound + .sums + .iter() + .find(|candidate| candidate.key == counter.counter) + .ok_or(GatewayAttemptError::Corrupt)?; + canonical(&slot)? == bytes + && slot.schema == SUM_SLOT_SCHEMA + && slot.counter == hex::encode(counter.counter) + && slot.slot == counter.slot + && slot.slot < limit.slots + && slot.namespace == self.namespace + && slot.operation_id == self.operation_id + && slot.claim == claim + && slot.window_seconds == bound.window_seconds + && slot.window_index == bound.window_index + && slot.window_end == bound.window_end + && slot.amount == bound.argument + && slot.amount <= slot.cumulative + && slot.cumulative <= limit.capacity + } + }; + if !valid { + return Err(GatewayAttemptError::Corrupt); + } + } + Ok(()) + } + fn locator_valid(&self) -> bool { match (&self.response_locator, &self.observation_plan) { (None, _) => true, @@ -656,6 +773,19 @@ impl Record { { return Err(GatewayAttemptError::Corrupt); } + if self.entry.as_ref().is_some_and(|entry| { + entry.schema != "auths.effect-entry/1" + || entry.granted_at < self.evaluated_at + || entry.granted_at > MAX_JSON_INTEGER + || entry.effect_id != hex::encode(binding.id().as_bytes()) + || entry.dependencies.len() > 3 + || entry + .dependencies + .iter() + .any(|value| digest_bytes(value).is_err()) + }) { + return Err(GatewayAttemptError::Corrupt); + } if self.schema != SCHEMA || self.nonce.len() != 32 || !self @@ -709,7 +839,7 @@ impl Record { action_commitment, recipe_digest, evaluated_at: self.evaluated_at, - stage: if recovered && self.stage == GatewayAttemptStage::Attempting { + stage: if recovered && self.stage == GatewayAttemptStage::EntryGranted { GatewayAttemptStage::Unknown } else { self.stage @@ -1696,7 +1826,7 @@ enum ExpectedPlan<'a> { Stored, } -/// A fresh `attempting` claim record for `request`, with a random nonce and +/// A fresh `reserved` claim record for `request`, with a random nonce and /// no counters. fn claim_record( request: &ClosedProviderRequest, @@ -1728,7 +1858,8 @@ fn claim_record( recipe_digest: hex::encode(binding.journal_identity().3), nonce: hex::encode(nonce), evaluated_at, - stage: GatewayAttemptStage::Attempting, + stage: GatewayAttemptStage::Reserved, + entry: None, refusal: None, counters: Vec::new(), response_status: None, @@ -1886,7 +2017,7 @@ impl GatewayAttempts { .await } - /// Reads a secret-free durable snapshot. An `attempting` stage is + /// Reads a secret-free durable snapshot. An `entry-granted` stage is /// conservatively projected as `unknown`: another process may hold it, or /// it may have crashed. /// @@ -1906,7 +2037,7 @@ impl GatewayAttempts { /// Reopens a stored attempt for one read-only observation from its /// stored plan. It returns `None` unless the recipe digest is unchanged, /// the new verified request resolves to the same plan, and the stage can - /// be resolved by a read-back: an `attempting` or `unknown` record only + /// be resolved by a read-back: an `entry-granted` or `unknown` record only /// for a verified-locator link, and a `response-recorded` record for any /// declared link whose locator is recorded. A re-observation records only /// positive evidence under compare-and-swap, so it may run while the @@ -1959,11 +2090,12 @@ impl GatewayAttempts { record.snapshot(false)?; let link = record.link(); let stage_resolvable = match record.stage { - GatewayAttemptStage::Attempting | GatewayAttemptStage::Unknown => { + GatewayAttemptStage::EntryGranted | GatewayAttemptStage::Unknown => { transition::resolves_unknown(link) } GatewayAttemptStage::ResponseRecorded => transition::has_link(link), - GatewayAttemptStage::NotEntered + GatewayAttemptStage::Reserved + | GatewayAttemptStage::NotEntered | GatewayAttemptStage::Observed | GatewayAttemptStage::ObservedByProvider => false, }; @@ -2050,13 +2182,110 @@ impl Attempt { } } -/// A durable claim token; dropping it without a result leaves `unknown` on -/// restart and never permits another automatic write. +/// A durable attempt handle. A reservation does not authorize transport; only +/// a newly acknowledged grant produces a one-use provider permit. pub struct ClaimedGatewayAttempt { attempt: Attempt, } impl ClaimedGatewayAttempt { + /// Validates the native authority, dependencies and every existing slot + /// under the same writer fence, then persists one immutable grant. No + /// deserialization path can construct the returned transport permit. + pub(crate) async fn grant_entry( + self, + approved: Arc, + validation: crate::entry::EntryValidation, + ) -> Result<(Self, ProviderEntryPermit), GatewayAttemptError> { + blocking(move || { + let mut attempt = self.attempt; + let dependencies = validation.dependencies(); + let counters = attempt.record.counters()?; + let mut keys = vec![(GatewayRecordKind::Attempt, attempt.key)]; + keys.extend_from_slice(&dependencies); + keys.extend(counters.iter().map(|counter| match counter.kind { + GatewayCounterKind::Count => ( + GatewayRecordKind::CountSlot, + GatewayAttemptKey(crate::bounds::count_slot_key( + &counter.counter, + counter.slot, + )), + ), + GatewayCounterKind::Sum => ( + GatewayRecordKind::SumSlot, + GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.counter, counter.slot)), + ), + })); + let mut committed = None; + attempt.store.fenced_replace(&keys, &mut |snapshots| { + if snapshots.len() != keys.len() + || snapshots[0].as_deref() != Some(attempt.stored.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + let current = decode( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if current.stage != GatewayAttemptStage::Reserved + || current.binding_canonical.as_bytes() + != approved + .effect() + .binding() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::InvalidTransition); + } + let dependency_end = 1 + dependencies.len(); + let now = validation + .validate( + &approved, + &snapshots[1..dependency_end], + current.evaluated_at, + ) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + current.validate_reservations( + attempt.key, + approved.command().bound.as_ref(), + &snapshots[dependency_end..], + now, + )?; + let mut next = current.clone(); + next.stage = GatewayAttemptStage::EntryGranted; + next.entry = Some(EntryAudit { + schema: "auths.effect-entry/1".to_owned(), + granted_at: now, + effect_id: hex::encode(approved.effect().binding().id().as_bytes()), + dependencies: snapshots[1..dependency_end] + .iter() + .map(|bytes| { + let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; + auths_codec::domain_commitment("auths.effect-entry-dependency/1", bytes) + .map(|digest| hex::encode(digest.as_bytes())) + .map_err(|_| GatewayAttemptError::Corrupt) + }) + .collect::, _>>()?, + }); + if !valid_transition(¤t, &next)? { + return Err(GatewayAttemptError::InvalidTransition); + } + let bytes = encode(&next)?; + committed = Some((next, bytes.clone())); + Ok(bytes) + })?; + // A callback result alone is insufficient. This point is reached + // only after the adapter acknowledges durable publication. + let (record, stored) = committed.ok_or(GatewayAttemptError::Unavailable)?; + attempt.record = record; + attempt.stored = stored; + Ok((Self { attempt }, ProviderEntryPermit { approved })) + }) + .await + } + /// Records, once and before transport entry, what was read after the /// lease: the pre-entry observations and the relative-ceiling basis. /// @@ -2129,6 +2358,19 @@ impl ClaimedGatewayAttempt { } } +/// One-use native transport capability, constructed only after a new durable +/// entry acknowledgement. The shared reference retains the one sealed command; +/// the permit itself is neither cloneable nor deserializable. +pub(crate) struct ProviderEntryPermit { + approved: Arc, +} + +impl ProviderEntryPermit { + pub(crate) fn request(&self) -> &ClosedProviderRequest { + &self.approved.command().request + } +} + /// A stored attempt that may be advanced only by a separate read-only /// observation, never by another write. pub struct ObservableGatewayAttempt { @@ -2669,3 +2911,7 @@ impl GatewayAttempts { }) } } + +#[cfg(test)] +#[path = "entry_tests.rs"] +mod entry_tests; diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 54d5317f3..343084920 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -18,8 +18,8 @@ use crate::transport::{ GatewayTransportError, ProviderPort, ProviderResponse, WriteTransportOutcome, }; use crate::{ - ClaimedGatewayAttempt, ClosedCredentialRead, ClosedProviderRequest, CompiledRecipe, - GatewayAttemptError, GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, + ClaimedGatewayAttempt, ClosedCredentialRead, CompiledRecipe, GatewayAttemptError, + GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, ObservableGatewayAttempt, RequestHeader, }; use auths_gateway_kernel::order::{ @@ -43,6 +43,9 @@ pub(crate) trait SubmitIo { /// A credential lease. type Lease; + /// Captures installed immutable inputs for native checking inside the store fence. + fn entry_validation(&self) -> Result; + /// Reads the gateway clock. fn clock(&self) -> Option; @@ -102,7 +105,7 @@ pub(crate) trait SubmitIo { async fn write( &self, lease: &Self::Lease, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result; /// Performs one bounded GET of an action read or observation under @@ -241,9 +244,10 @@ struct Run<'a, I: SubmitIo> { guard: Option, ceiling: Option, evaluated_at: u64, - verified: Option, + verified: Option>, selected: Vec, claim: Option, + permit: Option, observable: Option, lease: Option, pre_entry: GatewayPreEntry, @@ -264,6 +268,7 @@ impl<'a, I: SubmitIo> Run<'a, I> { verified: None, selected: Vec::new(), claim: None, + permit: None, observable: None, lease: None, pre_entry: GatewayPreEntry::default(), @@ -350,7 +355,7 @@ impl Run<'_, I> { SubmitAction::Verify => SubmitEvent::Verification(self.verify()), SubmitAction::Admit => SubmitEvent::Admission(self.admit()), SubmitAction::BindScope => { - let bound = match self.verified.as_ref().map(ApprovedEffect::command) { + let bound = match self.verified.as_deref().map(ApprovedEffect::command) { Some(verified) => self.io.bind_scope(verified), None => Err("gateway.attempt.unavailable"), }; @@ -406,6 +411,7 @@ impl Run<'_, I> { SubmitAction::CheckDeadline => SubmitEvent::Deadline( self.io.within_entry_deadline(self.evaluated_at) && self.revalidate(), ), + SubmitAction::GrantEntry => SubmitEvent::Granted(self.grant_entry().await), SubmitAction::Send => SubmitEvent::Write(self.send().await), SubmitAction::RecordResponse => { let recorded = self.record_response().await; @@ -476,7 +482,7 @@ impl Run<'_, I> { argument } }; - self.verified = Some(approved); + self.verified = Some(std::sync::Arc::new(approved)); Verification::Authorized { argument } } @@ -484,7 +490,7 @@ impl Run<'_, I> { /// observer check; nothing is stored. The first failing check's code is /// the one reported. fn admit(&mut self) -> bool { - let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { + let Some(verified) = self.verified.as_deref().map(ApprovedEffect::command) else { return false; }; if let Some(retention) = self.cx.recipe.idempotency_retention() @@ -572,7 +578,7 @@ impl Run<'_, I> { } async fn resume(&mut self) -> bool { - let Some(verified) = self.verified.as_ref().map(ApprovedEffect::command) else { + let Some(verified) = self.verified.as_deref().map(ApprovedEffect::command) else { return false; }; match self @@ -630,7 +636,7 @@ impl Run<'_, I> { async fn pre_entry_read(&mut self) -> PreEntryResult { let (Some(lease), Some(verified), Some(observer), Some(pointers)) = ( &self.lease, - self.verified.as_ref().map(ApprovedEffect::command), + self.verified.as_deref().map(ApprovedEffect::command), self.cx.observer, self.cx.recipe.pre_entry_pointers(), ) else { @@ -676,7 +682,7 @@ impl Run<'_, I> { async fn ceiling_read(&mut self) -> CeilingRead { let (Some(lease), Some(verified), Some(ceiling)) = ( &self.lease, - self.verified.as_ref().map(ApprovedEffect::command), + self.verified.as_deref().map(ApprovedEffect::command), &self.ceiling, ) else { return CeilingRead::Unavailable; @@ -712,16 +718,36 @@ impl Run<'_, I> { } } + async fn grant_entry(&mut self) -> bool { + let validation = match self.io.entry_validation() { + Ok(validation) => validation, + Err(_) => return false, + }; + let Some(approved) = &self.verified else { + return false; + }; + let Some(claim) = self.claim.take() else { + return false; + }; + let (claim, permit) = match claim + .grant_entry(std::sync::Arc::clone(approved), validation) + .await + { + Ok(granted) => granted, + // An ambiguous acknowledgement may follow a committed grant. + Err(_) => return false, + }; + self.claim = Some(claim); + self.permit = Some(permit); + true + } + async fn send(&mut self) -> WriteResult { - let (Some(lease), Some(verified)) = ( - &self.lease, - self.verified.as_ref().map(ApprovedEffect::command), - ) else { - return WriteResult::NotEntered; + let (Some(lease), Some(permit)) = (&self.lease, self.permit.take()) else { + return WriteResult::Unknown; }; - match self.io.write(lease, &verified.request).await { - Err(_) => WriteResult::NotEntered, - Ok(WriteTransportOutcome::Unknown) => WriteResult::Unknown, + match self.io.write(lease, permit).await { + Err(_) | Ok(WriteTransportOutcome::Unknown) => WriteResult::Unknown, Ok(WriteTransportOutcome::ResponseRecorded { status, digest, @@ -738,7 +764,7 @@ impl Run<'_, I> { let (Some(claim), Some((status, digest, body, version_ok)), Some(verified)) = ( self.claim.take(), self.written.take(), - self.verified.as_ref().map(ApprovedEffect::command), + self.verified.as_deref().map(ApprovedEffect::command), ) else { return ResponseRecord::Failed; }; diff --git a/product/runtime/auths-gateway/src/support.rs b/product/runtime/auths-gateway/src/support.rs index bdc382932..d6ef7581d 100644 --- a/product/runtime/auths-gateway/src/support.rs +++ b/product/runtime/auths-gateway/src/support.rs @@ -72,7 +72,8 @@ pub struct SupportFacts { const fn stage_token(stage: GatewayAttemptStage) -> &'static str { match stage { GatewayAttemptStage::NotEntered => "not-entered", - GatewayAttemptStage::Attempting => "attempting", + GatewayAttemptStage::Reserved => "reserved", + GatewayAttemptStage::EntryGranted => "entry-granted", GatewayAttemptStage::ResponseRecorded => "response-recorded", GatewayAttemptStage::Unknown => "unknown", GatewayAttemptStage::Observed => "observed", diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 9ce6567af..b88f3ed9f 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -3,10 +3,7 @@ // These matches separate definite pre-entry failure from ambiguous network entry. #![allow(clippy::manual_let_else)] -use crate::{ - ClosedCredentialRead, ClosedProviderRequest, CompiledRecipe, CredentialRequirement, - RequestHeader, -}; +use crate::{ClosedCredentialRead, CompiledRecipe, CredentialRequirement, RequestHeader}; use auths_connections::StoredSecretLease; use reqwest::{ Client, @@ -88,7 +85,7 @@ pub(crate) trait ProviderPort { /// Sends one closed write after a durable claim. async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result; /// Performs one bounded GET of an action read or observation and returns @@ -109,9 +106,9 @@ pub(crate) trait ProviderPort { impl ProviderPort for &P { async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { - (**self).write(request).await + (**self).write(permit).await } async fn action_read( @@ -139,9 +136,9 @@ pub(crate) struct LeasedTransport<'a> { impl ProviderPort for LeasedTransport<'_> { async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, ) -> Result { - self.transport.write(request, self.lease).await + self.transport.write(permit, self.lease).await } async fn action_read( @@ -275,9 +272,10 @@ impl GatewayHttpTransport { /// usual because the gateway never interprets a write body. pub(crate) async fn write( &self, - request: &ClosedProviderRequest, + permit: crate::store::ProviderEntryPermit, lease: &StoredSecretLease, ) -> Result { + let request = permit.request(); if request.credential_requirement() != &self.requirement || !self.owns_url(request.url()) { return Err(GatewayTransportError::NotEntered); } @@ -634,9 +632,38 @@ mod tests { let arguments = json!({"operation_id": "run-1", "record_id": "recTEST0000000001", "replacement": "Approved", "operator_namespace": recipe.namespace().as_str(), "recipe_digest": recipe.digest_hex()}); - let request = recipe - .closed_request_from_arguments(arguments.as_object().expect("arguments"), [1; 32]) - .expect("request"); + let command = crate::scenario_tests::admitted( + &recipe, + arguments.as_object().expect("arguments"), + [1; 32], + Vec::new(), + 60, + Vec::new(), + 1000, + ) + .expect("command"); + let approved = std::sync::Arc::new( + crate::effect::approve_driver_fixture(command, *recipe.digest(), 1000, None) + .expect("approval"), + ); + let attempts = + crate::store_testkit::TestAttempts::open(crate::store_testkit::Backend::File); + let crate::store::BoundedClaim::Claimed(claim) = attempts + .attempts() + .claim_bounded(&approved, 1000) + .await + .expect("claim") + else { + panic!("claim refused") + }; + let (_granted, permit) = claim + .grant_entry( + std::sync::Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: 1000 }, + ) + .await + .expect("durable grant"); + let request = &approved.command().request; let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)) .await .expect("bind"); @@ -673,7 +700,7 @@ mod tests { ); assert_eq!(witness.snapshot().read_transport_entries, 0); assert!(matches!( - transport.write(&request, &lease).await, + transport.write(permit, &lease).await, Ok(WriteTransportOutcome::ResponseRecorded { status: 200, .. }) )); let observation = request.observation().expect("observation"); From 8201545d23c75236eeac70ae799e1f1530b93cf4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 04:10:34 +0000 Subject: [PATCH 017/136] chore(formal): regenerate qualification artifacts Source-SHA: fd8803c0737b2a2ddd39aed8e365b46440c8bb6d Workflow-Run: 40630469370 --- formal/qualification/aeneas/source-closure.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 003e34c54..067fd5515 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "bd1d82a3172d544cad6ecb8c917eded9b94dc0550721ec63f4fd2999d8a7441b", + "digest": "e7c4c784f4842b7b862e201cc37f6186532262d81868c24f30ed7cac6f736af5", "files": [ { "path": ".cargo/config.toml", @@ -189,11 +189,11 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/order.rs", - "sha256": "0d4bb6649d38c865d9ce0b74d277c6d00f378b711a8c5406c1028c115466dd26" + "sha256": "fc7861008f4d0a991b7461cef2a9b6a872424f5b8f177561efd248f776bf8ab7" }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", - "sha256": "e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b" + "sha256": "ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23" }, { "path": "product/runtime/auths-gateway-kernel/src/ratio.rs", @@ -205,7 +205,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/transition.rs", - "sha256": "cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374" + "sha256": "607c8538f98554238c1a0dd83e09c1da6198ae72e3ff5870fce93cd54a133445" }, { "path": "product/runtime/auths-lifecycle/Cargo.toml", From 6d38bb1c6a58c3d66e887e0ff083791b1d1a04f6 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 04:21:40 +0000 Subject: [PATCH 018/136] feat(gateway)!: resume reservations with fresh audited grants --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/effect-entry.json | 35 +- compliance.toml | 5 +- ...017-bound-effect-and-recovery-ownership.md | 25 ++ docs/plans/0074-implementation-status.md | 38 ++- .../0009-bound-effect-and-recovery.md | 10 + .../runtime/auths-gateway-kernel/src/order.rs | 8 +- .../auths-gateway-kernel/src/transition.rs | 85 +++-- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 5287 -> 6459 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 5170 -> 6342 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5021 -> 5620 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4899 -> 4925 bytes .../fuzz_targets/target_gateway_attempt.rs | 3 + .../auths-gateway/semantic-closure.json | 2 +- .../runtime/auths-gateway/src/entry_tests.rs | 307 +++++++++++++++++- .../src/pending_vectors/attempts.rs | 2 +- .../auths-gateway/src/property_tests.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../runtime/auths-gateway/src/recipe/tests.rs | 2 + .../auths-gateway/src/scenario_tests.rs | 8 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 129 +++++++- product/runtime/auths-gateway/src/submit.rs | 9 +- .../runtime/auths-gateway/src/transport.rs | 2 + 30 files changed, 616 insertions(+), 74 deletions(-) diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 27d6481e8..37f5cebbc 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/5", + "attempt_schema": "auths.gateway-attempt/6", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index eab5700d5..c8bc81f2f 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -1,5 +1,32 @@ { - "schema": "auths.effect-entry-fixture/1", + "schema": "auths.effect-entry-fixture/2", + "reservation_restart": { + "initial_revision": 1, + "checkpoint_revision": 2, + "grant_revision": 3, + "reservation_slots_retained": 2, + "additional_slots": 0, + "old_deadline_refused": true, + "expired_approval_refused": true, + "stale_grant_refused": true, + "initial_evidence_retained": true, + "grant_audit": { + "revision": 3, + "authorization_started_at": 1790000061, + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[14,37,23,217,26,34,199,14,199,18,19,17,88,100,209,190,194,226,162,253,36,175,178,129,180,51,83,114,24,48,54,217],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"g-bxBML0YxjfGnvQlVDvMQGUFxWsq-D2pzNQb0bT2fD8bkZ7v6POjxdhaqIbLzZSF-jGOM-Bgfi7MS6MjtcZAg\"}", + "pre_entry": { + "basis": { + "value": 1002, + "response_digest": "0202020202020202020202020202020202020202020202020202020202020202", + "read_at": 1790000061 + } + }, + "schema": "auths.effect-entry/2", + "granted_at": 1790000061, + "effect_id": "0e2517d91a22c70ec71213115864d1bec2e2a2fd24afb281b4335372183036d9", + "dependencies": [] + } + }, "scope": "native synthetic post-verification grant; no provider entry or installed authority claim", "reserved_stage": "reserved", "granted_stage": "entry-granted", @@ -7,7 +34,11 @@ "second_grant_refused": true, "post_grant_nonentry_refused": true, "entry_audit": { - "schema": "auths.effect-entry/1", + "revision": 2, + "authorization_started_at": 1790000000, + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}", + "pre_entry": null, + "schema": "auths.effect-entry/2", "granted_at": 1790000000, "effect_id": "ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3", "dependencies": [] diff --git a/compliance.toml b/compliance.toml index f7d1eb8de..95f163d30 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/5", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/6", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-entry/1", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/5", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1615,6 +1615,7 @@ effect-entry = [ "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", "product/runtime/auths-gateway/src/entry_tests.rs#postgres_grant_has_one_winner_and_no_restart_permit", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_reservation_restart_retains_capacity_and_requires_fresh_approval", ] effect-configuration = [ "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 6bfe47428..c27ae23fb 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -252,3 +252,28 @@ This is not yet full P2 evidence. Reopening a reservation with fresh approval, explicit journal revisions, installed after-lock expiry/revocation races, ambiguous-commit fault injection and translated/refinement regeneration remain open. Acquisition/disclosure and independent recovery are later cutovers. + + +## Reservation restart and immutable approval history + +Attempt `/6` requires monotonic exact-JSON-integer revisions. Every update uses +both the complete predecessor bytes and one revision increment; saturation +refuses progress. An identical reserved operation may reopen with its existing +allocation. It does not acquire entry authority and cannot reopen a granted or +terminal operation. Full-binding differences still conflict. + +A renewed exact approval does not rewrite the admission approval or first +pre-entry checkpoint. Grant audit `/2` separately freezes the actual approval, +fresh authorization start time, revision and fresh reads used at final entry. +The original proof is revalidated under the fence, using the new submission's +bounded deadline. The public snapshot uses the grant's pre-entry evidence after +entry. Stale handles lose the same atomic replacement; stored grants still +cannot recreate transport permits. Count/sum slots are checked and retained, +never charged a second time by resumption. + +The synthetic native file corpus now covers restart beyond the first approval +and submission deadline, fresh approval, unchanged exhausted-capacity slots, +immutable initial evidence and refusal of a second grant. PostgreSQL parity +source is authored; installed authority, process faults and full recovery +remain separate evidence gates. A revision in the same store cannot detect +whole-store rollback. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 85533ee64..955ff0e8f 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -281,13 +281,43 @@ closure regeneration passed after that correction (one artifact-generation test) be regenerated against the changed shipping predicates. P3/P4 and all complete acceptance gates remain open. No AP073 or delegation work was performed. +## Reservation restart and revision checkpoint + +- Attempt `/6` adds a required revision bounded to exact JSON integers. The + shipping transition predicate requires exactly one increment for every update, + rejects stale/skipped revisions and fails closed at saturation. CAS still + compares the complete previous bytes; the revision is not a rollback anchor. +- An equal binding in `Reserved` can reopen without replacing its initial + approval, claim, first checkpoint or count/sum slots. Existing grants and + terminal records remain replay; changed full bindings remain conflicts. + Reopening produces no transport capability. +- Grant audit `/2` freezes the approval actually used, its fresh authorization + start time, grant revision and fresh pre-entry evidence. The grant rechecks + current native authority under the fence using the resumed submission's + deadline. Historical admission approval remains immutable, and post-grant + snapshots expose the reads used for that grant. +- Required native `effect-entry.json` generation passed on `fd8803c0` plus this + source: `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact + store::entry_tests::native_entry_fixture_is_current` (one generator test). + The expanded synthetic file-backed sequence exhausts its count/sum capacity, + checkpoints, reopens after the initial approval and submission deadline expire, + refuses stale deadline/approval, grants once with fresh evidence, retains the + original slots and audit, and refuses another grant. Canonical stage/transition + fuzz seeds were regenerated. This is not installed proof or provider evidence. +- Attempt-scenario and semantic-closure artifact generation also passed (one + generator test each). Remote artifact commit `8201545d` was preserved before + final closure generation. No broad suite or hosted workflow was observed. +- Equivalent PostgreSQL restart source is authored, not executed. Public pending + projections, independent recovery authorization, installed fault/race evidence, + acquisition/disclosure/ACK and translated formal artifacts remain open. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | -| P1 | In progress | Finish installed first mutation cutover and native fixtures | -| P2 | Mutation grant wired | Reservation restart/revisions, full installed fault/race evidence and formal links | +| P1 | Core binding and approval wired | Versioned semantic review completeness and installed approval journey | +| P2 | Mutation grant and reservation restart wired | Public projections, independent recovery, installed fault/race evidence and formal links | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | @@ -299,10 +329,10 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | Case | Required evidence | Implementation / authored / executed | Limitation or next work | | --- | --- | --- | --- | -| A01 | Same bound identity and exact request across review/approval/send | Partial / partial / compilation-only | Execution cutover pending | +| A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Pending / no / no | Atomic journal admission | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file fixture | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index f6a52acd2..09ec19eb6 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -140,3 +140,13 @@ fenced replacement acknowledges. The same retained command supplies the request. Slot membership is checked without reallocation. The native synthetic grant corpus proves its narrow file-store sequence; it does not establish installed multi-process fencing, all fault boundaries or the still-open recovery cutover. + + +Reservation resumption now remains in that same owner: equal reserved bindings +reopen unchanged, and grant audit `/2` appends the fresh approval/read facts while +preserving admission history. Attempt `/6` advances exactly one revision per +replacement. The synthetic file corpus exercises restart after the initial +approval/deadline, retained count/sum slots at exhausted capacity and one fresh +grant. PostgreSQL equivalent source is authored, not executed. These mechanics +do not establish acquisition, disclosure, independent observation authority or +installed end-to-end guarantees. diff --git a/product/runtime/auths-gateway-kernel/src/order.rs b/product/runtime/auths-gateway-kernel/src/order.rs index 479b1482e..a1a5e77b0 100644 --- a/product/runtime/auths-gateway-kernel/src/order.rs +++ b/product/runtime/auths-gateway-kernel/src/order.rs @@ -146,8 +146,8 @@ pub enum Verification { /// The result of the claim. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum ClaimResult { - /// This submission stored the claim with every slot. - Inserted, + /// This submission holds a new or reopened reservation with every slot. + Reserved, /// The claim step stored the claim as `not-entered`. Refused, /// The logical operation was already claimed. @@ -535,7 +535,7 @@ pub const fn pre_claim(state: SubmitState, passed: bool, next: SubmitDecision) - #[must_use] pub const fn after_claim(state: SubmitState, result: ClaimResult) -> SubmitDecision { match result { - ClaimResult::Inserted => go( + ClaimResult::Reserved => go( state, Phase::Reload(Mode::Entry), SubmitAction::Reload(Mode::Entry), @@ -915,7 +915,7 @@ mod tests { SubmitEvent::Verification(Verification::Authorized { argument: 500 }), SubmitEvent::Admission(true), SubmitEvent::Preparation(true), - SubmitEvent::Claim(ClaimResult::Inserted), + SubmitEvent::Claim(ClaimResult::Reserved), SubmitEvent::Reload(true), SubmitEvent::Lease(true), SubmitEvent::Prefix(true), diff --git a/product/runtime/auths-gateway-kernel/src/transition.rs b/product/runtime/auths-gateway-kernel/src/transition.rs index 75ea3c4fc..768fa5d7c 100644 --- a/product/runtime/auths-gateway-kernel/src/transition.rs +++ b/product/runtime/auths-gateway-kernel/src/transition.rs @@ -60,6 +60,8 @@ pub enum Link { /// The fields of one stored attempt record the transition rule inspects. #[derive(Clone, Debug, Eq, PartialEq)] pub struct AttemptView { + /// Monotonic journal revision, bounded to exact JSON integers. + pub revision: u64, /// Canonical bytes of the fields no transition may change. pub fixed: Vec, /// Immutable canonical grant/audit bytes; empty before entry. @@ -227,7 +229,9 @@ pub const fn has_reading(reading: Reading) -> bool { #[must_use] pub fn consistent(view: &AttemptView) -> bool { let has_response = !absent(&view.response); - requires_entry(view.stage) == !absent(&view.entry) + view.revision > 0 + && view.revision <= 9_007_199_254_740_991 + && requires_entry(view.stage) == !absent(&view.entry) && refusal_stage(view.stage) == view.refusal && (!requires_response(view.stage) || has_response) && (!has_response || permits_response(view.stage)) @@ -359,7 +363,9 @@ pub const fn link_equal(left: Link, right: Link) -> bool { /// consistent with its stage. #[must_use] pub fn valid_transition(old: &AttemptView, new: &AttemptView) -> bool { - consistent(old) + old.revision < 9_007_199_254_740_991 + && new.revision == old.revision + 1 + && consistent(old) && entry_kept(old, new) && same_bytes(&old.fixed, &new.fixed) && plan_kept(old, new) @@ -392,6 +398,7 @@ mod tests { Vec::new() }; AttemptView { + revision: 1, entry: if requires_entry(stage) { alloc::vec![7] } else { @@ -414,6 +421,27 @@ mod tests { } } + fn transition(old: &AttemptView, new: &AttemptView) -> bool { + let mut next = new.clone(); + next.revision = old.revision + 1; + valid_transition(old, &next) + } + + #[test] + fn revisions_advance_once_and_never_wrap() { + let old = view(Stage::Reserved, Link::None); + let mut new = view(Stage::EntryGranted, Link::None); + assert!(!valid_transition(&old, &new)); + new.revision = 2; + assert!(valid_transition(&old, &new)); + new.revision = 3; + assert!(!valid_transition(&old, &new)); + let mut saturated = old.clone(); + saturated.revision = 9_007_199_254_740_991; + new.revision = 9_007_199_254_740_992; + assert!(!valid_transition(&saturated, &new)); + } + #[test] fn terminal_stages_have_no_outgoing_transition() { for link in [Link::None, Link::Verified, Link::AfterResponse] { @@ -421,7 +449,7 @@ mod tests { for to in STAGES { if terminal_stage(from) { assert!(!stage_transition_allowed(from, to, link)); - assert!(!valid_transition(&view(from, link), &view(to, link))); + assert!(!transition(&view(from, link), &view(to, link))); } } } @@ -432,7 +460,7 @@ mod tests { fn unknown_resolves_only_for_a_verified_link_with_evidence() { for link in [Link::None, Link::Verified, Link::AfterResponse] { for to in STAGES { - let allowed = valid_transition(&view(Stage::Unknown, link), &view(to, link)); + let allowed = transition(&view(Stage::Unknown, link), &view(to, link)); assert_eq!( allowed, to == Stage::ResponseRecorded @@ -448,34 +476,28 @@ mod tests { let old = view(Stage::Reserved, Link::Verified); let mut checkpoint = old.clone(); checkpoint.pre_entry = vec![9]; - assert!(valid_transition(&old, &checkpoint)); - assert!(!valid_transition(&checkpoint, &checkpoint)); - assert!( - !valid_transition(&old, &old), - "a checkpoint must add evidence" - ); + assert!(transition(&old, &checkpoint)); + assert!(!transition(&checkpoint, &checkpoint)); + assert!(!transition(&old, &old), "a checkpoint must add evidence"); let mut refused = view(Stage::NotEntered, Link::Verified); refused.pre_entry = vec![9]; - assert!(valid_transition(&old, &refused)); - assert!(valid_transition(&checkpoint, &refused)); + assert!(transition(&old, &refused)); + assert!(transition(&checkpoint, &refused)); refused.pre_entry = vec![8]; - assert!(!valid_transition(&checkpoint, &refused), "kept once set"); + assert!(!transition(&checkpoint, &refused), "kept once set"); let mut responded = view(Stage::ResponseRecorded, Link::Verified); responded.pre_entry = vec![9]; - assert!( - !valid_transition(&old, &responded), - "added only before entry" - ); - assert!(!valid_transition(&checkpoint, &responded)); + assert!(!transition(&old, &responded), "added only before entry"); + assert!(!transition(&checkpoint, &responded)); let mut grant = view(Stage::EntryGranted, Link::Verified); grant.pre_entry = checkpoint.pre_entry.clone(); - assert!(valid_transition(&checkpoint, &grant)); - assert!(valid_transition(&grant, &responded)); - assert!(!valid_transition(&grant, &refused)); - assert!(!valid_transition(&grant, &grant), "no second grant"); + assert!(transition(&checkpoint, &grant)); + assert!(transition(&grant, &responded)); + assert!(!transition(&grant, &refused)); + assert!(!transition(&grant, &grant), "no second grant"); let mut changed = responded.clone(); changed.entry = vec![8]; - assert!(!valid_transition(&grant, &changed), "grant is immutable"); + assert!(!transition(&grant, &changed), "grant is immutable"); } #[test] @@ -483,20 +505,20 @@ mod tests { let old = view(Stage::ResponseRecorded, Link::AfterResponse); let mut moved = view(Stage::ObservedByProvider, Link::AfterResponse); moved.response = vec![1]; - assert!(valid_transition(&old, &moved)); + assert!(transition(&old, &moved)); moved.fixed = vec![7; 5]; - assert!(!valid_transition(&old, &moved)); + assert!(!transition(&old, &moved)); let mut changed = view(Stage::Observed, Link::AfterResponse); changed.response = vec![2]; - assert!(!valid_transition(&old, &changed)); + assert!(!transition(&old, &changed)); let attempting = view(Stage::EntryGranted, Link::AfterResponse); - assert!(!valid_transition( + assert!(!transition( &attempting, &view(Stage::ObservedByProvider, Link::AfterResponse) )); let mut located = view(Stage::ResponseRecorded, Link::AfterResponse); located.locator = vec![3]; - assert!(valid_transition(&attempting, &located)); + assert!(transition(&attempting, &located)); } } @@ -546,6 +568,7 @@ mod proofs { fn any_view() -> AttemptView { AttemptView { + revision: kani::any(), entry: any_bytes(), fixed: any_bytes(), stage: any_stage(), @@ -606,6 +629,8 @@ mod proofs { } }; shape + && view.revision > 0 + && view.revision <= 9_007_199_254_740_991 && (view.locator.is_empty() || response) && (matches!(view.stage, Stage::Reserved | Stage::NotEntered) == view.entry.is_empty()) } @@ -659,7 +684,9 @@ mod proofs { } else { old.entry == new.entry }; - let expected = old.fixed == new.fixed + let expected = old.revision < 9_007_199_254_740_991 + && new.revision == old.revision + 1 + && old.fixed == new.fixed && entry && fields_match_stage(&old) && old.observation == new.observation diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 5912259f9..7774eb4e3 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 1819a947c..a2e2540c0 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 36f0d0a5b..396b398c9 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 32698c165..80f1f6ef5 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 31848cb65..103458b2d 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"schema":"auths.gateway-attempt/5","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"schema":"auths.effect-entry/1","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index aa92b1f6669c7bd2264112d4cdf2d4f23d3ba236..0acde163f5c747c3c9c7c21d5576f0c507715c9f 100644 GIT binary patch delta 232 zcmZ3kx!XvHfq^HbTB#_tEVDQ>KTpZZNN2JvVro<KTpZZNN2JvVro<KTpZZP-h~m0;AbRwRlb*gs2fr^dS4>G(ky2WErKz z(vpn)qRgtq5}*n3#U+VFC8;U#i6ub8%q+KLIXOC$ P>jY&PjW*8_WMl#Wi1RJ4 delta 72 zcmeyOJy)HTfq}EWdh$F@1xC}&`#BG?Z~nqQk8$#RPI)l@7Q1Y5az<)yqLP(TVrfZ6 Zv0iFgT558MZfaghQKi1&=Fh^6OaPL589x93 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index 13140b9f3576c11a6c282e8af2cd4c00e7bbc511..b92671f5fe45b89e13794cf8a3330f05b373ebf3 100644 GIT binary patch delta 59 zcmZ3iwpUGvfq}E9TB#_tEVDQ>KTpZZP-h~m0;AbRwRlb*gs2fr^dS4@G{L=$02O8t A?f?J) delta 37 qcmdn1wpfjofq}EWdh$F@1xC}&`#BG?Z~nqQk8$#RPI)lDjuQapuMB4Z diff --git a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs index 702bc6aab..9b592fdb8 100644 --- a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs +++ b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_attempt.rs @@ -71,6 +71,9 @@ fuzz_target!(|data: &[u8]| { ) else { panic!("valid records are JSON"); }; + let revision = old["revision"].as_u64().expect("old revision"); + assert!(revision < 9_007_199_254_740_991); + assert_eq!(new["revision"].as_u64(), Some(revision + 1)); if from != Stage::Reserved || to != Stage::EntryGranted { assert_eq!(old.get("entry"), new.get("entry"), "entry grant changed"); } diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 4ba0e1c2c..d7fdff8ad 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"fc7861008f4d0a991b7461cef2a9b6a872424f5b8f177561efd248f776bf8ab7"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"607c8538f98554238c1a0dd83e09c1da6198ae72e3ff5870fce93cd54a133445"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"b3cc4dab24c192dc1b2da74797f7be3e1d4d08ec9e6f02ddd7d96b86972df707"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"dd2c2ec65ce92b260d3391fcdc633320940d21dfe2640164d768908b1db5b6de"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3146ff7ac9fb9db2cd6f56a04ae4a53d4d83e772c322fb6373bcc455fe854bc0"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"b72cc8e8a17548c92e0300e27191ee311d3b6ee935d3fe68f7ef973c75b8411f"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2a870baff07f28ef5b38d3111771c744390684feda7a78046d960c6e2bc50c18"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"1293a51118855763f232dc3c143ee4917fe291429e6bbc400f722e3aa23faced"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"83f66e6a1436ef9277ed96ffca24dc2c514f00cd66957a6e696ccb21bb741c2e"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"9625881fb44399a3a1af8d5d57eb9932b2893767b0fcfcb7a853b891852af1ec"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36a740907783c636934d3cdf95d7c53dc04e7752e440f6ce4ca06adb85ce0012"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"91d5179cd0c6dd34212f9231294a1f603490d3db2d54416f288bf64f6c857744"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ee714dd929994be0ad87e6025e7509c1bb5fadaa5caad278df351077bb27548"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"dcb58c43228b145b5405224c77f61bb0858923296872f5288170ba9c6d9d40e3"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"dd2c2ec65ce92b260d3391fcdc633320940d21dfe2640164d768908b1db5b6de"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4f03d8893a8ad762164055f519e74245d35d2cb9d4d700d25a4ab6ac9e90169"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"edaae33b432440ef04681488851cd75c80c6ceef4457bf79757429ed6e717b34"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"3ebd3d4687a472b1f771d3d0467366d9e746bd73fa462e53f4020125e1850313"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"092e10290e9103a141b088a38c71c80f67718e1e644ddbc0e84adb5ca3f711a8"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"80581b4e946732ba2093c6bf1212a4e32cb3af1086a25ce5482891e9bd528b1d"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0f88771f2af4e10933eaed781f1c7c0622af236a667a233afe9e585c30bbca22"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index 6fcf1b1ab..8fb5d077e 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -4,6 +4,7 @@ use super::*; use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; const NOW: u64 = 1_790_000_000; +const RESUMED_AT: u64 = NOW + crate::recipe::ENTRY_DEADLINE_SECONDS + 1; fn approved() -> Arc { let recipe = crate::CompiledRecipe::compile( @@ -31,6 +32,285 @@ fn approved() -> Arc { ) } +fn bounded_approval() -> Arc { + use ed25519_dalek::Signer as _; + let recipes: serde_json::Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" + )) + .expect("recipes"); + let scenarios: serde_json::Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/attempt-scenarios-v3.json" + )) + .expect("scenarios"); + let recipe = crate::CompiledRecipe::compile( + &serde_json::to_vec(&recipes["bases"]["stripe"]["recipe"]).expect("recipe"), + &serde_json::to_vec(&recipes["bases"]["stripe"]["lock"]).expect("lock"), + ) + .expect("compile"); + let mut setup = scenarios["defaults"]["stripe"].clone(); + setup["grant_policy"]["max_count"] = serde_json::json!(1); + setup["grant_policy"]["sum_limit"] = serde_json::json!(500); + let mut arguments = setup["arguments"].as_object().expect("arguments").clone(); + arguments.insert( + "operator_namespace".to_owned(), + serde_json::json!(recipe.namespace().as_str()), + ); + arguments.insert( + "recipe_digest".to_owned(), + serde_json::json!(recipe.digest_hex()), + ); + let command = crate::scenario_tests::admitted( + &recipe, + &arguments, + [11; 32], + Vec::new(), + 3600, + vec![crate::bounds::BoundLink { + subject: crate::harness::Signer::new(0x44).principal, + policy: crate::scenario_tests::policy_from_members(&setup["grant_policy"]), + }], + NOW, + ) + .expect("bounded command"); + let approved = + crate::effect::approve_driver_fixture(command.clone(), *recipe.digest(), NOW, None) + .expect("approval"); + let request = approved + .effect() + .approval_request(NOW, NOW + 5) + .expect("short approval"); + let signature = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("signing message")) + .to_bytes(); + Arc::new( + crate::effect::approve_driver_fixture( + command, + *recipe.digest(), + NOW, + Some(request.with_signature(signature)), + ) + .expect("short approved effect"), + ) +} + +async fn slot_bytes( + store: &TestAttempts, + kind: GatewayRecordKind, + key: [u8; 32], +) -> Option> { + let raw = store.raw(); + tokio::task::spawn_blocking(move || raw.load(kind, &GatewayAttemptKey(key))) + .await + .expect("slot read task") + .expect("slot read") +} + +/// Reopening a reservation retains its one count/sum allocation and initial +/// evidence. Only fresh approval and a new acknowledged revision grant entry. +#[allow( + clippy::too_many_lines, + reason = "one ordered crash/reopen history retains its audit assertions together" +)] +async fn reservation_restart(backend: Backend) -> serde_json::Value { + let store = TestAttempts::open(backend); + let approved = bounded_approval(); + let initial = crate::GatewayPreEntry { + observations: Vec::new(), + basis: Some(crate::GatewayRelativeBasis { + value: 1001, + response_digest: [1; 32], + read_at: NOW, + }), + }; + let fresh = crate::GatewayPreEntry { + observations: Vec::new(), + basis: Some(crate::GatewayRelativeBasis { + value: 1002, + response_digest: [2; 32], + read_at: RESUMED_AT, + }), + }; + let claim = reserved(store.attempts(), &approved) + .await + .record_checkpoint(&initial) + .await + .expect("first checkpoint"); + assert_eq!(claim.attempt.record.revision, 2); + let original_bytes = claim.attempt.stored.clone(); + let original_approval = claim.attempt.record.approval_canonical.clone(); + let recipe_digest = digest_bytes(&claim.attempt.record.recipe_digest).expect("recipe digest"); + let counters = claim.attempt.record.counters().expect("counters"); + assert!(counters.iter().any(|c| c.kind == GatewayCounterKind::Count)); + assert!(counters.iter().any(|c| c.kind == GatewayCounterKind::Sum)); + let slot_keys = counters + .iter() + .map(|counter| match counter.kind { + GatewayCounterKind::Count => ( + GatewayRecordKind::CountSlot, + crate::bounds::count_slot_key(&counter.counter, counter.slot), + ), + GatewayCounterKind::Sum => ( + GatewayRecordKind::SumSlot, + crate::bounds::sum_slot_key(&counter.counter, counter.slot), + ), + }) + .collect::>(); + let mut slots_before = Vec::new(); + for (kind, key) in &slot_keys { + slots_before.push(slot_bytes(&store, *kind, *key).await.expect("allocated")); + } + let stale = stale_copy(&claim); + drop(claim); + let restarted = store.reopen(); + let renewed = Arc::new( + crate::effect::approve_driver_fixture( + approved.command().clone(), + recipe_digest, + RESUMED_AT, + None, + ) + .expect("renewed approval"), + ); + assert_eq!(approved.effect().binding(), renewed.effect().binding()); + let BoundedClaim::Claimed(claim) = restarted + .claim_bounded(&renewed, RESUMED_AT) + .await + .expect("reopen") + else { + panic!("existing reservation must not exhaust again") + }; + assert_eq!(claim.attempt.stored, original_bytes); + assert!( + stale_copy(&claim) + .grant_entry( + Arc::clone(&renewed), + crate::entry::EntryValidation::Oracle { now: RESUMED_AT }, + NOW, + &fresh, + ) + .await + .is_err(), + "original submission deadline cannot authorize a resumed grant" + ); + assert!( + stale_copy(&claim) + .grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: RESUMED_AT }, + RESUMED_AT, + &fresh, + ) + .await + .is_err(), + "expired approval cannot authorize a resumed grant" + ); + let claim = claim + .record_checkpoint(&fresh) + .await + .expect("fresh checkpoint is retained at grant"); + assert_eq!( + claim.attempt.stored, original_bytes, + "first checkpoint remains immutable" + ); + let (granted, permit) = claim + .grant_entry( + Arc::clone(&renewed), + crate::entry::EntryValidation::Oracle { now: RESUMED_AT }, + RESUMED_AT, + &fresh, + ) + .await + .expect("resumed grant"); + drop(permit); + assert_eq!(granted.attempt.record.revision, 3); + assert_eq!(granted.attempt.record.approval_canonical, original_approval); + assert_eq!( + granted + .attempt + .record + .pre_entry + .as_ref() + .expect("initial evidence") + .decode() + .expect("decode"), + initial + ); + let audit = granted.attempt.record.entry.as_ref().expect("grant audit"); + assert_eq!(audit.revision, 3); + assert_eq!(audit.authorization_started_at, RESUMED_AT); + assert_ne!(audit.approval_canonical, original_approval); + assert_eq!( + audit.approval_canonical.as_bytes(), + renewed + .approval() + .to_private_bytes() + .expect("new approval") + .as_slice() + ); + assert_eq!( + audit + .pre_entry + .as_ref() + .expect("fresh evidence") + .decode() + .expect("decode"), + fresh + ); + let snapshot = granted.attempt.record.snapshot(true).expect("snapshot"); + assert_eq!(snapshot.revision(), 3); + assert_eq!(snapshot.pre_entry(), Some(&fresh)); + assert_eq!(snapshot.stage(), GatewayAttemptStage::Unknown); + assert!( + stale + .grant_entry( + Arc::clone(&renewed), + crate::entry::EntryValidation::Oracle { now: RESUMED_AT }, + RESUMED_AT, + &fresh, + ) + .await + .is_err(), + "stale reservation cannot grant again" + ); + assert!(matches!( + restarted.claim_bounded(&renewed, RESUMED_AT).await, + Err(GatewayAttemptError::Replay) + )); + for ((kind, key), before) in slot_keys.iter().zip(&slots_before) { + assert_eq!( + &slot_bytes(&store, *kind, *key).await.expect("retained"), + before + ); + } + for counter in &counters { + let (kind, key) = match counter.kind { + GatewayCounterKind::Count => ( + GatewayRecordKind::CountSlot, + crate::bounds::count_slot_key(&counter.counter, counter.slot + 1), + ), + GatewayCounterKind::Sum => ( + GatewayRecordKind::SumSlot, + crate::bounds::sum_slot_key(&counter.counter, counter.slot + 1), + ), + }; + assert!(slot_bytes(&store, kind, key).await.is_none()); + } + serde_json::json!({ + "initial_revision": 1, "checkpoint_revision": 2, "grant_revision": 3, + "reservation_slots_retained": counters.len(), "additional_slots": 0, + "old_deadline_refused": true, "expired_approval_refused": true, + "stale_grant_refused": true, "initial_evidence_retained": true, + "grant_audit": serde_json::to_value(audit).expect("audit"), + }) +} + +#[tokio::test] +#[ignore = "requires the TLS PostgreSQL fixture"] +async fn postgres_reservation_restart_retains_capacity_and_requires_fresh_approval() { + assert!(postgres_configured()); + reservation_restart(Backend::Postgres).await; +} + async fn reserved( attempts: &GatewayAttempts, approved: &Arc, @@ -54,6 +334,10 @@ fn stale_copy(claim: &ClaimedGatewayAttempt) -> ClaimedGatewayAttempt { } #[tokio::test] +#[allow( + clippy::too_many_lines, + reason = "canonical records and transitions are emitted from the same native grant" +)] async fn native_entry_fixture_is_current() { let store = TestAttempts::open(Backend::File); let approved = approved(); @@ -65,6 +349,8 @@ async fn native_entry_fixture_is_current() { .grant_entry( Arc::clone(&approved), crate::entry::EntryValidation::Oracle { now: NOW }, + NOW, + &crate::GatewayPreEntry::default(), ) .await .expect("grant"); @@ -80,7 +366,9 @@ async fn native_entry_fixture_is_current() { stale .grant_entry( Arc::clone(&approved), - crate::entry::EntryValidation::Oracle { now: NOW } + crate::entry::EntryValidation::Oracle { now: NOW }, + NOW, + &crate::GatewayPreEntry::default(), ) .await .is_err() @@ -96,6 +384,7 @@ async fn native_entry_fixture_is_current() { .expect("retained"); assert_eq!(read.stage(), GatewayAttemptStage::Unknown); let mut next = granted.attempt.record.clone(); + next.revision += 1; next.stage = GatewayAttemptStage::NotEntered; next.refusal = Some("test.no-send".to_owned()); assert!(!valid_transition(&granted.attempt.record, &next).expect("transition")); @@ -105,14 +394,18 @@ async fn native_entry_fixture_is_current() { let mut entry = granted.attempt.record.clone(); entry.nonce = "00112233445566778899aabbccddeeff".to_owned(); let mut reserved = entry.clone(); + reserved.revision = 1; reserved.stage = GatewayAttemptStage::Reserved; reserved.entry = None; let mut refused = reserved.clone(); + refused.revision = 2; refused.stage = GatewayAttemptStage::NotEntered; refused.refusal = Some("test.before-grant".to_owned()); let mut unknown = entry.clone(); + unknown.revision = entry.revision + 1; unknown.stage = GatewayAttemptStage::Unknown; let mut response = entry.clone(); + response.revision = entry.revision + 1; response.stage = GatewayAttemptStage::ResponseRecorded; response.response_status = Some(200); response.response_digest = Some(hex::encode([9; 32])); @@ -155,7 +448,8 @@ async fn native_entry_fixture_is_current() { write_seed(&format!("transition-{name}-synthetic-entry"), &bytes); } let fixture = serde_json::to_vec_pretty(&serde_json::json!({ - "schema": "auths.effect-entry-fixture/1", + "schema": "auths.effect-entry-fixture/2", + "reservation_restart": reservation_restart(Backend::File).await, "scope": "native synthetic post-verification grant; no provider entry or installed authority claim", "reserved_stage": "reserved", "granted_stage": "entry-granted", "restart_projection": "unknown", "second_grant_refused": true, "post_grant_nonentry_refused": true, "entry_audit": audit, @@ -173,14 +467,19 @@ async fn grant_conformance(backend: Backend) { let approved = approved(); let claim = reserved(store.attempts(), &approved).await; let stale = stale_copy(&claim); + let pre_entry = crate::GatewayPreEntry::default(); let (left, right) = tokio::join!( claim.grant_entry( Arc::clone(&approved), - crate::entry::EntryValidation::Oracle { now: NOW } + crate::entry::EntryValidation::Oracle { now: NOW }, + NOW, + &pre_entry, ), stale.grant_entry( Arc::clone(&approved), - crate::entry::EntryValidation::Oracle { now: NOW } + crate::entry::EntryValidation::Oracle { now: NOW }, + NOW, + &pre_entry, ), ); assert_eq!( diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index f1f426219..cdf16b595 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -20,7 +20,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/5"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/6"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/property_tests.rs b/product/runtime/auths-gateway/src/property_tests.rs index c65af08aa..2a74dab4e 100644 --- a/product/runtime/auths-gateway/src/property_tests.rs +++ b/product/runtime/auths-gateway/src/property_tests.rs @@ -317,7 +317,7 @@ proptest! { let stage = if kind == 0 { runtime.block_on(claim.record_not_entered("test.before-grant", None)).map(|snapshot| snapshot.stage()) } else { - let (claim, permit) = runtime.block_on(claim.grant_entry(approved, crate::entry::EntryValidation::Oracle { now: 1_790_000_000 })).expect("grant"); + let (claim, permit) = runtime.block_on(claim.grant_entry(approved, crate::entry::EntryValidation::Oracle { now: 1_790_000_000 }, 1_790_000_000, &crate::GatewayPreEntry::default(),)).expect("grant"); *writes.entry(operation).or_default() += 1; drop(permit); if kind == 1 { runtime.block_on(claim.record_unknown()).map(|snapshot| snapshot.stage()) } diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index f44bc394b..82b978732 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/7"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/5"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/6"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 9a24c1a56..210423290 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/5", + "store_schema": "auths.gateway-attempt/6", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index 45368a891..3a4e94df9 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -788,6 +788,8 @@ async fn response_and_observation_are_distinct_durable_stages() { .grant_entry( approved, crate::entry::EntryValidation::Oracle { now: 1_790_000_000 }, + 1_790_000_000, + &crate::GatewayPreEntry::default(), ) .await .expect("grant"); diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 2aa28b5ef..975af7973 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1359,7 +1359,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/5"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/6"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1488,7 +1488,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/5", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/6", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); @@ -1704,9 +1704,9 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { assert!( matches!( attempts.claim_bounded(&renewed, NOW + 1).await, - Err(GatewayAttemptError::Replay) + Ok(crate::store::BoundedClaim::Claimed(_)) ), - "renewing approval cannot mint another claim" + "renewing approval reopens the reservation without replacing its bytes" ); let mut changed_authority = command.clone(); changed_authority.native_authority = [42; 32]; diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 221bd29a5..87911e48c 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "b92b03244d4f4f5e3d7360f06c2dcbe53d57e294b06f231f6c2706666e0dd801"; + "a6feccfc4aa0f00add3598fc643ea58b5a607847c83650450b403316c9bac899"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 457ae19f2..103445f7a 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/5`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/6`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/5"; +const SCHEMA: &str = "auths.gateway-attempt/6"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -248,6 +248,7 @@ pub fn pre_entry_digest(observations: &[Vec]) -> Option<[u8; 32]> { /// Secret-free persisted evidence for one logical operation. #[derive(Clone, Debug, Eq, PartialEq)] pub struct GatewayAttemptSnapshot { + revision: u64, namespace: OperatorNamespace, operation_id: LogicalOperationId, action_commitment: [u8; 32], @@ -266,6 +267,12 @@ pub struct GatewayAttemptSnapshot { } impl GatewayAttemptSnapshot { + /// Returns the durable journal revision. + #[must_use] + pub const fn revision(&self) -> u64 { + self.revision + } + /// Returns the operator namespace. #[must_use] pub const fn namespace(&self) -> &OperatorNamespace { @@ -478,6 +485,7 @@ impl PreEntryWire { #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct Record { + revision: u64, schema: String, binding_canonical: String, approval_canonical: String, @@ -516,6 +524,10 @@ struct Record { #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct EntryAudit { + revision: u64, + authorization_started_at: u64, + approval_canonical: String, + pre_entry: Option, schema: String, granted_at: u64, effect_id: String, @@ -576,6 +588,7 @@ impl Record { _ => return Err(GatewayAttemptError::Corrupt), }; Ok(AttemptView { + revision: self.revision, entry: self .entry .as_ref() @@ -774,7 +787,11 @@ impl Record { return Err(GatewayAttemptError::Corrupt); } if self.entry.as_ref().is_some_and(|entry| { - entry.schema != "auths.effect-entry/1" + entry.schema != "auths.effect-entry/2" + || entry.revision < 2 + || entry.revision > self.revision + || entry.authorization_started_at < self.evaluated_at + || entry.granted_at < entry.authorization_started_at || entry.granted_at < self.evaluated_at || entry.granted_at > MAX_JSON_INTEGER || entry.effect_id != hex::encode(binding.id().as_bytes()) @@ -786,6 +803,17 @@ impl Record { }) { return Err(GatewayAttemptError::Corrupt); } + if let Some(entry) = &self.entry { + let approval = + ExactEffectApproval::from_private_bytes(entry.approval_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + binding + .validate_recorded_approval(&approval, entry.granted_at) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if let Some(pre_entry) = &entry.pre_entry { + pre_entry.decode()?; + } + } if self.schema != SCHEMA || self.nonce.len() != 32 || !self @@ -829,11 +857,13 @@ impl Record { None => None, }; let pre_entry = self - .pre_entry + .entry .as_ref() + .map_or(self.pre_entry.as_ref(), |entry| entry.pre_entry.as_ref()) .map(PreEntryWire::decode) .transpose()?; Ok(GatewayAttemptSnapshot { + revision: self.revision, namespace, operation_id, action_commitment, @@ -1837,6 +1867,7 @@ fn claim_record( let mut nonce = [0_u8; 16]; getrandom::fill(&mut nonce).map_err(|_| GatewayAttemptError::Unavailable)?; let record = Record { + revision: 1, schema: SCHEMA.to_owned(), binding_canonical: String::from_utf8( binding @@ -2165,7 +2196,12 @@ struct Attempt { impl Attempt { /// Persists `next` only as a valid stage change from the exact stored /// record; a concurrent change by another process is a conflict. - async fn advance(mut self, next: Record) -> Result { + async fn advance(mut self, mut next: Record) -> Result { + next.revision = self + .record + .revision + .checked_add(1) + .ok_or(GatewayAttemptError::InvalidTransition)?; if !valid_transition(&self.record, &next)? { return Err(GatewayAttemptError::InvalidTransition); } @@ -2196,7 +2232,10 @@ impl ClaimedGatewayAttempt { self, approved: Arc, validation: crate::entry::EntryValidation, + authorization_started_at: u64, + pre_entry: &GatewayPreEntry, ) -> Result<(Self, ProviderEntryPermit), GatewayAttemptError> { + let pre_entry = PreEntryWire::encode(pre_entry)?; blocking(move || { let mut attempt = self.attempt; let dependencies = validation.dependencies(); @@ -2244,7 +2283,7 @@ impl ClaimedGatewayAttempt { .validate( &approved, &snapshots[1..dependency_end], - current.evaluated_at, + authorization_started_at, ) .map_err(|_| GatewayAttemptError::InvalidTransition)?; current.validate_reservations( @@ -2253,10 +2292,28 @@ impl ClaimedGatewayAttempt { &snapshots[dependency_end..], now, )?; + if authorization_started_at < current.evaluated_at { + return Err(GatewayAttemptError::InvalidTransition); + } let mut next = current.clone(); + next.revision = current + .revision + .checked_add(1) + .ok_or(GatewayAttemptError::InvalidTransition)?; next.stage = GatewayAttemptStage::EntryGranted; next.entry = Some(EntryAudit { - schema: "auths.effect-entry/1".to_owned(), + revision: next.revision, + authorization_started_at, + pre_entry: pre_entry.clone(), + approval_canonical: String::from_utf8( + approved + .approval() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, + schema: "auths.effect-entry/2".to_owned(), granted_at: now, effect_id: hex::encode(approved.effect().binding().id().as_bytes()), dependencies: snapshots[1..dependency_end] @@ -2290,13 +2347,22 @@ impl ClaimedGatewayAttempt { /// lease: the pre-entry observations and the relative-ceiling basis. /// /// # Errors - /// Rejects an empty or repeated checkpoint and persistence failure. + /// Rejects an empty first checkpoint, post-grant calls and persistence failure. + /// A resumed reservation retains its first checkpoint; its fresh reads are + /// separately bound in the immutable entry audit. pub async fn record_checkpoint( self, pre_entry: &GatewayPreEntry, ) -> Result { + if self.attempt.record.stage != GatewayAttemptStage::Reserved { + return Err(GatewayAttemptError::InvalidTransition); + } + let fresh = PreEntryWire::encode(pre_entry)?; + if self.attempt.record.pre_entry.is_some() { + return Ok(self); + } let mut next = self.attempt.record.clone(); - next.pre_entry = PreEntryWire::encode(pre_entry)?; + next.pre_entry = fresh; Ok(Self { attempt: self.attempt.advance(next).await?, }) @@ -2863,12 +2929,53 @@ impl GatewayAttempts { /// Slots are never released, and a replay consumes none. /// /// # Errors - /// An identical binding is `Replay`; a different binding for the same - /// operation is `BindingConflict`. Store errors never authorize entry. + /// An identical reserved binding reopens without another charge. An existing + /// grant or terminal operation is `Replay`; a changed binding is + /// `BindingConflict`. Reopening itself never authorizes provider entry. pub(crate) async fn claim_bounded( &self, approved: &ApprovedEffect, evaluated_at: u64, + ) -> Result { + match self.claim_new_bounded(approved, evaluated_at).await { + Err(GatewayAttemptError::Replay) => { + let request = &approved.command().request; + let (stored, record) = self + .load(request.namespace(), request.operation_id()) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + if record.binding_canonical.as_bytes() + != approved + .effect() + .binding() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + if record.stage != GatewayAttemptStage::Reserved { + return Err(GatewayAttemptError::Replay); + } + // This handle grants no entry. A fresh fenced CAS still checks + // native authority, approval and every retained slot. + Ok(BoundedClaim::Claimed(Box::new(ClaimedGatewayAttempt { + attempt: Attempt { + store: Arc::clone(&self.store), + key: self.key(request.namespace(), request.operation_id())?, + stored, + record, + }, + }))) + } + result => result, + } + } + + async fn claim_new_bounded( + &self, + approved: &ApprovedEffect, + evaluated_at: u64, ) -> Result { let command = approved.command(); let request = &command.request; diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 343084920..8aff748b4 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -555,7 +555,7 @@ impl Run<'_, I> { { Ok(BoundedClaim::Claimed(claim)) => { self.claim = Some(*claim); - ClaimResult::Inserted + ClaimResult::Reserved } Ok(BoundedClaim::Exhausted(code)) => { self.result = Some(not_entered(code)); @@ -730,7 +730,12 @@ impl Run<'_, I> { return false; }; let (claim, permit) = match claim - .grant_entry(std::sync::Arc::clone(approved), validation) + .grant_entry( + std::sync::Arc::clone(approved), + validation, + self.evaluated_at, + &self.pre_entry, + ) .await { Ok(granted) => granted, diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index b88f3ed9f..d76e5bf99 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -660,6 +660,8 @@ mod tests { .grant_entry( std::sync::Arc::clone(&approved), crate::entry::EntryValidation::Oracle { now: 1000 }, + 1000, + &crate::GatewayPreEntry::default(), ) .await .expect("durable grant"); From a4d4bb041c05aa53c00f5427d33b31ce2e3ad758 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 04:24:50 +0000 Subject: [PATCH 019/136] chore(formal): regenerate qualification artifacts Source-SHA: 6d38bb1c6a58c3d66e887e0ff083791b1d1a04f6 Workflow-Run: 40631903601 --- formal/qualification/aeneas/source-closure.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 067fd5515..4c292cfec 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "e7c4c784f4842b7b862e201cc37f6186532262d81868c24f30ed7cac6f736af5", + "digest": "25cbca328f1e7d342069591491bf713c80cfad76f1887f89a47d6a2b88672147", "files": [ { "path": ".cargo/config.toml", @@ -189,7 +189,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/order.rs", - "sha256": "fc7861008f4d0a991b7461cef2a9b6a872424f5b8f177561efd248f776bf8ab7" + "sha256": "407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709" }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", @@ -205,7 +205,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/transition.rs", - "sha256": "607c8538f98554238c1a0dd83e09c1da6198ae72e3ff5870fce93cd54a133445" + "sha256": "f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584" }, { "path": "product/runtime/auths-lifecycle/Cargo.toml", From ed907973e539b2c5a98ee88865adf08749e293b6 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 04:49:34 +0000 Subject: [PATCH 020/136] feat(gateway)!: require complete native effect review contracts --- .../fixtures/gateway/airtable/recipe.json | 74 +++- .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 406 +++++++++++++++++- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/effect-review-contract.json | 155 +++++++ bindings/fixtures/gateway/github/recipe.json | 52 ++- .../fixtures/gateway/hostile-recipes-v2.json | 228 ++++++++-- bindings/fixtures/gateway/todoist/recipe.json | 82 +++- .../fixtures/openapi-derivation/README.md | 19 +- .../airtable-set-demo-status/derivation.json | 2 +- .../airtable-set-demo-status/recipe.json | 16 +- .../airtable-set-demo-status/report.txt | 1 + .../airtable-set-demo-status/review.json | 20 +- .../derivation.json | 2 +- .../recipe.json | 16 +- .../report.txt | 1 + .../review.json | 20 +- .../github-issues-create/derivation.json | 2 +- .../expected/github-issues-create/recipe.json | 20 +- .../expected/github-issues-create/report.txt | 1 + .../expected/github-issues-create/review.json | 24 +- .../hostile-fractional-bounds/derivation.json | 2 +- .../hostile-fractional-bounds/recipe.json | 13 +- .../hostile-fractional-bounds/report.txt | 1 + .../hostile-fractional-bounds/review.json | 17 +- .../derivation.json | 2 +- .../hostile-integer-path-fixed/recipe.json | 12 +- .../hostile-integer-path-fixed/report.txt | 1 + .../hostile-integer-path-fixed/review.json | 16 +- .../derivation.json | 2 +- .../hostile-literal-enum-member/recipe.json | 12 +- .../hostile-literal-enum-member/report.txt | 1 + .../hostile-literal-enum-member/review.json | 16 +- .../expected/hostile-recipe-limit/report.txt | 2 +- .../minimal-create-note/derivation.json | 2 +- .../expected/minimal-create-note/recipe.json | 33 +- .../expected/minimal-create-note/report.txt | 1 + .../expected/minimal-create-note/review.json | 37 +- .../minimal-rename-note-form/derivation.json | 2 +- .../minimal-rename-note-form/recipe.json | 21 +- .../minimal-rename-note-form/report.txt | 1 + .../minimal-rename-note-form/review.json | 25 +- .../minimal-set-label/derivation.json | 2 +- .../expected/minimal-set-label/recipe.json | 16 +- .../expected/minimal-set-label/report.txt | 1 + .../expected/minimal-set-label/review.json | 20 +- .../derivation.json | 2 +- .../openai-create-vector-store/recipe.json | 12 +- .../openai-create-vector-store/report.txt | 1 + .../openai-create-vector-store/review.json | 16 +- .../todoist-create-task/derivation.json | 2 +- .../expected/todoist-create-task/recipe.json | 12 +- .../expected/todoist-create-task/report.txt | 1 + .../expected/todoist-create-task/review.json | 16 +- .../derivation.json | 2 +- .../recipe.json | 16 +- .../report.txt | 1 + .../review.json | 20 +- .../todoist-rest-create-task/derivation.json | 2 +- .../todoist-rest-create-task/recipe.json | 12 +- .../todoist-rest-create-task/report.txt | 1 + .../todoist-rest-create-task/review.json | 16 +- .../stripe-refund-approval/recipe/recipe.json | 173 +++++++- compliance.toml | 15 +- demos/airtable-gateway/recipe.json | 18 +- demos/stripe-gateway/recipe.json | 24 +- ...017-bound-effect-and-recovery-ownership.md | 26 ++ docs/plans/0074-implementation-status.md | 107 +++-- .../0009-bound-effect-and-recovery.md | 11 + ...ound-effects-and-recovery-state-machine.md | 13 + examples/stripe-refund-approval/recipe.json | 173 +++++++- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6459 -> 6463 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6342 -> 6346 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5620 -> 5621 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4925 -> 4923 bytes .../corpus/target_gateway_recipe/airtable | Bin 1955 -> 2708 bytes .../fuzz/corpus/target_gateway_recipe/github | Bin 1397 -> 2008 bytes .../stripe-refund-approval | Bin 3214 -> 4978 bytes .../fuzz/corpus/target_gateway_recipe/todoist | Bin 1937 -> 2907 bytes .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 15 +- product/runtime/auths-gateway/src/effect.rs | 74 +++- .../auths-gateway/src/effect_native_tests.rs | 30 +- product/runtime/auths-gateway/src/harness.rs | 3 +- .../src/pending_vectors/recipes.rs | 29 +- product/runtime/auths-gateway/src/recipe.rs | 18 +- .../auths-gateway/src/recipe/effect_review.rs | 165 +++++++ .../auths-gateway/src/recipe/review.rs | 7 +- .../auths-gateway/src/recipe/source.rs | 3 +- .../runtime/auths-gateway/src/recipe/tests.rs | 137 +++++- .../auths-gateway/src/semantic_closure.rs | 2 +- product/tools/auths-openapi-derive/src/lib.rs | 6 +- .../tools/auths-openapi-derive/src/render.rs | 22 +- .../auths-openapi-derive/tests/corpus.rs | 43 +- qualification/reference/packet_plan.py | 2 +- .../live/stripe-platform/recipe.json | 24 +- 102 files changed, 2427 insertions(+), 268 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-review-contract.json create mode 100644 product/runtime/auths-gateway/src/recipe/effect_review.rs diff --git a/bindings/fixtures/gateway/airtable/recipe.json b/bindings/fixtures/gateway/airtable/recipe.json index 6d753f87c..6738c12e8 100644 --- a/bindings/fixtures/gateway/airtable/recipe.json +++ b/bindings/fixtures/gateway/airtable/recipe.json @@ -1,18 +1,32 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", "operator_namespace": "airtable-demo", - "credential": {"kind": "bearer"}, + "credential": { + "kind": "bearer" + }, "origin": "https://api.airtable.com", "write": { "method": "PATCH", "path": [ - {"kind": "fixed", "value": "v0"}, - {"kind": "fixed", "value": "appTEST0000000001"}, - {"kind": "fixed", "value": "tblTEST0000000001"}, - {"kind": "field", "name": "record_id"} + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appTEST0000000001" + }, + { + "kind": "fixed", + "value": "tblTEST0000000001" + }, + { + "kind": "field", + "name": "record_id" + } ], "body": { "kind": "json", @@ -21,7 +35,12 @@ "fields": { "fields": { "kind": "object", - "fields": {"DemoStatus": {"kind": "field", "name": "replacement"}} + "fields": { + "DemoStatus": { + "kind": "field", + "name": "replacement" + } + } } } } @@ -29,17 +48,48 @@ }, "observation": { "path": [ - {"kind": "fixed", "value": "v0"}, - {"kind": "fixed", "value": "appTEST0000000001"}, - {"kind": "fixed", "value": "tblTEST0000000001"}, - {"kind": "field", "name": "record_id"} + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appTEST0000000001" + }, + { + "kind": "fixed", + "value": "tblTEST0000000001" + }, + { + "kind": "field", + "name": "record_id" + } ], "json_pointer": "/fields/DemoStatus", "expected_field": "replacement", "maximum_response_bytes": 16384 }, "echo": { - "write": {"kind": "json-pointer", "pointer": "/fields/auths_echo"}, + "write": { + "kind": "json-pointer", + "pointer": "/fields/auths_echo" + }, "observe": "/fields/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } } } diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 69ca70e3a..6637a9ad4 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 8a8a7464a..7b14a9f5c 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"btcyTvL9Z5CXR0v4Q-jUKDfIRYiAolqpurmQFQcBKfcFlm3ExTmW8vXXSzrexPXn_j_Q8-3bG_mTZVVcWWZfAQ"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"Uoj3JjEIvCgS6KgjJMH4AJUwriSj7OPkKaJe6YQcGO_oGRqebSbrNv3ZZby3lSA1FXDWFZ7vj73MYn4lIubxCg"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 07f697151..878474684 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -1,15 +1,409 @@ { - "schema": "auths.effect-fixture/1", + "schema": "auths.effect-fixture/2", + "private_review": { + "binding": { + "action": [ + 219, + 243, + 122, + 229, + 143, + 29, + 19, + 240, + 24, + 237, + 170, + 175, + 210, + 164, + 29, + 59, + 66, + 162, + 74, + 103, + 67, + 79, + 155, + 221, + 113, + 192, + 76, + 90, + 209, + 8, + 239, + 133 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/3", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 91, + 45, + 36, + 252, + 80, + 62, + 186, + 89, + 20, + 225, + 233, + 127, + 185, + 175, + 28, + 222, + 171, + 0, + 62, + 94, + 35, + 57, + 163, + 66, + 193, + 2, + 220, + 223, + 114, + 143, + 9, + 14 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "observer-demo", + "native_authority": [ + 12, + 223, + 7, + 218, + 165, + 63, + 40, + 255, + 24, + 196, + 38, + 32, + 163, + 189, + 22, + 212, + 80, + 171, + 110, + 200, + 136, + 172, + 112, + 195, + 198, + 191, + 162, + 85, + 246, + 209, + 25, + 182 + ], + "operation": "bound-native-1", + "partition": "synthetic-partition", + "protocol": { + "kind": "mutation", + "request": [ + 246, + 40, + 160, + 130, + 141, + 190, + 67, + 73, + 36, + 122, + 136, + 120, + 45, + 200, + 112, + 63, + 63, + 208, + 224, + 162, + 81, + 191, + 76, + 102, + 28, + 45, + 211, + 67, + 39, + 95, + 101, + 222 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 35, + 115, + 55, + 47, + 0, + 150, + 49, + 135, + 103, + 9, + 208, + 125, + 94, + 182, + 6, + 172, + 251, + 207, + 120, + 195, + 131, + 70, + 177, + 24, + 159, + 158, + 208, + 23, + 9, + 217, + 23, + 89 + ], + "reservations": [], + "schema": "auths.bound-effect/2", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85", + "actors": [ + "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw" + ], + "arguments": { + "operation_id": "bound-native-1", + "operator_namespace": "observer-demo", + "recipe_digest": "2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759", + "record_id": "recTEST0000000001", + "replacement": "private-sentinel-‮Approved" + }, + "request": { + "body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", + "content_type": "application/json", + "headers": [], + "idempotency_key": null, + "method": "PATCH", + "url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001" + }, + "schema": "auths.gateway-submission-review/1" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "contract": { + "consequences": [ + "Synthetic fixture mutation; no production semantics or human-review claim." + ], + "fields": [ + { + "argument": "record_id", + "kind": "text", + "label": "record_id", + "value": "recTEST0000000001" + }, + { + "argument": "replacement", + "kind": "text", + "label": "replacement", + "value": "private-sentinel-‮Approved" + } + ], + "presentation": "literal-complete-values/1", + "schema": "auths.effect-review-contract/1" + }, + "recipe": { + "account_scope": null, + "bounds": null, + "credential": { + "kind": "bearer" + }, + "credential_guard": null, + "digest": "2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759", + "echo": { + "disclosure": "the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets", + "kind": "json-pointer", + "observe": "/fields/auths_echo", + "write": "/fields/auths_echo" + }, + "effect_review_contract": { + "consequences": [ + "Synthetic fixture mutation; no production semantics or human-review claim." + ], + "fields": { + "record_id": { + "kind": "text", + "label": "record_id" + }, + "replacement": { + "kind": "text", + "label": "replacement" + } + }, + "schema": "auths.effect-review-contract/1" + }, + "has_observation": true, + "idempotency": null, + "maximum_body_bytes": 16384, + "method": "PATCH", + "observation": { + "expected_field": "replacement", + "json_pointer": "/fields/DemoStatus", + "locator": "verified-locator", + "maximum_response_bytes": 16384, + "path": [ + "v0", + "appTEST0000000001", + "tblTEST0000000001", + "" + ] + }, + "operator_namespace": "observer-demo", + "origin": "https://api.airtable.com", + "path": [ + "v0", + "appTEST0000000001", + "tblTEST0000000001", + "" + ], + "pre_entry": null, + "preconditions": null, + "provider_headers": null, + "recovery": { + "class": "linked", + "lost_claim_reentry": { + "deduplication": "none" + }, + "pre_entry_reread": false, + "provider_link": "verified-locator", + "schema": "auths.gateway-recovery-capability/1", + "state_observation": "verified-locator", + "unknown_resolution": "gateway-reobservation", + "write_is_conditional": false + }, + "relative_ceiling": null, + "schema": "auths.gateway-recipe-review/3", + "sends_idempotency_key": false, + "service": "gateway-observer-test", + "tool": "set_status_v1", + "write_is_conditional": false + }, + "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." + } + }, + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/3\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/2\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/2\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/3\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 246,\n 40,\n 160,\n 130,\n 141,\n 190,\n 67,\n 73,\n 36,\n 122,\n 136,\n 120,\n 45,\n 200,\n 112,\n 63,\n 63,\n 208,\n 224,\n 162,\n 81,\n 191,\n 76,\n 102,\n 28,\n 45,\n 211,\n 67,\n 39,\n 95,\n 101,\n 222\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "a347c831aca019b89c21aee5afdd929915b0c15402125539c5e11109ada86b0d", + "effect_id_hex": "0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[130,155,174,42,161,212,222,153,202,43,10,122,87,97,242,35,27,223,112,47,125,115,208,48,115,251,106,13,76,12,240,142],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[84,123,152,238,89,4,230,133,112,194,246,32,202,254,47,205,177,99,33,243,125,34,37,69,106,219,38,241,75,213,43,35],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[193,217,12,57,120,59,81,187,101,197,67,79,50,171,103,204,73,150,97,36,251,157,111,73,52,61,93,202,254,31,40,162],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[43,38,114,196,183,50,144,76,215,249,233,36,35,247,40,103,124,60,28,79,139,77,216,235,230,90,48,212,198,93,122,100]},\"qualification_policy\":\"optional\",\"recipe\":[207,200,179,182,92,125,118,36,245,192,56,244,158,141,121,135,43,50,81,109,250,115,160,58,153,160,42,118,35,205,44,193],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[163,71,200,49,172,160,25,184,156,33,174,229,175,221,146,153,21,176,193,84,2,18,85,57,197,225,17,9,173,168,107,13],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"btcyTvL9Z5CXR0v4Q-jUKDfIRYiAolqpurmQFQcBKfcFlm3ExTmW8vXXSzrexPXn_j_Q8-3bG_mTZVVcWWZfAQ\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Uoj3JjEIvCgS6KgjJMH4AJUwriSj7OPkKaJe6YQcGO_oGRqebSbrNv3ZZby3lSA1FXDWFZ7vj73MYn4lIubxCg\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", - "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-Approved\",\"auths_echo\":\"auths-e1-e38d866bf40628b9f92313a8dc13515ad20b2b63498935834e2c6c3435545424\"}}", + "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJjZmM4YjNiNjVjN2Q3NjI0ZjVjMDM4ZjQ5ZThkNzk4NzJiMzI1MTZkZmE3M2EwM2E5OWEwMmE3NjIzY2QyY2MxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwtQXBwcm92ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxNjMsNzEsMjAwLDQ5LDE3MiwxNjAsMjUsMTg0LDE1NiwzMywxNzQsMjI5LDE3NSwyMjEsMTQ2LDE1MywyMSwxNzYsMTkzLDg0LDIsMTgsODUsNTcsMTk3LDIyNSwxNyw5LDE3MywxNjgsMTA3LDEzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImJ0Y3lUdkw5WjVDWFIwdjRRLWpVS0RmSVJZaUFvbHFwdXJtUUZRY0JLZmNGbG0zRXhUbVc4dlhYU3pyZXhQWG5fal9ROC0zYkdfbVRaVlZjV1daZkFRIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIFB1dw6IqVrQ58Oi4P9Re7Ve2MLzFoKpRm-DZAL7NYcvBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAER3htVt3Aoh5hFUwCLzv5OAc6-IN2aZFFm_1p6QH1o0ziEHaxjl3CForY3H-8nhNwDdp-aOC2bQioKpKcpDIPA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg5OBIkJBwGBaheSXK-uLktL2erWkN-lSFRHqnoPFlmWgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFUeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImNmYzhiM2I2NWM3ZDc2MjRmNWMwMzhmNDllOGQ3OTg3MmIzMjUxNmRmYTczYTAzYTk5YTAyYTc2MjNjZDJjYzEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC1BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMywyNTMsMjM1LDEwMywyOCwxMTAsNTIsMTMsOTIsNzEsMjM3LDE4MCwxNDgsMTMsOTEsNzQsMTU3LDUxLDk0LDI1NCwzNSwyMywyNDAsOTEsMTEsMTExLDkxLDE4OCwxNywxNjAsMTYxLDI0MF0sImV4cGlyZXNfYXQiOjE3OTAwMDAwMzAsIm5vdF9iZWZvcmUiOjE3OTAwMDAwMDAsInNjaGVtYSI6ImF1dGhzLmV4YWN0LWVmZmVjdC1hcHByb3ZhbC8xIn0sInNpZ25hdHVyZV9iNjQiOiJVb2ozSmpFSXZDZ1M2S2dqSk1INEFKVXdyaVNqN09Qa0thSmU2WVFjR09fb0dScWViU2JyTnYzWlpieTNsU0ExRlhEV0ZaN3ZqNzNNWW40bEl1YnhDZyJ9\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index c8bc81f2f..3899d3308 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[14,37,23,217,26,34,199,14,199,18,19,17,88,100,209,190,194,226,162,253,36,175,178,129,180,51,83,114,24,48,54,217],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"g-bxBML0YxjfGnvQlVDvMQGUFxWsq-D2pzNQb0bT2fD8bkZ7v6POjxdhaqIbLzZSF-jGOM-Bgfi7MS6MjtcZAg\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[233,67,145,200,208,36,229,168,205,199,223,16,210,155,139,10,124,154,212,72,237,77,184,74,193,81,246,219,238,68,101,109],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"JK31EZbyaZbt41lSI61WQXgMhhM4xi7BNZdEuJy_dgwLAUVhMNUTyu9YKntacl6kxfCDiAebEg_s73ZiKkkSBw\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "0e2517d91a22c70ec71213115864d1bec2e2a2fd24afb281b4335372183036d9", + "effect_id": "e94391c8d024e5a8cdc7df10d29b8b0a7c9ad448ed4db84ac151f6dbee44656d", "dependencies": [] } }, @@ -36,11 +36,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3", + "effect_id": "84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-review-contract.json b/bindings/fixtures/gateway/effect-review-contract.json new file mode 100644 index 000000000..abaa6826f --- /dev/null +++ b/bindings/fixtures/gateway/effect-review-contract.json @@ -0,0 +1,155 @@ +{ + "schema": "auths.effect-review-contract-fixture/1", + "profile_lock": { + "command_schema": { + "fields": { + "operation_id": { + "kind": "string", + "maximum": 128, + "minimum": 1 + }, + "operator_namespace": { + "type": "enum", + "variants": [ + "airtable-demo" + ] + }, + "recipe_digest": { + "kind": "string", + "maximum": 64, + "minimum": 64 + }, + "record_id": { + "kind": "string", + "maximum": 43, + "minimum": 17 + }, + "replacement": { + "type": "enum", + "variants": [ + "Approved", + "Pending" + ] + } + }, + "kind": "object" + }, + "generator_format": 2, + "profile": "airtable-gateway-record-update", + "schema": "auths.self-hosted-profile-lock/1", + "schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", + "service": "airtable-gateway-demo", + "tool": "set_demo_status_v1", + "version": 1 + }, + "source_schema": "auths.gateway-recipe-source/3", + "review_schema": "auths.gateway-recipe-review/3", + "accepted": { + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } + }, + "digest": "64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9", + "operator_namespace": "airtable-demo", + "service": "airtable-gateway-demo", + "tool": "set_demo_status_v1", + "origin": "https://api.airtable.com", + "method": "PATCH", + "path": [ + "v0", + "appTEST0000000001", + "tblTEST0000000001", + "" + ], + "credential": { + "kind": "bearer" + }, + "maximum_body_bytes": 16384, + "has_observation": true, + "sends_idempotency_key": false, + "echo": { + "kind": "json-pointer", + "write": "/fields/auths_echo", + "observe": "/fields/auths_echo", + "disclosure": "the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets" + }, + "preconditions": null, + "recovery": { + "schema": "auths.gateway-recovery-capability/1", + "class": "linked", + "state_observation": "verified-locator", + "provider_link": "verified-locator", + "unknown_resolution": "gateway-reobservation", + "lost_claim_reentry": { + "deduplication": "none" + }, + "pre_entry_reread": false, + "write_is_conditional": false + }, + "write_is_conditional": false, + "provider_headers": null, + "credential_guard": null, + "idempotency": null, + "observation": { + "locator": "verified-locator", + "path": [ + "v0", + "appTEST0000000001", + "tblTEST0000000001", + "" + ], + "json_pointer": "/fields/DemoStatus", + "expected_field": "replacement", + "maximum_response_bytes": 16384 + }, + "pre_entry": null, + "account_scope": null, + "relative_ceiling": null, + "bounds": null + }, + "rejected": [ + { + "name": "unsupported-version", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/999\",\"consequences\":[\"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"],\"fields\":{\"record_id\":{\"kind\":\"identifier\",\"label\":\"Record id\"},\"replacement\":{\"kind\":\"text\",\"label\":\"Replacement\"}}}}", + "code": "gateway.recipe.invalid-source" + }, + { + "name": "missing-field", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"],\"fields\":{}}}", + "code": "gateway.recipe.invalid-source" + }, + { + "name": "missing-consequences", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[],\"fields\":{\"record_id\":{\"kind\":\"identifier\",\"label\":\"Record id\"},\"replacement\":{\"kind\":\"text\",\"label\":\"Replacement\"}}}}", + "code": "gateway.recipe.invalid-source" + }, + { + "name": "misleading-control", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"],\"fields\":{\"record_id\":{\"kind\":\"identifier\",\"label\":\"Record id\"},\"replacement\":{\"kind\":\"text\",\"label\":\"Status\\nDestination: misleading\"}}}}", + "code": "gateway.recipe.invalid-source" + }, + { + "name": "wrong-type", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"],\"fields\":{\"record_id\":{\"kind\":\"identifier\",\"label\":\"Record id\"},\"replacement\":{\"kind\":\"integer\",\"label\":\"Replacement\",\"unit\":\"count\"}}}}", + "code": "gateway.recipe.invalid-source" + }, + { + "name": "duplicate-field", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29\",\"service\":\"airtable-gateway-demo\",\"tool\":\"set_demo_status_v1\",\"operator_namespace\":\"airtable-demo\",\"credential\":{\"kind\":\"bearer\"},\"origin\":\"https://api.airtable.com\",\"write\":{\"method\":\"PATCH\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"body\":{\"kind\":\"json\",\"value\":{\"kind\":\"object\",\"fields\":{\"fields\":{\"kind\":\"object\",\"fields\":{\"DemoStatus\":{\"kind\":\"field\",\"name\":\"replacement\"}}}}}}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v0\"},{\"kind\":\"fixed\",\"value\":\"appTEST0000000001\"},{\"kind\":\"fixed\",\"value\":\"tblTEST0000000001\"},{\"kind\":\"field\",\"name\":\"record_id\"}],\"json_pointer\":\"/fields/DemoStatus\",\"expected_field\":\"replacement\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"json-pointer\",\"pointer\":\"/fields/auths_echo\"},\"observe\":\"/fields/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"],\"fields\":{\"replacement\":{\"kind\":\"text\",\"label\":\"Replacement\"},\"record_id\":{\"kind\":\"identifier\",\"label\":\"Record id\"},\"replacement\":{\"kind\":\"text\",\"label\":\"Replacement\"}}}}", + "code": "gateway.recipe.invalid-source" + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/github/recipe.json b/bindings/fixtures/gateway/github/recipe.json index 9affd734d..9bf0e7fc0 100644 --- a/bindings/fixtures/gateway/github/recipe.json +++ b/bindings/fixtures/gateway/github/recipe.json @@ -1,28 +1,64 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "2f9c472c3681a7c7a80f6dcf057f614adbc7126f5414ca2d19c770cd050ad71f", "service": "github-gateway-demo", "tool": "create_issue_v1", "operator_namespace": "github-demo", - "credential": {"kind": "bearer"}, + "credential": { + "kind": "bearer" + }, "origin": "https://api.github.com", "write": { "method": "POST", "path": [ - {"kind": "fixed", "value": "repos"}, - {"kind": "fixed", "value": "auths-dev"}, - {"kind": "fixed", "value": "gateway-fixture-repo"}, - {"kind": "fixed", "value": "issues"} + { + "kind": "fixed", + "value": "repos" + }, + { + "kind": "fixed", + "value": "auths-dev" + }, + { + "kind": "fixed", + "value": "gateway-fixture-repo" + }, + { + "kind": "fixed", + "value": "issues" + } ], "body": { "kind": "json", "value": { "kind": "object", "fields": { - "title": {"kind": "field", "name": "title"}, - "body": {"kind": "field", "name": "body"} + "title": { + "kind": "field", + "name": "title" + }, + "body": { + "kind": "field", + "name": "body" + } } } } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create an issue in the repository identified by the complete destination URL, using the displayed title and body. The issue may be visible to repository readers." + ], + "fields": { + "body": { + "kind": "text", + "label": "Body" + }, + "title": { + "kind": "text", + "label": "Title" + } + } } } diff --git a/bindings/fixtures/gateway/hostile-recipes-v2.json b/bindings/fixtures/gateway/hostile-recipes-v2.json index 0a29c7787..a8cd89e74 100644 --- a/bindings/fixtures/gateway/hostile-recipes-v2.json +++ b/bindings/fixtures/gateway/hostile-recipes-v2.json @@ -1,10 +1,10 @@ { "schema": "auths.gateway-hostile-recipes/2", - "source_schema": "auths.gateway-recipe-source/2", + "source_schema": "auths.gateway-recipe-source/3", "bases": { "airtable": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", @@ -80,6 +80,22 @@ "pointer": "/fields/auths_echo" }, "observe": "/fields/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } } }, "lock": { @@ -136,11 +152,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1" + "digest": "64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9" }, "airtable-pre-entry": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "18c3621ff65c6f326bae155b0a9e984cc8ab97e03f75ec428b2d18ffda1b064a", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", @@ -217,6 +233,30 @@ }, "observe": "/fields/auths_echo" }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + }, + "expected": { + "kind": "text", + "label": "expected" + }, + "record_uri": { + "kind": "text", + "label": "record_uri" + } + } + }, "preconditions": { "read_back_subject": "record_uri", "verified": [ @@ -314,11 +354,11 @@ "pre_entry_reread": true, "write_is_conditional": false }, - "digest": "27f8339d08701cd0b7955edc54ee21bf5ce355705aa93034284ac2d20289d70e" + "digest": "f42f96dc883881beaddd2c8a72f45cfde577fb0532558664517407f2d6c4693e" }, "todoist": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d2929455f9e255caf23629daa0db125c73565a2a55b4db13fbe0fbea731d10f3", "service": "todoist-gateway-demo", "tool": "create_task_v1", @@ -386,6 +426,26 @@ } } } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create one task with the displayed content at the displayed destination. Provider-side notification and visibility rules still apply." + ], + "fields": { + "content": { + "kind": "text", + "label": "Content" + }, + "description": { + "kind": "text", + "label": "Description" + }, + "temp_id": { + "kind": "identifier", + "label": "Temp id" + } + } } }, "lock": { @@ -445,11 +505,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "3c5a6e4dfed46131f7882f697a70e7bb22e06cbf6d717f7182f0fedebe8a2f5b" + "digest": "a6e5dbfda065e10be581d238d1c1a45d6aca0b90850d944a69f7d53667883f2e" }, "todoist-operation-id": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d2929455f9e255caf23629daa0db125c73565a2a55b4db13fbe0fbea731d10f3", "service": "todoist-gateway-demo", "tool": "create_task_v1", @@ -525,6 +585,26 @@ }, "retention_seconds": 3600 } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create one task with the displayed content at the displayed destination. Provider-side notification and visibility rules still apply." + ], + "fields": { + "content": { + "kind": "text", + "label": "Content" + }, + "description": { + "kind": "text", + "label": "Description" + }, + "temp_id": { + "kind": "identifier", + "label": "Temp id" + } + } } }, "lock": { @@ -587,11 +667,11 @@ "write_is_conditional": false }, "note": "retention_seconds is a fixture value, not a statement of the provider's retention", - "digest": "9d6972f67644e0d6377f2feb33332fe27a1484b553615843fdcd85a5143c2aee" + "digest": "6aac58294ebf42423c472cc5783a7f031c87adc4100b08999e78484e33209d8c" }, "github": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "2f9c472c3681a7c7a80f6dcf057f614adbc7126f5414ca2d19c770cd050ad71f", "service": "github-gateway-demo", "tool": "create_issue_v1", @@ -636,6 +716,22 @@ } } } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create an issue in the repository identified by the complete destination URL, using the displayed title and body. The issue may be visible to repository readers." + ], + "fields": { + "body": { + "kind": "text", + "label": "Body" + }, + "title": { + "kind": "text", + "label": "Title" + } + } } }, "lock": { @@ -690,11 +786,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "45ad8e8a7d69b408dd3bed85714ece4b72a3ed35723b1bb0375d4b802e8bb0c3" + "digest": "c233392d5f51034ebe8eb79054bdc4f3109c092be8caa95f1ea9356e2a1a2291" }, "github-response-locator": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "2f9c472c3681a7c7a80f6dcf057f614adbc7126f5414ca2d19c770cd050ad71f", "service": "github-gateway-demo", "tool": "create_issue_v1", @@ -740,6 +836,22 @@ } } }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create an issue in the repository identified by the complete destination URL, using the displayed title and body. The issue may be visible to repository readers." + ], + "fields": { + "body": { + "kind": "text", + "label": "Body" + }, + "title": { + "kind": "text", + "label": "Title" + } + } + }, "observation": { "path": [ { @@ -821,11 +933,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "df92737ef30b74ef81b4438533ee5d9d46b8056e430f6c0032bc23f18b87873c" + "digest": "199f38ede4c2468a11d627d66d31471625bbec460a04911f48906fe4b68749f3" }, "stripe-plain": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "06c91dcf9660ed2445c04c87bd5546d8bdfb7540c3f91276685c93ea5abdd82d", "service": "stripe-refunds", "tool": "create_refund_v1", @@ -863,6 +975,24 @@ "kind": "derived-header", "retention_seconds": 86400 } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } }, "lock": { @@ -919,11 +1049,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "ff49d44a2978d72869f3865cdf886d518aaabc1d9fb27d6ef143c3e80b2ba394" + "digest": "6a6fddf6a71d93045db061b5e80d374e988fad6db3c659a46f08cd2a48f1b726" }, "stripe": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e", "service": "stripe-refunds", "tool": "create_refund_v1", @@ -1095,6 +1225,32 @@ "name": "metadata[auths_echo]" }, "observe": "/metadata/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "connect_account": { + "kind": "identifier", + "label": "Connect account" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } }, "lock": { @@ -1161,11 +1317,11 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "fe005b5323d196292b5eff4439f40f6e835dac2e9bd869c64f27b4a371615090" + "digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9" }, "stripe-platform": { "recipe": { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d61ec6d55d346f7c6ba550451623b72abaecebf013c307b685fce059db21f9ea", "service": "stripe-refunds", "tool": "create_refund_v1", @@ -1245,12 +1401,27 @@ "provider_headers": { "Stripe-Version": "2025-03-31.basil" }, - "echo": { - "write": { - "kind": "form-field", - "name": "metadata[auths_echo]" - }, - "observe": "/metadata/auths_echo" + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } }, "bounds": { "sum": { @@ -1333,6 +1504,13 @@ "json_pointer": "/amount", "expected_field": "amount", "maximum_response_bytes": 16384 + }, + "echo": { + "write": { + "kind": "form-field", + "name": "metadata[auths_echo]" + }, + "observe": "/metadata/auths_echo" } }, "lock": { @@ -1394,7 +1572,7 @@ "pre_entry_reread": false, "write_is_conditional": false }, - "digest": "7e0cd37f029562d2fb291026f98616148a667f2b19bbfa2b4ccb54637b3805ff" + "digest": "04edff61298edcf288bdb182d22a5288b7f903478cbca77f0134822105f3003f" } }, "cases": [ diff --git a/bindings/fixtures/gateway/todoist/recipe.json b/bindings/fixtures/gateway/todoist/recipe.json index 64d073adf..553ba04b8 100644 --- a/bindings/fixtures/gateway/todoist/recipe.json +++ b/bindings/fixtures/gateway/todoist/recipe.json @@ -1,17 +1,28 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d2929455f9e255caf23629daa0db125c73565a2a55b4db13fbe0fbea731d10f3", "service": "todoist-gateway-demo", "tool": "create_task_v1", "operator_namespace": "todoist-demo", - "credential": {"kind": "bearer"}, + "credential": { + "kind": "bearer" + }, "origin": "https://api.todoist.com", "write": { "method": "POST", "path": [ - {"kind": "fixed", "value": "api"}, - {"kind": "fixed", "value": "v1"}, - {"kind": "fixed", "value": "sync"} + { + "kind": "fixed", + "value": "api" + }, + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "sync" + } ], "body": { "kind": "form", @@ -20,24 +31,61 @@ "kind": "json", "value": { "kind": "array", - "items": [{ - "kind": "object", - "fields": { - "type": {"kind": "string", "value": "item_add"}, - "uuid": {"kind": "field", "name": "operation_id"}, - "temp_id": {"kind": "field", "name": "temp_id"}, - "args": { - "kind": "object", - "fields": { - "content": {"kind": "field", "name": "content"}, - "description": {"kind": "field", "name": "description"} + "items": [ + { + "kind": "object", + "fields": { + "type": { + "kind": "string", + "value": "item_add" + }, + "uuid": { + "kind": "field", + "name": "operation_id" + }, + "temp_id": { + "kind": "field", + "name": "temp_id" + }, + "args": { + "kind": "object", + "fields": { + "content": { + "kind": "field", + "name": "content" + }, + "description": { + "kind": "field", + "name": "description" + } + } } } } - }] + ] } } } } + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Create one task with the displayed content at the displayed destination. Provider-side notification and visibility rules still apply." + ], + "fields": { + "content": { + "kind": "text", + "label": "Content" + }, + "description": { + "kind": "text", + "label": "Description" + }, + "temp_id": { + "kind": "identifier", + "label": "Temp id" + } + } } } diff --git a/bindings/fixtures/openapi-derivation/README.md b/bindings/fixtures/openapi-derivation/README.md index e56e9151d..8ee8f8137 100644 --- a/bindings/fixtures/openapi-derivation/README.md +++ b/bindings/fixtures/openapi-derivation/README.md @@ -14,7 +14,7 @@ rejected. `expected//` holds: | --- | --- | --- | | `profile.toml`, `recipe.json`, `derivation.json` | exact bytes the CLI writes | absent | | `profile.lock.json` | the packaged profile generator's lock for that `profile.toml` | absent | -| `review.json` | the gateway recipe compiler's review, including the recipe digest | absent | +| `review.json` | native review after an explicitly synthetic test-only review declaration | absent | | `rejections.json` | absent | every code, JSON pointer, and resolving override, in order | | `report.txt` | the report printed after writing | the rejection report; nothing is written | @@ -45,11 +45,24 @@ cargo test -p auths-openapi-derive --test corpus The first command rewrites the derived files and rejection lists, the second rewrites `profile.lock.json` with the packaged generator, the third compiles -every derived recipe against those locks and records `review.json`, and the +every derived recipe against those locks after adding the test-only declaration, +and records `review.json`, and the last checks the result without writing. What this corpus shows: the derived contract and recipe for each case, that -every derived recipe compiles under the gateway recipe compiler, and the exact +each incomplete draft is refused until a review declaration is supplied, +then compiles with explicitly synthetic review fields in this corpus, and the exact rejection for each unsupported construct. It does not show that a document describes its provider accurately or that any derived request has the effect the document describes. + +Recipe source `/3` requires `auths.effect-review-contract/1`. Derivation emits +field names and compatible presentation kinds, but leaves consequences and +integer units incomplete. Operators must supply and review these domain facts; +they are not inferred from untrusted OpenAPI descriptions. The native compiler +refuses the incomplete draft. `review.json` is a test-only transport comparison, +not approval of a generated domain description. + +When updating artifacts, unavailable pinned vendor inputs are reported as +pending; their committed files are not rewritten. Ordinary verification with a +configured corpus directory still fails for a missing or mismatched vendor file. diff --git a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/derivation.json b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/derivation.json index 6948f0b39..ec418c595 100644 --- a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/derivation.json @@ -71,6 +71,6 @@ "generator_format": 2, "outputs": { "profile.toml": "eda4695abe919527b111ee0da1f1151a76697915ade5075f8fe8fdbedda6540b", - "recipe.json": "10527081482c25fb51dec8787848ffc2fa0a3048069ece66de433e9e4a7307fd" + "recipe.json": "1cc501024f8633c0c4cd99662f00c29c4ac33fae2393026f7dfc421294100a99" } } diff --git a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/recipe.json b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/recipe.json index 813555174..823d27af3 100644 --- a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/recipe.json @@ -1,5 +1,19 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "record_id": { + "kind": "text", + "label": "record_id" + }, + "fields_DemoStatus": { + "kind": "text", + "label": "fields_DemoStatus" + } + } + }, "profile_schema_digest": "2dbf645e83e39556502dd02e204ccec3e3a1102fe55739dc7f45b2632665ee17", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/report.txt b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/report.txt index 5a67bc76f..5c793c364 100644 --- a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/report.txt @@ -7,5 +7,6 @@ overrides: --omit returnFieldsByFieldId --omit typecast unenforced: record_id minLength (#/paths/~1appTEST0000000001~1tblTEST0000000001~1{record_id}/patch/parameters/0/schema/minLength) wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/review.json b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/review.json index 231d15cb4..1a8f2fce5 100644 --- a/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/review.json +++ b/bindings/fixtures/openapi-derivation/expected/airtable-set-demo-status/review.json @@ -1,6 +1,22 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "1bdf7a75cf7806c4c806e1319c31ff2a52bb2b145451320300e3db044ad6aa60", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "fields_DemoStatus": { + "kind": "text", + "label": "fields_DemoStatus" + }, + "record_id": { + "kind": "text", + "label": "record_id" + } + } + }, + "digest": "384d1c43210ae26ec6fc75f77ba8ccacca3d801d7c514e7ba33b8c761a48aaea", "operator_namespace": "airtable-demo", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/derivation.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/derivation.json index 6eb89d860..3a2a4bb3a 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/derivation.json @@ -101,6 +101,6 @@ "generator_format": 2, "outputs": { "profile.toml": "badad26d5681b8d433581e5c6efd2639779c6b5127c911934d00f205429e10ca", - "recipe.json": "d3ec26f9da51f7b757c203497f0d6a1559e44c84fea971587900b32a269da0af" + "recipe.json": "1cf7d997ec8dc09855af61217ba8f18c573cd767004c74ef27e1e41f657f3a64" } } diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/recipe.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/recipe.json index bca84922e..c720fb129 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/recipe.json @@ -1,5 +1,19 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "title": { + "kind": "text", + "label": "title" + }, + "body": { + "kind": "text", + "label": "body" + } + } + }, "profile_schema_digest": "0dda3f3e84a069ff32ae7f3f09ace84289030061ff2641f64c308bc159d439b4", "service": "github-gateway-demo", "tool": "create_issue_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/report.txt b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/report.txt index c8fb04343..3e5ae8dbe 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/report.txt @@ -6,5 +6,6 @@ omitted: assignee (--omit) milestone (--omit) labels (--omit) assignees (--omit) issue_field_values (--omit) type (--omit) parent_issue_id (--omit) overrides: --max-bytes body=256 --max-bytes title=128 --require body --omit assignee --omit assignees --omit issue_field_values --omit labels --omit milestone --omit parent_issue_id --omit type --closed . --pick title=string --literal owner="auths-dev" --literal repo="gateway-fixture-repo" --security-scheme bearer --tool create_issue wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/review.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/review.json index a500fe25a..92a075138 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/review.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create-fixed-repository/review.json @@ -1,6 +1,22 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "41dd377c19a1700a08681079c5b313805a8c152236d88e81c47bff64f1bc97fd", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "body": { + "kind": "text", + "label": "body" + }, + "title": { + "kind": "text", + "label": "title" + } + } + }, + "digest": "c986df14d2753051d48bc48c8c434b350da83d80fe63bcc51e46d6b171180118", "operator_namespace": "github-demo", "service": "github-gateway-demo", "tool": "create_issue_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create/derivation.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create/derivation.json index 577dd0fc0..f408535a0 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create/derivation.json @@ -109,6 +109,6 @@ "generator_format": 2, "outputs": { "profile.toml": "3a6499d4ec71e98d87f6c83ab26bef630387fe0eb15cd5888f061b1c684746a0", - "recipe.json": "e366e43229b7edb3c7d093bf390006ace2962940eb9884e1f87356cd7e971dc6" + "recipe.json": "d6786c2d5a56f746844cd8434f7cc018b45376e270f5089d2e5d7173a7991dfb" } } diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create/recipe.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create/recipe.json index d86bdd9ae..2ae18c0a7 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create/recipe.json @@ -1,5 +1,23 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "owner": { + "kind": "text", + "label": "owner" + }, + "repo": { + "kind": "text", + "label": "repo" + }, + "title": { + "kind": "text", + "label": "title" + } + } + }, "profile_schema_digest": "c2d83451c30631c96f928b54d7f6364cc349afc4f6fb2118b8a7f9d48bb013a1", "service": "github-gateway-demo", "tool": "issues_create_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create/report.txt b/bindings/fixtures/openapi-derivation/expected/github-issues-create/report.txt index 1376286ed..2e6447bb5 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create/report.txt @@ -6,5 +6,6 @@ omitted: body (--omit) assignee (--omit) milestone (--omit) labels (--omit) assignees (--omit) issue_field_values (--omit) type (--omit) parent_issue_id (--omit) overrides: --max-bytes owner=64 --max-bytes repo=128 --max-bytes title=256 --omit assignee --omit assignees --omit body --omit issue_field_values --omit labels --omit milestone --omit parent_issue_id --omit type --closed . --pick title=string --security-scheme bearer --tool issues_create wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/github-issues-create/review.json b/bindings/fixtures/openapi-derivation/expected/github-issues-create/review.json index 8be3fc715..2ae4b63e6 100644 --- a/bindings/fixtures/openapi-derivation/expected/github-issues-create/review.json +++ b/bindings/fixtures/openapi-derivation/expected/github-issues-create/review.json @@ -1,6 +1,26 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "5f8f591ad590851208fd4c2778465cc417d680e920ee7544ab906fc8850d5490", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "owner": { + "kind": "text", + "label": "owner" + }, + "repo": { + "kind": "text", + "label": "repo" + }, + "title": { + "kind": "text", + "label": "title" + } + } + }, + "digest": "4e9d7a265398f343260ac6db6ee3d72efbba1512df83b514455b25e492dcc5e2", "operator_namespace": "github-demo", "service": "github-gateway-demo", "tool": "issues_create_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/derivation.json b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/derivation.json index 04f2c537c..89075cb08 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/derivation.json @@ -44,6 +44,6 @@ "generator_format": 2, "outputs": { "profile.toml": "5f7ae8a6a5417c19b694f3709e7cf3b4898be0e879a9828616d9003121cfaa25", - "recipe.json": "41db1e3ecde95a5b5c4546b9d3ebf77b80c8432a13368574f65d0c5ddd85d500" + "recipe.json": "0f7b2136d3e69b29e8a6c54ce80a7db970da23875e6d65d9e2aa8a89446762ce" } } diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/recipe.json b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/recipe.json index 94dc37409..0bf7753eb 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/recipe.json @@ -1,5 +1,16 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "p": { + "kind": "integer", + "label": "p", + "unit": "" + } + } + }, "profile_schema_digest": "bb9157c5e5256469c5b5c903362508d0e2a1b75d5fcecdf6221230497f9b2c5b", "service": "hostile", "tool": "hFractionalBounds_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/report.txt b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/report.txt index 55c6c037f..645e0cdda 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/report.txt @@ -6,5 +6,6 @@ omitted: none overrides: none wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/review.json b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/review.json index d73a8c842..1ebcb313b 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/review.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-fractional-bounds/review.json @@ -1,6 +1,19 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "d11322d4151684ab0117ae814b940dab627f0f4258527f400f1aa24a09dc5b22", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "p": { + "kind": "integer", + "label": "p", + "unit": "synthetic units" + } + } + }, + "digest": "9955d6bbe8ea098e8171ae8d962ba1d2f2c98a427f845048c1f9f9f103b1937b", "operator_namespace": "hostile", "service": "hostile", "tool": "hFractionalBounds_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/derivation.json b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/derivation.json index c0f0e5857..e0b9e0d23 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/derivation.json @@ -46,6 +46,6 @@ "generator_format": 2, "outputs": { "profile.toml": "5bb08289820e03a38ca102d389faa0927286efa4eb01d5259b9d65feaad5ca98", - "recipe.json": "cb0b3be2510bfce8ef6a93ea98eb7479dc447fb3acf29b7d8edea8bf9d0bf911" + "recipe.json": "80cab668f10433e7b3624fcb6fee53b3077f2e013a051c8304dd99663adab0f3" } } diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/recipe.json b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/recipe.json index 8c2304c47..5eccb4b22 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/recipe.json @@ -1,5 +1,15 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "a": { + "kind": "text", + "label": "a" + } + } + }, "profile_schema_digest": "245011e2bdf4718d913d7d1bb3758dba223efdd23065a3828efec232bd962b82", "service": "hostile", "tool": "hIntegerPath_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/report.txt b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/report.txt index a054c97af..4b1d1b7ef 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/report.txt @@ -6,5 +6,6 @@ omitted: none overrides: --literal item_id=7 wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/review.json b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/review.json index a7a7c37b7..4c8b21bae 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/review.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-integer-path-fixed/review.json @@ -1,6 +1,18 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "757cef6f42c1e80d6d6fe5173e6e7aaf590b4cd137784e2df98fdb9a03762580", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "a": { + "kind": "text", + "label": "a" + } + } + }, + "digest": "10ca318368112e6458a2d46c236e869217fff766b3ba1ff117ce34e4277ad515", "operator_namespace": "hostile", "service": "hostile", "tool": "hIntegerPath_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/derivation.json b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/derivation.json index 24dabaab2..e6667d559 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/derivation.json @@ -46,6 +46,6 @@ "generator_format": 2, "outputs": { "profile.toml": "b0daa4b4efcfdae003c147fb380556f674c44f5c4743eef22fcfb5170b870d21", - "recipe.json": "0eeacd3947aed598a7fa9bbed0dc3c405318bad9f5a42e8b8bd32768aba091f4" + "recipe.json": "69329952a47a15e6574d88dcbb86eadaa2f7f80c9dfcc0d0d06a544391032fa6" } } diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/recipe.json b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/recipe.json index fea4dfd4c..69f9e1c39 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/recipe.json @@ -1,5 +1,15 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "a": { + "kind": "text", + "label": "a" + } + } + }, "profile_schema_digest": "245011e2bdf4718d913d7d1bb3758dba223efdd23065a3828efec232bd962b82", "service": "hostile", "tool": "hLiteralEnum_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/report.txt b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/report.txt index 42e8d18c8..e8be4e3cc 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/report.txt @@ -6,5 +6,6 @@ omitted: none overrides: --literal p=2 wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/review.json b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/review.json index dcbcae62e..b007885e8 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/review.json +++ b/bindings/fixtures/openapi-derivation/expected/hostile-literal-enum-member/review.json @@ -1,6 +1,18 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "f0488b207e27c205ba294b2b26e20f48ec4bde271792e57647e095a4443c53cc", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "a": { + "kind": "text", + "label": "a" + } + } + }, + "digest": "f1bc14dae1e701f2b4a120fa0b2c6e04cbaf5a0617d588d81d45b6cd19fbe7da", "operator_namespace": "hostile", "service": "hostile", "tool": "hLiteralEnum_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/hostile-recipe-limit/report.txt b/bindings/fixtures/openapi-derivation/expected/hostile-recipe-limit/report.txt index 6aaad3936..aacc4771b 100644 --- a/bindings/fixtures/openapi-derivation/expected/hostile-recipe-limit/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/hostile-recipe-limit/report.txt @@ -1,4 +1,4 @@ REJECTED contract contract.derive.recipe-limit #/paths/~1recipe-limit/post - the derived recipe.json is 68992 bytes; the gateway recipe compiler reads at most 65536; no override exists + the derived recipe.json is 69100 bytes; the gateway recipe compiler reads at most 65536; no override exists nothing written diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/derivation.json b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/derivation.json index 9f42dd3b7..f5660a556 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/derivation.json @@ -104,6 +104,6 @@ "generator_format": 2, "outputs": { "profile.toml": "0fda0813003f75d7e287fc6397c7a71e288e88fbe59b17769a3aa453235c18d0", - "recipe.json": "b1b0022835975e14e55f2c6bc207685147f8e25b3fa60bc4c7a8f9a710e7deb0" + "recipe.json": "c9345495778bc887c969cd00a9eaaa58a3ab5c5eeabbac30d9d66e6ce234e067" } } diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/recipe.json b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/recipe.json index 62f5103b6..4ac25aeee 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/recipe.json @@ -1,5 +1,36 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "notebook_id": { + "kind": "text", + "label": "notebook_id" + }, + "title": { + "kind": "text", + "label": "title" + }, + "status": { + "kind": "text", + "label": "status" + }, + "pinned": { + "kind": "boolean", + "label": "pinned" + }, + "priority": { + "kind": "integer", + "label": "priority", + "unit": "" + }, + "meta_color": { + "kind": "text", + "label": "meta_color" + } + } + }, "profile_schema_digest": "3b7cf471aac444931be7ec82435618d77a3a50d90f1c855e0b0ba589e2135de3", "service": "notes", "tool": "createNote_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/report.txt b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/report.txt index 3b4365abc..90a64de6d 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/report.txt @@ -8,5 +8,6 @@ unenforced: notebook_id pattern (#/components/parameters/NotebookId/schema/pattern) unenforced: notebook_id minLength (#/components/parameters/NotebookId/schema/minLength) wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/review.json b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/review.json index 45914d74c..3871789e2 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-create-note/review.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-create-note/review.json @@ -1,6 +1,39 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "9fcaf0411200dcd052d7ae2d990439cd51775906a86b95e83351606373571689", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "meta_color": { + "kind": "text", + "label": "meta_color" + }, + "notebook_id": { + "kind": "text", + "label": "notebook_id" + }, + "pinned": { + "kind": "boolean", + "label": "pinned" + }, + "priority": { + "kind": "integer", + "label": "priority", + "unit": "synthetic units" + }, + "status": { + "kind": "text", + "label": "status" + }, + "title": { + "kind": "text", + "label": "title" + } + } + }, + "digest": "602048b64870798d1d5a32613e935fdba56243441a3a736d02fd7d674c4029f8", "operator_namespace": "notes-demo", "service": "notes", "tool": "createNote_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/derivation.json b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/derivation.json index 7dbfd650b..b5a54a93e 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/derivation.json @@ -56,6 +56,6 @@ "generator_format": 2, "outputs": { "profile.toml": "a5b639a83e3cbe78009edc4873ea84cdbef83cef78b80a19d8c0ac9acaaacda2", - "recipe.json": "c40a38b83a279ec7f17c04037da269d174150ba60d0e5287b8812a2615cb6217" + "recipe.json": "3be41252da1c8785730b86f922b3f6a5405b2f9d62f3eca9d9d60fe3dd257e83" } } diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/recipe.json b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/recipe.json index eba1589f8..d0d290500 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/recipe.json @@ -1,5 +1,24 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "note_id": { + "kind": "text", + "label": "note_id" + }, + "title": { + "kind": "text", + "label": "title" + }, + "revision": { + "kind": "integer", + "label": "revision", + "unit": "" + } + } + }, "profile_schema_digest": "edc46422990c3f827b6c762b53dc705a1d559aa6f6c217b08b25b24fcde78822", "service": "notes", "tool": "renameNote_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/report.txt b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/report.txt index 45d605c78..80cdd821a 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/report.txt @@ -6,5 +6,6 @@ omitted: none overrides: --security NotesBearer wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/review.json b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/review.json index d0d38a307..83c1f121f 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/review.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-rename-note-form/review.json @@ -1,6 +1,27 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "908b73ab7bed251e2600fe2ca95e0504646e8ccb9147a8952b20af0a3354a72d", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "note_id": { + "kind": "text", + "label": "note_id" + }, + "revision": { + "kind": "integer", + "label": "revision", + "unit": "synthetic units" + }, + "title": { + "kind": "text", + "label": "title" + } + } + }, + "digest": "57b07e87baa371ba18560bd7f6c20d405a0062275c2f08f9310fbbb83051cef6", "operator_namespace": "notes-demo", "service": "notes", "tool": "renameNote_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/derivation.json b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/derivation.json index bb497e579..c4cfad128 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/derivation.json @@ -55,6 +55,6 @@ "generator_format": 2, "outputs": { "profile.toml": "c8d46a1fa31d889ae5ec5dd2af6bad958259ba7d71526a7ad2ba087c490486d7", - "recipe.json": "7fbe8ef586d1e1dbdf601028fe66eb9b02554a41f5bb218279bbc80e0691c7e9" + "recipe.json": "142a9de14fdd29a0293eb34c018abb05784d0a1d5de6931c89a6530a7a2196cb" } } diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/recipe.json b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/recipe.json index 3bb66cc09..0c2ca6daf 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/recipe.json @@ -1,5 +1,19 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "note_id": { + "kind": "text", + "label": "note_id" + }, + "label": { + "kind": "text", + "label": "label" + } + } + }, "profile_schema_digest": "7d7364459ae29c8072ecd012025cca8cb4a4cecc57d8e292a54e9175b918bf5f", "service": "notes", "tool": "setNoteLabel_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/report.txt b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/report.txt index 3cc897287..a3b2cb47a 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/report.txt @@ -6,5 +6,6 @@ omitted: none overrides: --closed . --literal source="auths" --server https://labels-eu.notes.example/v2 wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/review.json b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/review.json index 3292ced54..27c2827f1 100644 --- a/bindings/fixtures/openapi-derivation/expected/minimal-set-label/review.json +++ b/bindings/fixtures/openapi-derivation/expected/minimal-set-label/review.json @@ -1,6 +1,22 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "6b9d1b80d7bfe89d46fcac348f73c42c302671226fa18fba8909e009d569abef", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "label": { + "kind": "text", + "label": "label" + }, + "note_id": { + "kind": "text", + "label": "note_id" + } + } + }, + "digest": "a7d3a86fb3b2c87cc379bb61b00e11c2cd41c7eb7db711b24182701acdb6ccd0", "operator_namespace": "notes-demo", "service": "notes", "tool": "setNoteLabel_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/derivation.json b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/derivation.json index 883f45425..9aa50cf97 100644 --- a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/derivation.json @@ -80,6 +80,6 @@ "generator_format": 2, "outputs": { "profile.toml": "d7a9d77ef3cfe8175f9c5b61bc391cab7eb2d81dd52e228a221ac8a70d8fb09a", - "recipe.json": "c9441090ba7faeba9cae1d3956f64b21da3211c96ff48894fb09b3d97c8fc6d3" + "recipe.json": "0bfdcbad25720c24d21e9625570f186e16d30b1cd8d89d0e5fe74114bf0cac0d" } } diff --git a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/recipe.json b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/recipe.json index 1fd7ab6e5..20bedbf18 100644 --- a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/recipe.json @@ -1,5 +1,15 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "name": { + "kind": "text", + "label": "name" + } + } + }, "profile_schema_digest": "6682c07816a161a09e67d13c839a7bfabc363337ce348eda8fd8b707446be961", "service": "openai-vector-stores", "tool": "createVectorStore_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/report.txt b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/report.txt index a71cbda0d..d0ccb321b 100644 --- a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/report.txt @@ -6,5 +6,6 @@ omitted: file_ids (--omit) description (--omit) expires_after (--omit) chunking_strategy (--omit) metadata (--omit) overrides: --max-bytes name=128 --require name --omit chunking_strategy --omit description --omit expires_after --omit file_ids --omit metadata wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/review.json b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/review.json index e111fb6f5..0bf7cba06 100644 --- a/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/review.json +++ b/bindings/fixtures/openapi-derivation/expected/openai-create-vector-store/review.json @@ -1,6 +1,18 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "03f3497a3e815338994fb385b5876783bfb742ca049ec8aecf4be0cf6fb44d8f", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "name": { + "kind": "text", + "label": "name" + } + } + }, + "digest": "7b4fed5ddda7b147ca95faae4fa535ee6052236794dd1f05097d79a2791aeb0b", "operator_namespace": "openai-demo", "service": "openai-vector-stores", "tool": "createVectorStore_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/derivation.json b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/derivation.json index fa895ba56..2a57e9a4e 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/derivation.json @@ -140,6 +140,6 @@ "generator_format": 2, "outputs": { "profile.toml": "0ae561ebfb01f0e684db069599944728a4377ffb7fb50259829f2ca0b98849c8", - "recipe.json": "347dd32f8f9663581303b84025c5ee1bafe1f03864693f37a9d305efb640ae61" + "recipe.json": "f546eef5ad6ade6cf19552812a6fa9c68ca32ded1e380c2dfa2b86b36a77dccc" } } diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/recipe.json b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/recipe.json index 0ef495bf5..25d7e38ac 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/recipe.json @@ -1,5 +1,15 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "content": { + "kind": "text", + "label": "content" + } + } + }, "profile_schema_digest": "327329aec5e0b979139ed7fe33f217aadea056f475a7c2a8474e270e616703c8", "service": "todoist-gateway-demo", "tool": "create_task_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/report.txt b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/report.txt index 591d70777..bfe0626ac 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/report.txt @@ -6,5 +6,6 @@ omitted: description (--omit) project_id (--omit) section_id (--omit) parent_id (--omit) order (--omit) labels (--omit) priority (--omit) assignee_id (--omit) due_string (--omit) due_date (--omit) due_datetime (--omit) due_lang (--omit) duration (--omit) duration_unit (--omit) deadline_date (--omit) overrides: --max-bytes content=256 --omit assignee_id --omit deadline_date --omit description --omit due_date --omit due_datetime --omit due_lang --omit due_string --omit duration --omit duration_unit --omit labels --omit order --omit parent_id --omit priority --omit project_id --omit section_id --closed . --security-scheme bearer --tool create_task wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/review.json b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/review.json index 0e4289241..e65203796 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-create-task/review.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-create-task/review.json @@ -1,6 +1,18 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "f2a19e3434038b75ee191b50b5c06ffa0847063d70f63e3cc6e8582893e99b98", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "content": { + "kind": "text", + "label": "content" + } + } + }, + "digest": "269bd2aea8420678ed985bb80b2e129acb84463924ab4687ba38ef317af86129", "operator_namespace": "todoist-demo", "service": "todoist-gateway-demo", "tool": "create_task_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/derivation.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/derivation.json index b0328cd2d..029973b6f 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/derivation.json @@ -63,6 +63,6 @@ "generator_format": 2, "outputs": { "profile.toml": "d25beb4cc24861c880caa588723956a6f95c41772464cad776884030f6d4fbd2", - "recipe.json": "9e56806b864a4f62fd7312adfde8f4fe3b6cc44d9548f6ead6327ebf133005bd" + "recipe.json": "03e867a992934232433a3a32f11ad3710dcfeb67b320141fa3ee30fef3310b30" } } diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/recipe.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/recipe.json index 41a5a538b..8618574d0 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/recipe.json @@ -1,5 +1,19 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "content": { + "kind": "text", + "label": "content" + }, + "description": { + "kind": "text", + "label": "description" + } + } + }, "profile_schema_digest": "4f43d83855ce5ab31f514e5cd3d2b39c2692372b228d987e0b99c9695ad44d24", "service": "todoist-gateway-demo", "tool": "create_task_v2", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/report.txt b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/report.txt index 8fd9a39a8..2bb005f41 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/report.txt @@ -6,5 +6,6 @@ omitted: priority (--omit) overrides: --max-bytes content=256 --max-bytes description=80 --require description --omit priority --closed . --pick description=string --security-scheme bearer --tool create_task wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/review.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/review.json index 8b3b05936..609b1c01b 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/review.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task-with-description/review.json @@ -1,6 +1,22 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "7128697129a7e1fe680b0706b7d4ad014c351fa05925a7de9af980bd2a193f60", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "content": { + "kind": "text", + "label": "content" + }, + "description": { + "kind": "text", + "label": "description" + } + } + }, + "digest": "94468e298e659332ff00638c7203d37ab0b4e948ff7f9f41b956db2f02f2da91", "operator_namespace": "todoist-demo", "service": "todoist-gateway-demo", "tool": "create_task_v2", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/derivation.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/derivation.json index 86aa422e2..dbc791381 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/derivation.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/derivation.json @@ -62,6 +62,6 @@ "generator_format": 2, "outputs": { "profile.toml": "0ae561ebfb01f0e684db069599944728a4377ffb7fb50259829f2ca0b98849c8", - "recipe.json": "347dd32f8f9663581303b84025c5ee1bafe1f03864693f37a9d305efb640ae61" + "recipe.json": "f546eef5ad6ade6cf19552812a6fa9c68ca32ded1e380c2dfa2b86b36a77dccc" } } diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/recipe.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/recipe.json index 0ef495bf5..25d7e38ac 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/recipe.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/recipe.json @@ -1,5 +1,15 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [], + "fields": { + "content": { + "kind": "text", + "label": "content" + } + } + }, "profile_schema_digest": "327329aec5e0b979139ed7fe33f217aadea056f475a7c2a8474e270e616703c8", "service": "todoist-gateway-demo", "tool": "create_task_v1", diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/report.txt b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/report.txt index c4727b794..6db732623 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/report.txt +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/report.txt @@ -6,5 +6,6 @@ omitted: description (--omit) priority (--omit) overrides: --max-bytes content=256 --omit description --omit priority --closed . --security-scheme bearer --tool create_task wrote: profile.toml recipe.json derivation.json + review: complete recipe.review consequences, labels and integer units; incomplete declarations cannot compile next: auths generate profile.toml && auths-node gateway recipe check --recipe recipe.json --profile-lock profile.lock.json claim: derived shape only; provider effect unqualified diff --git a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/review.json b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/review.json index 0e4289241..e65203796 100644 --- a/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/review.json +++ b/bindings/fixtures/openapi-derivation/expected/todoist-rest-create-task/review.json @@ -1,6 +1,18 @@ { - "schema": "auths.gateway-recipe-review/2", - "digest": "f2a19e3434038b75ee191b50b5c06ffa0847063d70f63e3cc6e8582893e99b98", + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Synthetic transport comparison only; no production review claim." + ], + "fields": { + "content": { + "kind": "text", + "label": "content" + } + } + }, + "digest": "269bd2aea8420678ed985bb80b2e129acb84463924ab4687ba38ef317af86129", "operator_namespace": "todoist-demo", "service": "todoist-gateway-demo", "tool": "create_task_v1", diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/recipe/recipe.json b/bindings/python/python/auths/_templates/stripe-refund-approval/recipe/recipe.json index 506260bc3..36e3f65ff 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/recipe/recipe.json +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/recipe/recipe.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e", "service": "stripe-refunds", "tool": "create_refund_v1", @@ -7,64 +7,195 @@ "credential": { "kind": "bearer", "guard": { - "prefixes": ["rk_test_"], + "prefixes": [ + "rk_test_" + ], "probe": { - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "balance"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "balance" + } + ], "json_pointer": "/livemode", "equals": false, "maximum_response_bytes": 16384 }, "account": { - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "account"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "account" + } + ], "json_pointer": "/id", "maximum_response_bytes": 65536 }, "denied_reads": [ - {"method": "GET", "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "customers"}], "refused_status": [403]}, - {"method": "GET", "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "payouts"}], "refused_status": [403]} + { + "method": "GET", + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "customers" + } + ], + "refused_status": [ + 403 + ] + }, + { + "method": "GET", + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "payouts" + } + ], + "refused_status": [ + 403 + ] + } ] } }, "origin": "https://api.stripe.com", - "provider_headers": {"Stripe-Version": "2025-03-31.basil"}, - "account_scope": {"header": "Stripe-Account", "field": "connect_account"}, - "bounds": {"sum": {"argument": "amount", "partition": "currency"}}, + "provider_headers": { + "Stripe-Version": "2025-03-31.basil" + }, + "account_scope": { + "header": "Stripe-Account", + "field": "connect_account" + }, + "bounds": { + "sum": { + "argument": "amount", + "partition": "currency" + } + }, "relative_ceiling": { "argument": "amount", "basis_points": 5000, "path": [ - {"kind": "fixed", "value": "v1"}, - {"kind": "fixed", "value": "payment_intents"}, - {"kind": "field", "name": "payment_intent"} + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "payment_intents" + }, + { + "kind": "field", + "name": "payment_intent" + } ], "json_pointer": "/amount_received", - "bind": [{"pointer": "/currency", "field": "currency"}], + "bind": [ + { + "pointer": "/currency", + "field": "currency" + } + ], "maximum_response_bytes": 65536 }, "write": { "method": "POST", - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "refunds"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "refunds" + } + ], "body": { "kind": "form", "fields": { - "payment_intent": {"kind": "field", "name": "payment_intent"}, - "amount": {"kind": "field", "name": "amount"} + "payment_intent": { + "kind": "field", + "name": "payment_intent" + }, + "amount": { + "kind": "field", + "name": "amount" + } } }, - "idempotency": {"kind": "derived-header", "retention_seconds": 86400} + "idempotency": { + "kind": "derived-header", + "retention_seconds": 86400 + } }, "observation": { "path": [ - {"kind": "fixed", "value": "v1"}, - {"kind": "fixed", "value": "refunds"}, - {"kind": "response-field", "pointer": "/id", "max_bytes": 255} + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "refunds" + }, + { + "kind": "response-field", + "pointer": "/id", + "max_bytes": 255 + } ], "json_pointer": "/amount", "expected_field": "amount", "maximum_response_bytes": 16384 }, "echo": { - "write": {"kind": "form-field", "name": "metadata[auths_echo]"}, + "write": { + "kind": "form-field", + "name": "metadata[auths_echo]" + }, "observe": "/metadata/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "connect_account": { + "kind": "identifier", + "label": "Connect account" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } } diff --git a/compliance.toml b/compliance.toml index 95f163d30..61be59a3f 100644 --- a/compliance.toml +++ b/compliance.toml @@ -345,7 +345,7 @@ kind = "cargo" layer = "product" path = "product/tools/auths-openapi-derive" core_apis = [] -protocol_versions = ["auths.gateway-recipe-source/2", "auths.openapi-derivation-record-result/1", "auths.openapi-derivation/1", "auths.openapi-derive-result/1", "auths.self-hosted-profile-lock/1"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.openapi-derivation-record-result/1", "auths.openapi-derivation/1", "auths.openapi-derive-result/1", "auths.self-hosted-profile-lock/1"] wire_objects = [] fixture_suites = ["bindings/fixtures/openapi-corpus", "bindings/fixtures/openapi-derivation"] principal_families = [] @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/2", "auths.gateway-attempt/6", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/6", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/2", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/2", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,11 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +effect-review = [ + "product/runtime/auths-gateway/src/recipe/tests.rs#native_review_contract_fixture_is_current", + "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", +] effect-entry = [ "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", @@ -2020,7 +2025,7 @@ kind = "npm" layer = "demos" path = "demos/stripe-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] fixture_suites = ["demos/stripe-gateway", "qualification/simulation/live/stripe-platform"] principal_families = ["raw-key-v1"] @@ -2040,7 +2045,7 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/2"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] diff --git a/demos/airtable-gateway/recipe.json b/demos/airtable-gateway/recipe.json index a353d9463..9aacad0ee 100644 --- a/demos/airtable-gateway/recipe.json +++ b/demos/airtable-gateway/recipe.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", @@ -75,5 +75,21 @@ "pointer": "/fields/auths_echo" }, "observe": "/fields/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } } } diff --git a/demos/stripe-gateway/recipe.json b/demos/stripe-gateway/recipe.json index 9f9f90ce1..ba4893b10 100644 --- a/demos/stripe-gateway/recipe.json +++ b/demos/stripe-gateway/recipe.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d2f5b926a3b6989d13b3a4614372e298442de697d92d5e06330288f7de4e257a", "service": "stripe-platform-refunds", "tool": "create_refund_v1", @@ -167,5 +167,27 @@ "name": "metadata[auths_echo]" }, "observe": "/metadata/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } } diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index c27ae23fb..a3f2b8ce2 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -277,3 +277,29 @@ immutable initial evidence and refusal of a second grant. PostgreSQL parity source is authored; installed authority, process faults and full recovery remain separate evidence gates. A revision in the same store cannot detect whole-store rollback. + + +## Recipe-owned review semantics + +Source `/3` adds one mandatory versioned review declaration. Native validation +requires complete typed field coverage, bounded printable labels, explicit +integer units and operator-authored consequences. These are presentation facts, +not gateway-interpreted financial or provider semantics. The recipe digest and +effect compiler `/3` bind them to the exact effect. Compilation refuses a draft, +unknown version, duplicate/missing field, incompatible type or unsafe label. + +Private review `/2` carries the declaration's values from the sealed command, +complete request, structured binding and actual connection identity/generation. +The native literal renderer escapes untrusted text as JSON data and refuses +unsupported versions or output limits. The CLI emits only that safe presentation +with its exact signing statement and writes the request file after output succeeds. +This is a local presentation guarantee, not proof of an authenticated external +reviewer or of human understanding; installed channel/UI evidence remains open. + +OpenAPI derivation owns transport shape only. Its generated review declaration +has empty consequences/units and cannot compile until the operator completes +it. Test-only declarations support independent transport comparisons without +silently approving business meaning from untrusted descriptions. The full +Todoist vendor input currently fails the pinned digest; equivalent frozen native +excerpt outputs update the render artifacts while full vendor execution remains +explicitly pending. No source pin or verification rule was weakened. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 955ff0e8f..39cc72480 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -113,42 +113,29 @@ No stage is complete merely because types, documentation or a happy path exist. ## Immediate implementation continuation -The specification hardening pass adds explicit deployment non-bypassability, -versioned review completeness, adapter-specific fencing, six compositional -safety obligations, bounded operational recovery and a future AP073 composition -boundary. These strengthen A01/A02/A04/A06/A11–A13/A15–A18/A20–A22 without -claiming new executed evidence. The existing review and revalidation APIs do -not yet meet review-completeness or transactional-fencing gates. The adapter -mechanism remains an explicit open decision in ADR 0017 before P2 cutover. - -1. Complete the versioned semantic review contract and full operator review round - trip in maintained consumers. Installed submit and commissioning now require - exact approval, but the native raw review projection does not yet establish - the newly required mandatory-field presentation contract. Update installed - binding tests and example/qualification authoring so original proof bytes are - preserved from review through submission; never synthesize human approval in - an ordinary application wrapper. -2. Store the complete immutable binding in the existing attempt journal, with - replay keyed independently of the effect digest. Reuse the approved effect's - single owned command for send and reporting; reject changed binding as conflict. -3. Refactor the existing transition/order owner to distinguish reservation from - durable entry. The current `Attempting` state must not remain the authority - for both. Validate full native authority and exact approval after acquiring - the store transaction lock; fence connection/configuration against the same - transaction. Publish consumed permits only after durable acknowledgement. -4. Then finish acquisition/disclosure/ACK and AP070 direct cutover, installed - bindings, adapter fault/concurrency/process evidence and formal links. -5. Regenerate semantic closure and all affected canonical/formal artifacts once - source stabilizes. Required hosted workflows have deliberately not been - observed yet. The draft's current CI is not completion evidence. - -The native artifact-generation run last passed for `7c79532a` plus the installed -approval and native signing/frame fixture changes recorded above. CLI canonical -envelope generation then passed against that same native corpus. These cover -compilation, canonical policy/binding, private review and exact approval data, -not installed transport or transactional admission. Subsequent refusal tests -and input-zeroization edits are source-authored only. All unfulfilled AP074 gates -remain open, and the goal remains active. +The checkpoint sections below are historical records; the phase and acceptance +ledgers at the end describe current closure. Do not treat earlier "pending" +notes as a reason to reimplement a later completed source cutover. + +1. Finish truthful public reservation/recovery projections and independently + authorized bounded observation. `Reserved` is not provider uncertainty, and + replay must not implicitly authorize provider reads. Preserve immutable + admission/grant history and the one-use transport boundary already wired. +2. Complete typed acquisition, separate recipient disclosure and exact ACK in + the existing native owners. Bind and account for all credential-bearing + ancillary reads. Remove the competing AP070 Python decision owner and cut + maintained bindings over directly. +3. Finish the installed authenticated review/approval journey. The native + versioned review contract and literal renderer are now wired; frontend + capability, transport/channel authentication and failure evidence remain. +4. Add/complete installed authority expiry/revocation/configuration races, + adapter commit/ack faults and process/transport failpoints, plus differential + and generated-history evidence for A01–A22. Synthetic native fixtures are + deliberately narrower evidence. +5. Regenerate final translated/refinement/performance artifacts and observe + required hosted CI only after implementation, fixtures and documentation are + complete. No hosted results have been observed yet. Full Todoist pinned-input + re-execution remains pending, without blocking other implementation work. ## Full-binding journal cutover (in progress) @@ -311,12 +298,58 @@ closure regeneration passed after that correction (one artifact-generation test) projections, independent recovery authorization, installed fault/race evidence, acquisition/disclosure/ACK and translated formal artifacts remain open. +## Native review-contract checkpoint + +- Recipe source `/3` requires `auths.effect-review-contract/1`; source `/2` + is refused. Every non-binding profile argument must have one compatible + presentation, with a bounded trusted label and explicit unit for integers. + Native binding fields, exact destination/request, installation, reservations, + limits, recovery declarations and uncertainty are always present in private + review. Consequences are mandatory operator-owned recipe data. The gateway + performs no provider-name inference or unit conversion. +- Recipe review `/3`, private effect review `/2`, private signing output `/2` + and effect compiler `/3` make the cutover explicit. Review semantics participate + in the recipe digest and effect identity. There is one native full-value + renderer (`auths.literal-complete-review/1`), bounded to 1 MiB. It emits literal + ASCII JSON, escapes control/bidi/Unicode content, never interprets markup, + and refuses unknown renderer versions or oversized output. The CLI publishes + signing-request files only after complete local review output succeeds. +- Native required artifact generation passed on `6d38bb1c` plus this source: + `recipe::tests::native_review_contract_fixture_is_current` and + `observed_tests::effect_native_tests::native_compilation_approval_and_reverification_keep_exact_request` + (one generator each). The former emits valid recipe fuzz seeds and exact + negative review inputs for missing fields/consequences, unsupported version, + wrong type, control labels and duplicate fields. The latter includes a hostile + bidi/content sentinel, lossless literal-render round trip and renderer refusal. + These establish native compilation/presentation only, not installed human + approval or human understanding. Entry and semantic-closure generators passed. + Native CLI approval-envelope construction passed and matched the regenerated + signed effect corpus exactly; it also compiled the updated binary. +- OpenAPI derivation emits a source `/3` draft with incomplete consequences and + integer units. It cannot compile until an operator supplies those facts. + Derivation tests use explicitly synthetic declarations for transport comparison; + they do not turn descriptions from an untrusted document into review authority. +- OpenAPI corpus artifact generation completed for local documents and pinned + GitHub/OpenAI inputs. Todoist's current URL does not match its pinned bytes; + the two full-vendor cases were explicitly skipped during generation. Its + derived recipe/review/output commitments were updated from the native-generated + excerpt after verifying the previously committed vendor and excerpt recipes + and profiles were byte-identical (the corpus requires this equivalence). + Existing vendor provenance remains unchanged. Full pinned-vendor re-execution + is pending; no digest pin was changed and ordinary configured verification + still fails for missing/mismatched files. Inputs retained for later generation: + `/tmp/auths-ap074-openapi-inputs` (GitHub/OpenAI only). +- Remaining review work is the installed authenticated approval-channel journey, + supported frontend rendering and failure boundaries, privacy checks, and + cross-language/installed evidence. P2–P4 remain open and no complete A01–A22 + acceptance claim follows from this checkpoint. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | -| P1 | Core binding and approval wired | Versioned semantic review completeness and installed approval journey | +| P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Mutation grant and reservation restart wired | Public projections, independent recovery, installed fault/race evidence and formal links | | P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 09ec19eb6..103ddbe66 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -150,3 +150,14 @@ approval/deadline, retained count/sum slots at exhausted capacity and one fresh grant. PostgreSQL equivalent source is authored, not executed. These mechanics do not establish acquisition, disclosure, independent observation authority or installed end-to-end guarantees. + + +Review completeness is now a closed presentation mechanism shared by the +maintained recipes: typed complete field coverage, bounded labels/units and a +literal native renderer. Domain consequences and units remain operator-owned +recipe data; the gateway neither converts units nor infers meaning by provider. +Recipe/effect identities bind that declaration. Native negative and rendering +corpora cover missing/type/version/label/duplicate cases and hostile text. +Installed reviewer authentication, frontend parity and domain qualification +remain separate gates; the OpenAPI mapper deliberately emits an unusable draft +until its review facts are supplied. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 0465f5e02..0165eb62a 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -179,6 +179,19 @@ Test rendering failures, substituted labels and changed review semantics. This establishes faithful, complete presentation under the declared contract, not a proof that the human understood it. +The concrete recipe declaration is `auths.effect-review-contract/1` in recipe +source `/3`: required consequences and one typed presentation for every +non-binding profile argument. Integer presentations require explicit units. +The operator supplies domain meaning; OpenAPI derivation produces an incomplete +draft and cannot authorize these facts. Native review always includes the three +binding arguments, destination, exact request, installation, reservation and +recovery facts independently of recipe labels. Private review `/2` supports the +complete literal renderer `auths.literal-complete-review/1`; control and bidi +characters are escaped data, and output is never truncated. An installed frontend +must preserve that contract and associate its displayed result with the exact +signing request. Native fixture parity alone does not close the installed +approval-channel or human-journey acceptance gate. + ### 4.3 Closed transport and custody The private bound value contains the exact method, origin/path/query, noncredential headers, media type, body and closed observation plan. Transport accepts a stage-sealed effect capability, not a second set of URL/body/recipient parameters. Credential injection may fill only the approved credential slot for the bound connection/account/generation. Credentials themselves never enter effect serialization, public commitments, receipts, bindings or agent memory. diff --git a/examples/stripe-refund-approval/recipe.json b/examples/stripe-refund-approval/recipe.json index 506260bc3..36e3f65ff 100644 --- a/examples/stripe-refund-approval/recipe.json +++ b/examples/stripe-refund-approval/recipe.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e", "service": "stripe-refunds", "tool": "create_refund_v1", @@ -7,64 +7,195 @@ "credential": { "kind": "bearer", "guard": { - "prefixes": ["rk_test_"], + "prefixes": [ + "rk_test_" + ], "probe": { - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "balance"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "balance" + } + ], "json_pointer": "/livemode", "equals": false, "maximum_response_bytes": 16384 }, "account": { - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "account"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "account" + } + ], "json_pointer": "/id", "maximum_response_bytes": 65536 }, "denied_reads": [ - {"method": "GET", "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "customers"}], "refused_status": [403]}, - {"method": "GET", "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "payouts"}], "refused_status": [403]} + { + "method": "GET", + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "customers" + } + ], + "refused_status": [ + 403 + ] + }, + { + "method": "GET", + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "payouts" + } + ], + "refused_status": [ + 403 + ] + } ] } }, "origin": "https://api.stripe.com", - "provider_headers": {"Stripe-Version": "2025-03-31.basil"}, - "account_scope": {"header": "Stripe-Account", "field": "connect_account"}, - "bounds": {"sum": {"argument": "amount", "partition": "currency"}}, + "provider_headers": { + "Stripe-Version": "2025-03-31.basil" + }, + "account_scope": { + "header": "Stripe-Account", + "field": "connect_account" + }, + "bounds": { + "sum": { + "argument": "amount", + "partition": "currency" + } + }, "relative_ceiling": { "argument": "amount", "basis_points": 5000, "path": [ - {"kind": "fixed", "value": "v1"}, - {"kind": "fixed", "value": "payment_intents"}, - {"kind": "field", "name": "payment_intent"} + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "payment_intents" + }, + { + "kind": "field", + "name": "payment_intent" + } ], "json_pointer": "/amount_received", - "bind": [{"pointer": "/currency", "field": "currency"}], + "bind": [ + { + "pointer": "/currency", + "field": "currency" + } + ], "maximum_response_bytes": 65536 }, "write": { "method": "POST", - "path": [{"kind": "fixed", "value": "v1"}, {"kind": "fixed", "value": "refunds"}], + "path": [ + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "refunds" + } + ], "body": { "kind": "form", "fields": { - "payment_intent": {"kind": "field", "name": "payment_intent"}, - "amount": {"kind": "field", "name": "amount"} + "payment_intent": { + "kind": "field", + "name": "payment_intent" + }, + "amount": { + "kind": "field", + "name": "amount" + } } }, - "idempotency": {"kind": "derived-header", "retention_seconds": 86400} + "idempotency": { + "kind": "derived-header", + "retention_seconds": 86400 + } }, "observation": { "path": [ - {"kind": "fixed", "value": "v1"}, - {"kind": "fixed", "value": "refunds"}, - {"kind": "response-field", "pointer": "/id", "max_bytes": 255} + { + "kind": "fixed", + "value": "v1" + }, + { + "kind": "fixed", + "value": "refunds" + }, + { + "kind": "response-field", + "pointer": "/id", + "max_bytes": 255 + } ], "json_pointer": "/amount", "expected_field": "amount", "maximum_response_bytes": 16384 }, "echo": { - "write": {"kind": "form-field", "name": "metadata[auths_echo]"}, + "write": { + "kind": "form-field", + "name": "metadata[auths_echo]" + }, "observe": "/metadata/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "connect_account": { + "kind": "identifier", + "label": "Connect account" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } } diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 7774eb4e3..c87a6df54 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index a2e2540c0..47f07248a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 396b398c9..02a128e1c 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 80f1f6ef5..eba346a31 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 103458b2d..b121d4b8c 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/2\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[188,200,112,35,193,74,254,147,192,118,44,32,181,135,150,205,250,236,146,214,4,192,194,207,108,159,92,206,174,48,102,209],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,2,200,210,54,41,12,57,125,41,77,136,159,131,119,65,31,167,146,113,197,85,33,114,81,178,193,155,105,213,254,243],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"HOm3PFLRsj0lhSuVGqlNk6h2A6FJd5_QERQylR3nCF1hj6PW81wyvE-JQBA1-cRHrnpOzZsIltwHg4r-wWi2Aw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ea02c8d236290c397d294d889f8377411fa79271c555217251b2c19b69d5fef3","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 0acde163f5c747c3c9c7c21d5576f0c507715c9f..3e125bb77c7ab60229c72502ae855e6d4cdacf35 100644 GIT binary patch literal 6463 zcmeHL+j84B5X}elEBFjW0C@LX#?7RYrfE{!brLJX0YOkgLXiwFvK^2Ay=S3IeCagP zx}BySMHxc`mW##i*@Im@dh}g+<#lFdd)w6Bfn;8<7iOuv15b^^qJKPBgE?216EzHG z*$&glV_t6S!q)RltGcPJRu!bLW}eaml+3(?Ga=YN`Tsq`W^LOwD^+D}Q(1k9UC9DB zX*#k&`jSbJury^N3Yd@>A}0KhNzU;YFd0GuV~V9XVKE6|g(nyxDPl+lEcTfo9T*b9 zl9)w4!wWc{gdiuCP(@?R$*_-b4)&jU<^m3xdDocJ&9b$XvkOMv@~bIJqld{>V(QO4 z_d;FT`PiwgM>%`YhYZtAU1O_Fh#sVlxs&S76s8_5f-pC=*%>RanQ0rnfE(z0t(K;5 zl{U^T%65awD>Es~vT=v4amtm+$S+N22a4s{-(X(Telcn0^_TUqFoV?-nA~9x7}lz8 zup5WWyutLtUbj{G{rh-L4*DkWlao7X~GM)J};!QHzPnh(9ku^LL0uB;^rwr&y zL$<*Quq0WWG8vG#0~Wz8Ab+gbP~cEJ6~%1{t#u zrp6Q&kw*9{VULudn}&c0kOVaP(34W;AV27PloIwj)0=MPjO@t_np+bMp0+8GH)CB) z)(J6{&hTC%iV(T!{jqklNV4l|kkO6^?y%99xO^kTus)az0#Q?lAcA>-5Q(rN5;P-$ z5fPAQ0VBc4sR7M$hM2(nE__5^DIOu_I81<)9BYBWBwiK?DM1X0ln^F?SjLiEZZ2Aj zP-KeWig0tz{Rrxiqs@@zrffR$_Id@2v~n*@j@LF}nryv46>FyJ?HuVmb|%ZC0IFu* zPag(9?|;_SsuLfFrh0bjpH$C(JUux+JU{&5qx|)>?%uo%^VdNfetPx%)tmNN^!B)W z7se+aUW`Yd&tDwAeOa8md)7SdlFMH%P7mM4hflB@V!vY+x~^{W3f6Y%pV#_=MVcpZD%Ogvck^63Q!pZWf^iF!u7rDXpl;kNlWs>Spr>0OT9kZ#mA?vsh64@C9VHibmoFr+gRGw>H6bA5usKJ#u z;>s=%<6D9B`a#V}iKD;Cyi+x#=nbMnWZ3O0U_-{A*SvyvyWi8fjsD$AV4r*c|J-Yl z;~VVMV^!TN95;oH6PZc?Z3DS`z+4Nivos0HT=Os&QJ$8$QE6Bdp^&;1Cc>2zMS)JV z2udzXo#&BOrcCoBDYc2?7#AwGDNJi>)Fs-Qo^G0JP(i-CeX_PvsB^D8R2p-OZ{A`U z+WufVRjqxz<&ei91*q!HoOprMT)EpH;-Jr_TDi=jRHKYqaTIxfB!DzIetL9FgzEl@ zugDL1^{3=PId|pXGjCy3VLImn=6&d0d0>(B9Za5<)>K75{T?;g5sI0yCnmUPQ6J)H z2j0wkvM!}@%VK4zF6?q#W;lG?)IG@k64es;CGv6Cct$T8)E;-0yFxdkMcmXk`Nh8n zmVK8&#UhnYxV`sX#?7NI_pv%}+3KP^OO;_wY ujeVE@m%IG`P^YnleTI&iis}RUt(kg;b=kc8QGllp`=BP@H#Pr$Q}Y|S=_rE$ literal 6459 zcmeHL+iu)85X}elEA-6GlGK%cb6dM7oIjf7Fl>l=R&Z5^8X#fW=+%98(pSNT{?4xT}gxS zrEN(E=}RU>!jxhn3Yd^+A}0KhNzTy?m<%C-R$(YkSWH3~;R#wuiWrgsi+v_&4K#^h zNz5XjVFJ!4A;@V-EJbb1NwE(w4)$Mo_7VnJcsF=w>UHDFQ7O zh@HlEb9Hn&yp;Dn{E>|R-c&1_Sf70f`-m0sJf z(Z-Hu(XQ=vR@zx^*Y$YV3a8xIln!s~6<&u+aUfwt~zQQt{Bjz zLbk;Tuq0Wmm<&jK1Qx+9AbO;*(-DM4}P85r0R>`Z(y)72qHp z<1-f)Ufs|e4b?{-jcdsK=OV$Tgn#G&DhTBh?qvw<2Qj*&dcuN$fjxwG;)@75=72ZU z`lKq<69K~MFutYdhO+MnyYPh2BlU2E83EvU;fU*+hyh z7dit^LgcmwhH88ZqTSpeAnk*}y@>SLH~*60Fdd9eF9{7W4NNLHgZ%>-Te1*_lp%Fu zJdv?sQUOqn{s)H0^%#K*1cf9OvjlJP1c#8n05x)|2;n#K8HC8YGVsaX_OfyCL#hd{ zB37JpKY|V*Y2BxpE$Ws`J&jl%)#haO{MFaT zVrI^swN>-t)6d=aWqEp#o)Mik94X#!34kMSPF}yEXgdCh-;wXL@=wVl z-rSde$Gnx*xot-qFzq6ey6OZKBl=T4dRZz9bEheU^&znbdw)y zjC)BxB`k*;W6IwTHO8UF_=6uH4mHN1#`w}T#x7NuAvvkr{7`2c3jDuT;Qxo}j2-4v g6w8!SAJNAhsu-rEdH+3ttH=G2ksnH$FJIF90&sUCGXMYp diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index de6b156057a041ce43dc8064df187c0a1ce3a9fe..fa0ae654b6c65f1c482e614ec896268039ceb061 100644 GIT binary patch literal 6346 zcmeHLZExE)5bh7yuh3_@CaL#)E3%?P*LB^REPZidP!wgektJ24oTNei`<|oiybde6 zZa^_O4nm7O9glaTYZ6D$pSxV zda^-=l1Y)VJZB<_n2;C}Cc>CW&hZ#A8AAeNj-@nXDG6bPXBZ(VQbs+ae`GA<0;G$c#%>*<&2g{G{IxSKM=A$jjFa4a*&R3 zlMAz;?Px~9bZ?`!9l8I#0QO}Zvy3yqJ&QfeY40e-HZVktSRw9Hw8B!CSvWid=m zDJ&vS@K?efDPunk0TCeyXbhnzr_4cq(Dx)K?Db|a{n{HjkQp?$AsRgGQlerWip4^8g_dVMQcpMgk)u zBF_Rwf{{}rn&k{Jf%kp*h`w?>Ld>L2xFx< z*AeGsVQ@WVMb1r?j#D7wy^OcQwgALA@=~78^KMMW>HmW9v31h@~SW@kIOO^QdhzxxRR12(wP=f z#bu?7BGJlJd68w6HffsTLd7+e*D6Vgxc~>jcxt9SdjfKUxVCh^p z989OGvyXQi@))E5RfAa&FOZr`fBQom^x4*HpE;Cjlu>JrBJb}6kS0e@Ump>n`XBKH zc~{h5B@fEEFaLoBOQTBDdmpgiCCRg7XgbA&zzs z%z`JIQX01`R#xiVuEy0Ihws{E0J&eFS^~c$A?}*M=w*xAoH}!3P2_JxE z-(^s-NaYi5?|qlCYj&t+*>@S63Vz>ZAU*b7#+Uy6uf)1Ea{RqXqV TeQ*B{di#BUvF|UwqQCeP+;#}1 literal 6342 zcmeHL+iu)85X}elEA-6GlGK%cbKAISP&Ba}G(f$9KvC2#6D_6avbJOR-+M;8z87tS zv}jSRZGe(EB!@HS91i{L**E1?(AkaaUE_lT$%5Xj>{%47hXD+cSc`$vn z9r++b$)w1bQcNTf6B13rL>M#4IbI_sV_2Y7=t?t|k`a1%h8C70g=NIjkO`UtO(s~D zvLs{}fc;4ra+(rTQJZpd>?4AM^%sG?KtLA3HNKf<-MV`63r;?WtF0<)hS`n9TrPrX zfUn$g?DS1UIs2+#a?CW|W2s$=zG^x)?bLL(w0>|%!qR$s>#V?Hwr$J`VW4NP*S2r9 zu~S&I>jquac2?STGi}ymmm8Z?T$;`el*_Zf!M&!vb7>Lumws5;!I>Fc?yv?NYjroc zT|gGWVEbWq?-Lnx&Cr;phDSixZD!ZwuuBYVI{RtFNOC&Nm<)lDEj%&;4v4@N1G-eq zb~pi+Buf>O5t&cGBDh5aP#`Kn8z<;xG2TLj#EX>pq!@LPX@b{;zb9mU8g=a|aFDif z$Av}EwDd*8^~p!$S_=P}$gn8kA3lHzLWP8T83X%KidS+yV^PGw9>P2EMZ_Fqz#D2q zaux20h+z!bD}q195^rKfY}&E`21F2gRfNCJ_O{zhj`rjVecOr+-fn17G@~zPTT<+} z&>LhDCigQi`spi(c6|*&x)p;*igcHo|A;tjH%7acga(8LAr+h<{t<#LS&Tr+m|jvm zQLqtG0Z>i(2Zkv1=s^kuNs>xghOc-+LMUH=8YNZ4$Q$JhMwDF{g%odl(K_TI*MwJ* zD$aSBzz2}D8S=tbO-G^L_Mnq`p5$l}wq1^9H=&=4tvj0% z=%W;}<8#m-R{LzdI7E56PQ%nK-}PyqLW@{`OGJ z%*o5nx353{+W%M&=P#F0H#>jlvGTca0 zB}P@TF;?4|US(mLMnY6NRWcPOj$Fz%apdY9#x5Pwx=`Z8ahzio;!J4YgD;c0qTsU!&9&thPFSL&vomb-w4Qa zC<3PH?UF=+rn#EVewaf$n|d?RhImGF+HjP3e`ElTynS){meh3m5r1Mo6!jO`LvJ42 zzh}Y9>e6;o3|R1?pNazq#&>XeUO8Kr{rr1WV5cZ$#-3#0qD6IxtsMl5;BZ?=<9tQW zT3@*JxX!Wpw(&ib{Svhj#3c!{2m{TkLFMsy@~Ol^5(9A@8xXp?cUMYcCE><-K$8zZqH)J3 z(4pJW@Kd3pVb*^EqS(ioJ#*%acC|OFzgD|TOZPs1?|$iYWc&F3`&-wDAhZUDpn#kP zA`7GhC|;~*Xh28_g32+1u?#&33tBP(0fD^XSrA8sUWA!IN-c;aS;un{5@X&Q{|??h zY0_D0E~?osq9nDUr{gE6_H#SGZ z-QH#I`H|Qg9XI>iI=oa?e;8~G_D}m}yxUB)9Ug9-zy5T&)f;cu!%6>Sy>TC3U5$EU z+j}R8&smOL}o{ zUM;G5b9rl{bs-uY)G?10LEJz|$YP4voOnc83G-N^$B~?+965BL&#a;BDWHl7Zn9Yq zL2Seprn6yy@@isqHc)*yJA#REvAVo=vft~!)`RYo(c)OmrqAB(KYBBJdg7+iaoxSr zj)%LW;rVQ&Pak%9dh7-VftTm+ciVfz2OVywQEz^F*8li?@p$%j*?VQ??d8Fdbe5~{ z*T3#eQVL#)PHc+0iaIIpB#D~X;G;`rT~sMb>6A$-Nvd6nwN0riDy^I=d9}ScXnx+f zfA#;R{XLh~Y;X4e>6iWE_Tf%dC`qBjFCbAR9epX$lp(}AXzvYkUHB-TleJdZi{*(V RjuRJ4TUWJi4)1(v{Q)BOFINBn diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index b92671f5fe45b89e13794cf8a3330f05b373ebf3..bed4f63669d4025dd9bb74840fea3915b22028c0 100644 GIT binary patch delta 883 zcmeHE$w~u35H%VV5f6TW;2{U8Lsc)+-8W^BNZjI*O%%x_J)j9uCvm;_0fLwOg*Ta- z;$MkptMeCvhhE<6SFc{tU!~7dacXMe<-Pb?D9C(e@qGFj5ro!Y5fqTsKxBZF0L6!K z3?mRyf}rq>5E+IJgaIvCfPg?Q;$0B4LQiNGkWv#NN%nDEgv6NdkvoIa)yxllcGn(V z(idZVj;xgl%)%66l69N))VJyCBA zvgV#n4wTV1)k?K_U5;AE*@-r_%bnY!r~93_wb!kkl&>~3`*`@!h+8J!7=O&Ytw$hDz*nqTYkAEk#vLAEcR_ltMllPE>ZLfR4sO_?FF zhS+3i1shMskVfU1IDxDJ#{z{{J0Kki8v-Zc1NaJD<$(-@ktl#5YcNr%4Ik;l%VoaG zm)qSzxo{^M9L%A|iePTwBxIo?HZ>Wl#ZhgHh%Z*{LPoy+o>B%-8D~#w%={^ zx;L|)o*y@PJaL^1&+D7-jp}Llb)BoR*ILdO?c4XOliAmG>yuel*B4h(UvGXseSCEp zqtBG+$YwCggN`b55=C8Fp9L3(qd^{n44pDjMTsL9!^p;%4|1)X8}g=h*xCMhcC`Qh O)Bc@L+tv;bihluY#NbN+ diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/airtable b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/airtable index aace62f964d50a4a109680014005213b6b72d2dd..3c23d8206957febd8a2ee035a277d1c97a0a3d9a 100644 GIT binary patch literal 2708 zcmeHJOK;ma5bkl2UqSG&C(E|{OmZu_1$t}I=2ip(C5|knlBklj6T|R--{DJ=lQf6! z9;<^bk@Nicac17V`|I!16(Lj?6*P?A63X_b($gI?@W_sdfPgURe_rVTTDogGrYFFR1oNR_p$ z0o}1@1_wih0uHSa%$l=cV1_?L%dPPom;yy{@$52}O6){ycPe8#eLI`6PE1*da$3m7 zJAYKd*aU*P223TL!7uOcK74XA7Dr|(6#DLbk|2EHzZ6fvgSgu`uzK&1Im~TT_HmKf z7w^oz_3{5&pLN~c$8UG@_@w{MoXP9oF$eWUcJ`<&xX3!GcqVusl*{$ro&jc;OMdLZ z9cBBVW!r;ABUG=zBJ&3*OfQNiN`ay1kx}R9)zy*17k1v#LcM>Gr{5e+pLw!+BfHM; zC_KN70s}x@jf`%Pw-KT!a}Kod-{Y_0J-+#W`y1$;+q=h%KpcDW{$c6wvDC6L>!fH6 zRuClh%(H1WB0=CYJatG%;F&*ncL9d;4MGij63xEJ6c#htYRK}V0n6BQv%FsQM+ikF zhqJq^LnDUS;F1`e_kg=`VHB-v2br_#h!v_0m5wUzw#LLRMLnYw90WWL0X^?CP?nfF zwizpy6tXpn6=vpZI7Wmk8h-AfEnKd#RMM~D03xOWG5|^(fJByVoePaZN8rTQ6Y?lb z^tsiC~ZOJ*-?U$lj5N2sPoC4kl}2iNevy5dMi#j!s>q;ZZaVYkBDU^!C&j%@g&_7IU{X8+UyFq}nLa?&yRD^3vOMagAT1wN%Eh z^CYNV_URKf#}2tgp+&I?mU1OnYmn{VX>7KM>)`ij0pY|Mr5{7y@V;4%oNrcMH*}h} zqFyaWdg<2b4S1pEufu)c;k0zHO`Lv#mRmUP&uAbZ6gmhl?4S(;3sS3LI8QAmaneF0 z`n2OD(EvaSk!(Oc*+avZr%xyS^g`w?br0$?5 T)DLX0&TI4lO1q|$p0EA|vor7P delta 390 zcmbOtx|pAZfq~U@B8xVo(L{qs0!rDLc_~U(3Q9?-iAAYJN|Uu1Q!Lrr`@_R;EDLm44OtN}drBidjw&W$|f-NaZP0lY$iO)JC$b7p R_GROqY{aIuS)C)72>?TwZF2ws diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/github b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/github index 4cdccaee482001be4adca08d6365d2c34d1b3f8c..c44126ea6088a59a9cfbef18c09a4f8f944ee803 100644 GIT binary patch literal 2008 zcmb_dJ#X7E5Y5shzk=Xw*_LBliN|&=(4tMJATTKMWHFIMm86^)hS&b?9!W`&?IsA2 zYOp2p?%mhByNioYfA*JzP{VU58C?;|8k?K(hFN%GyGR3c(T}xvcSa0KSscO*7D!r~)38rR8 zST7i;E1 zy9F!3=E}o;|Mv6Ni@5ADo1@H~H%MC9BjcHT2GNT9i!Cb}pAQYSGR`aac+cERFz4QS z|6hmj^^F8l$A9Cc)+Uwpq2 zRuNw=A}eBZAfA^JTW&|B?xU-$ZF$dgfw-* zcBtgDhz3v{i#{f|2p?>fY)4WcTWMrk0I_Ol7X1>S%{XwdS@^yI*ghaJ-rt~a%73tQqtAq0YzGRn&%RQ#NEHUhMs?ycIr|7=*df!^0#%fF) z9nq3K%d#oyYPMM7m#o6q^f01f2x6+&5=YP*s>}I6GwwBy$LF5fU5zZKP@%aIwwji# zvdE3QZbX-P)0Zc1ty9_5qunG|%0GA*;XxHPp`Y4R+l u1_dNbQ**%X%S+4!JFg_OBqvpAavZamJZ?ov`6-o3leaU=Zf<7{WC8$o*iS+L diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/stripe-refund-approval b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/stripe-refund-approval index d489d59c28efc2102a433c208e80092cedaa79d2..214fca7ac4ec51f41a6e6a0d8ffdce22779b9097 100644 GIT binary patch literal 4978 zcmdT|+m72d5bg6m^%Dp_ukV+2{1y~N(WeGT(3izRprx_RL=s(+a$+p@hx(PB;Z2g) zc9Av((jdU@ik#u_%$YMJfB50YKcDXy<0jujCHR_g(b&Bi?u3QU;xy2Z%L5FIYIF{x z8Na8=2d%cUgv=Xdh1`L$WLs=zV*aq2j>U4j$Y(jsR;$@~x!Qo3EEn_X!*l}U`I}s9 zR`bP7OvQHb@FstF5c6fR$QR(<8_-9Y135HS)AAa&Ora_QATl04JrP)L1OeO7exd_%A?&_q&N`#cD8@o76(JPw56zFFY#c(k?-T)JFL6nl z*sk^!{x+f%HGy0Z zVli93!U)MMp+H0hR!WzcEo7Ls3hZ7vj{oxWhaRgg;dxFXba0E7*NJ&X&41xHZ;VwH zXw#)=7h%Ra7-K{v5C(xUR@kPG46$@Ro~7iVY5F~puOI9GAHah+smA{2@C6_}pu~R% zC|6qUWR3jfdutD7JsOFF9D1D}=Bn~4j)HlV1?X&#Y^Get!sqXONBA8-O6B}a$J51N zJR8g=!;LVqBwqNnLLp+G!miM|@IEPo;OuQs7q3rzE1`51lB>Fg+-9AE_Kr6wMy|+w zX>rq3$vrYo=v`A`YoR4X<%BCr9~POm(uUCUMr)|^lc#bEl7>=Pl+!E+S;~5soL_g% zY464hGQqVNkH=v@XRW4{gR8ZCslB9n_$qrO8zGTVo2XmT-F8OsN5BwH>f{7v-&ZVu zLM@g2>#pSSM^!{9kExIHjc@difu)^2bz54>PbZp|9lhj51$qjgUu|$vygidXYiT>w zY}NVQZ||c#p9^y**lS|^?GhM|UIC~++8b4z5;rkZDIBGJAyaC6J+&q5zMbVVmN$)c z{kTeO!T(z_gvt+YLhXIM^I#bE98(*A2J&(gsOq4Q*I2;q8VLl{En?gt$W7b@_9H3< zRDjF?DvZ;S)p9-_yX9IDP#Zc3qYgNk^GW}%s1SE_fsgT6H}KUGXJY=k<@M^glTLxt z#o{92UL87n^2*`M0reVteJaxa_|>9}r%qp#kndH>DDRhOmz~J+vkfM#!a^2>u;S5O zr!w;R6ja`W!F_t2u#MvEQ9HZsVj7MTKDY6lU)5l{#ZBWKiKY#ZQC5rGj{JQH!^JNK z&*4bZ-i3w#YD@!6)xdm>GqDr0HkR2vFyuCJ6k#k_C{^YqoNbkMGYV-Ar8waPkMWRw z*h|Ckf2}MN=#QR;*F}hk58+2R1oea~Kcj+GJq^T4e zaM#bb{l<<~O)Xu^$B;2d`pYo2^;*GLksiQ=C$I_rQ^$r`C1Bz*hchi1MKY1Ul zb6}wfL9mDmv1k1w@6q^G>^Iar$zfvD<3h{?Ci2L8yc3y zH&E&UU&5OPA3?CM;3UlAL%Fg!BjwD(%CJoCMq_PaHA|PQfRxL#A|+g8nnzA-U@;s~FM=yVmCWes6D( zyS7t&+5dVurn4xO=3R#*FiHjZo{-qFR&Qzz_||%fbL&1BF{D7^2^PgVk&KLi`jF^w zUdbegq4T_;rr?YMm>5_r;vAUtN}}2s87jKIFkM6%>J!gvTNu~2D>2hPL%hDtP&St7$r@mRu2l%7mpr}8+ z=5T4&+I@}(_VN0H(^AYqsa3I}p&3O@{Bk`^sY5so&2|(u_;9V=FRN5I!4&*Xk&{X# z0gWPvxF_W5bfjDeud>{V3)9=U0!?NTj}<#S|Jlpz}+NHZNn}?d|>~oGmae+2(;2& zBuE&~oS8WukLSaOe|{bA7~?kEKq>fwaj|t9J6Q_{uVOzokf|ERR&PxP_cJ~s<=W_6 z6|iiKmQt<3IjX_|>Vnaz_YDa340Y**eOd0N&6=*k2&c`m5+&GL z^s!DDXe*&|N)Qs!fVsV>N)j$cWx#M09(~T*sI{tSW#e3J7x(v~R+A9lB-3T%`qd~$ zkq5LA+(vu6uV4QA=2eJ4;WnuA-Fsv~x92@qZyls0>6cl}YVD!>BqqjEv z>i|g7|FXCHDr*ru(lZf+zE@iA+tjc8v>iRvMEXimok=?gKdi1gY~V`d zsh+F!CoWNmBaRNHA$}&EAkfEUNI6LQ3sMG zy+OV`fCQTvRXg0PcMhqGd@Za&`EfvcDLa?+|37yyPAl=PdD5>Zh8x%^cy05)xYr=h z@j&CXMrvc?+K9~EHx~z<4U|~;xrHi&ZmZy*{WZgM1&pp5_Nv^5xeYL>Y+Z;wNESAZ z33s-D^f^@t+L#IZYV=M?Fk_3qtkO>9D)Va$J0ROBt5&K|ZqLlN0L##{D43}0Vn1ol z-*afU7X?beUle3p?GE0$jf@v!1^x#89IOJ*ZGrLbws#NmpCSM4l;Q3gQorQ#{VPAJHtN7g{O`)=-5ZEXV6#V3$lrad6~|Hs(0k z(V-eQvm9m@r_nHsS}5}IMq3AR9A?jPp|ck{wn4W|_8n$W-VUG_VK%cPifQ<~m_7Lp LjP>nzdc6A$Mb+vd delta 462 zcmcaDHj$r&fq~`!L>6sEqlpH01eCHf^HP+o6qJ%u6N^%dlqRb%Ce_0Q(=sbkQf3~5(_ewYIV32z@QqB!ZJhR)D>6eB`ei}4UC1Dt2Eh{X(dxN*JMs+y~$Fn zGI~lSl?5Qn5!Mx#6lLb6qc|+HBsDiaF(pN5@Q9=q3H0zS{ z^GZ_lNfu@N@{U(QDycVBG1g9A%%-{d6vsp+ E0KTP%umAu6 diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index d7fdff8ad..6098987c1 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0275855503cf68ac7b379331a2c8204ff6cf1e885c8f91b638e4db8ba7e3edd8"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"287084421c003dfa78ab3138d2b53f784c7ff9a405c723df9de0050b91e3f871"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"db7c13f8168f1a7dba9d63cc7617568ef1469f133c612be18cc496bced3dbe7d"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"dcb58c43228b145b5405224c77f61bb0858923296872f5288170ba9c6d9d40e3"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"dd2c2ec65ce92b260d3391fcdc633320940d21dfe2640164d768908b1db5b6de"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4f03d8893a8ad762164055f519e74245d35d2cb9d4d700d25a4ab6ac9e90169"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"51693208270231c25c3aef2a32151d5962114c71e86b88cb9df83181c7af83d9"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fecf9af67e7afc48d080e9f8f55f8ce28e49d0e08988717a27908bbda461d6b6"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"c3eb7d9fdd98dacf52750b14b67ad7b7faaecbbdeafff1e0b049f67d0a2d0139"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"1af50298fb1461e1b24cbdf560d43124d6b1c4c529586c911b1c4797214a69ff"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"edaae33b432440ef04681488851cd75c80c6ceef4457bf79757429ed6e717b34"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"3ebd3d4687a472b1f771d3d0467366d9e746bd73fa462e53f4020125e1850313"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"092e10290e9103a141b088a38c71c80f67718e1e644ddbc0e84adb5ca3f711a8"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"80581b4e946732ba2093c6bf1212a4e32cb3af1086a25ce5482891e9bd528b1d"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0f88771f2af4e10933eaed781f1c7c0622af236a667a233afe9e585c30bbca22"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"41ebd1f7420603da8198c27ff90f830771f79917dacb477688c44c974ba79263"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f5fd3b28bf0663b46aee082f202bfe101234cd258bf0c5a492a73abe3231af99"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"39ad3705eb3aee2377497ced44b67b66adf871ae94467479bae06e2903d6455a"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"dcb58c43228b145b5405224c77f61bb0858923296872f5288170ba9c6d9d40e3"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"26d026f98463cafd65f059ddaae1441d57d98549f506709b0058c8cf8d8fb385"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4f03d8893a8ad762164055f519e74245d35d2cb9d4d700d25a4ab6ac9e90169"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"825f2ee17f0876c51c76e21fff06ea0c4690fd77ddb9850259936f062cc23aec"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"3ebd3d4687a472b1f771d3d0467366d9e746bd73fa462e53f4020125e1850313"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"092e10290e9103a141b088a38c71c80f67718e1e644ddbc0e84adb5ca3f711a8"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"80581b4e946732ba2093c6bf1212a4e32cb3af1086a25ce5482891e9bd528b1d"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0f88771f2af4e10933eaed781f1c7c0622af236a667a233afe9e585c30bbca22"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 85057972c..d3104d29b 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -3000,13 +3000,17 @@ mod unix { let review = effect .private_review() .map_err(|_| "gateway.effect.review-refused")?; + let rendered_review = review + .render_literal(auths_gateway::effect::LITERAL_REVIEW_RENDERER) + .map_err(|_| "gateway.effect.review-refused")?; let signing_message = request .signing_message() .map_err(|_| "gateway.effect.approval")?; let output = Zeroizing::new( serde_json_canonicalizer::to_vec(&serde_json::json!({ - "schema": "auths.private-effect-signing/1", - "review": review, + "schema": "auths.private-effect-signing/2", + "renderer": auths_gateway::effect::LITERAL_REVIEW_RENDERER, + "literal_review": rendered_review.as_str(), "approval_request": request, "signing_message_hex": hex::encode(signing_message), })) @@ -3015,15 +3019,16 @@ mod unix { if output.len() > auths_gateway::effect::MAX_PRIVATE_EFFECT_REVIEW_BYTES { return Err("gateway.effect.review-refused".into()); } + std::io::stdout() + .write_all(&output) + .and_then(|()| std::io::stdout().flush()) + .map_err(|_| "gateway.output")?; private_file( &request_out, &request .to_private_bytes() .map_err(|_| "gateway.effect.approval")?, )?; - std::io::stdout() - .write_all(&output) - .map_err(|_| "gateway.output")?; Ok(()) } diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 68ce202c9..7cd664314 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -24,7 +24,7 @@ pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/2"; pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/2"; +const COMPILER: &str = "auths.gateway-effect-compiler/3"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -34,6 +34,8 @@ pub const MAX_EFFECT_APPROVAL_SECONDS: u64 = 3_600; /// Private human review can contain the exact body and full binding. Public /// activity/receipt projections have a different, smaller disclosure contract. pub const MAX_PRIVATE_EFFECT_REVIEW_BYTES: usize = 131_072; +/// Native full-value, non-markup private review renderer. +pub const LITERAL_REVIEW_RENDERER: &str = "auths.literal-complete-review/1"; /// Maximum canonical operator effect policy, checked before decoding. pub const MAX_EFFECT_POLICY_BYTES: usize = 4_096; @@ -215,6 +217,7 @@ pub(crate) fn approve_driver_fixture( ) .map_err(|_| invalid())?; let effect = BoundEffect { + review: serde_json::json!({"scope": "synthetic post-verification oracle; no human review claim"}), binding, command, connection, @@ -590,6 +593,7 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { /// exact immutable compiler output. There is no public constructor, clone or /// deserializer. Compiling this value does not approve it or grant entry. pub struct BoundEffect { + review: serde_json::Value, binding: EffectBinding, command: VerifiedCommand, connection: ConnectionRecord, @@ -606,7 +610,11 @@ pub struct PrivateEffectReview { schema: &'static str, effect_id_hex: String, binding_canonical: String, + binding: BindingWire, + installation: serde_json::Value, native: crate::GatewaySubmissionReview, + semantic: serde_json::Value, + renderer: &'static str, } #[cfg(unix)] @@ -618,8 +626,40 @@ impl fmt::Debug for PrivateEffectReview { #[cfg(unix)] impl PrivateEffectReview { - /// Encodes the native private review; consumers display it without - /// reconstructing identity, provider bytes or authority facts themselves. + /// Renders complete private review as literal ASCII JSON. Non-ASCII and + /// control characters remain escaped data, including bidi controls. A + /// caller may not substitute a renderer that truncates or interprets markup. + /// + /// # Errors + /// Refuses unsupported renderers, encoding failures or output above 1 MiB. + pub fn render_literal(&self, renderer: &str) -> Result, EffectBindingError> { + use std::fmt::Write as _; + if renderer != self.renderer { + return Err(EffectBindingError::Unsupported); + } + self.to_private_bytes()?; + let json = Zeroizing::new( + serde_json::to_string_pretty(self).map_err(|_| EffectBindingError::Invalid)?, + ); + let mut rendered = Zeroizing::new(String::new()); + for character in json.chars() { + if character.is_ascii() { + rendered.push(character); + } else { + let mut units = [0; 2]; + for unit in character.encode_utf16(&mut units) { + write!(rendered, "\\u{unit:04x}").map_err(|_| EffectBindingError::Invalid)?; + } + } + if rendered.len() > 1_048_576 { + return Err(EffectBindingError::Invalid); + } + } + Ok(rendered) + } + + /// Encodes machine-readable private review without reconstructing identity, + /// provider bytes or authority facts. Use `render_literal` for human display. /// /// # Errors /// Refuses an encoding failure or a review above the fixed byte limit. @@ -669,7 +709,17 @@ impl BoundEffect { .map_err(|_| not_entered("gateway.effect.invalid-binding"))? .to_owned(); Ok(PrivateEffectReview { - schema: "auths.private-effect-review/1", + schema: "auths.private-effect-review/2", + renderer: LITERAL_REVIEW_RENDERER, + binding: self.binding.wire.clone(), + installation: serde_json::json!({ + "provider": self.connection.provider_kind().as_str(), + "alias": self.connection.alias().as_str(), + "connection_id": self.connection.connection_id().as_str(), + "credential_generation": self.connection.credential_generation().get(), + "connection_contract": self.connection.contract().as_str(), + }), + semantic: self.review.clone(), effect_id_hex: hex::encode(self.binding.id().as_bytes()), binding_canonical, native: crate::engine::review_command(&self.command)?, @@ -1051,13 +1101,25 @@ fn bind_mutation( request: request_commitment(request)?, }, })?; - Ok(BoundEffect { + let review = serde_json::json!({ + "contract": installed.recipe.effect_review(&command.arguments).map_err(|_| EffectBindingError::Invalid)?, + "recipe": installed.recipe.review_document(), + "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.", + }); + let effect = BoundEffect { + review, binding, command, connection: installed.connection.clone(), proof: Zeroizing::new(proof.to_vec()), action: Zeroizing::new(action.to_vec()), - }) + }; + #[cfg(unix)] + effect + .private_review() + .map_err(|_| EffectBindingError::Invalid)? + .to_private_bytes()?; + Ok(effect) } /// Preserve all selected branches and evidence through the existing native diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 74a9d8a39..f4aeeba7b 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -43,7 +43,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { let observer = signer(h::OBSERVER_SEED); let recipe = recipe( &json!({ - "replacement": {"type": "enum", "variants": ["private-sentinel-Approved", "Pending"]} + "replacement": {"kind": "string", "minimum": 1, "maximum": 64} }), &Value::Null, ); @@ -52,7 +52,7 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { let arguments = json!({ "operation_id": "bound-native-1", "operator_namespace": NAMESPACE, "recipe_digest": recipe.digest_hex(), "record_id": RECORD, - "replacement": "private-sentinel-Approved" + "replacement": "private-sentinel-\u{202e}Approved" }) .as_object() .expect("arguments") @@ -103,6 +103,28 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { std::str::from_utf8(expected.body()).expect("body") ); assert_eq!(review_json["native"]["request"]["url"], expected.url()); + assert_eq!(review_json["schema"], "auths.private-effect-review/2"); + assert_eq!( + review_json["semantic"]["contract"]["schema"], + "auths.effect-review-contract/1" + ); + let literal = private_review + .render_literal("auths.literal-complete-review/1") + .expect("complete native rendering"); + assert!(literal.is_ascii()); + assert!( + literal.contains("\\u202e"), + "bidi controls remain escaped data" + ); + assert_eq!( + serde_json::from_str::(&literal).expect("literal JSON"), + review_json + ); + assert!( + private_review + .render_literal("truncate-to-summary/1") + .is_err() + ); assert!(!format!("{private_review:?}").contains("private-sentinel")); assert_eq!( &EffectBinding::from_private_bytes(&bytes).expect("binding data"), @@ -136,7 +158,9 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { ), }; let fixture = serde_json::to_vec_pretty(&json!({ - "schema": "auths.effect-fixture/1", + "schema": "auths.effect-fixture/2", + "private_review": review_json, + "literal_review": literal.as_str(), "scope": "native compilation and exact approval; no entry or durability claim", "effect_id_hex": hex::encode(effect.binding().id().as_bytes()), "operation_key_hex": hex::encode(crate::GatewayAttemptKey::for_operation(&policy, expected.namespace(), expected.operation_id()).expect("native replay key").as_bytes()), diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 942e9a96b..170a2f4e1 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -207,7 +207,8 @@ pub(crate) fn recipe_sources( {"kind": "field", "name": "record_id"} ]); let source = json!({ - "schema": "auths.gateway-recipe-source/2", "profile_schema_digest": digest, + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": digest, + "review": crate::recipe::synthetic_review(&schema["fields"]), "service": SERVICE, "tool": TOOL, "operator_namespace": NAMESPACE, "credential": {"kind": "bearer"}, "origin": ORIGIN, "write": {"method": "PATCH", "path": path, "body": {"kind": "json", "value": { diff --git a/product/runtime/auths-gateway/src/pending_vectors/recipes.rs b/product/runtime/auths-gateway/src/pending_vectors/recipes.rs index f155ad139..4ef59fd22 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/recipes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/recipes.rs @@ -1,4 +1,4 @@ -//! Recipe source `/2`: valid bases with the recovery class each compiles to, +//! Recipe source `/3`: valid bases with the recovery class each compiles to, //! and hostile cases for every construct the revision adds. //! //! The bases are derived from the committed fixtures and the north-star @@ -13,7 +13,7 @@ use sha2::{Digest as _, Sha256}; pub(super) const FILE: &str = "hostile-recipes-v2.json"; const SCHEMA: &str = "auths.gateway-hostile-recipes/2"; -const SOURCE_V2: &str = "auths.gateway-recipe-source/2"; +const SOURCE_SCHEMA: &str = "auths.gateway-recipe-source/3"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const AIRTABLE: &[u8] = @@ -98,11 +98,11 @@ fn airtable_pre_entry_lock() -> Value { ) } -/// A committed recipe under the `/2` schema, with its echo placement in the +/// A committed recipe under the `/3` schema, with its echo placement in the /// `/2` object form. fn revised(bytes: &[u8]) -> Value { let mut recipe = parse(bytes); - recipe["schema"] = json!(SOURCE_V2); + recipe["schema"] = json!(SOURCE_SCHEMA); if let Some(pointer) = recipe.pointer("/echo/write").and_then(Value::as_str) { let pointer = pointer.to_owned(); recipe["echo"]["write"] = json!({"kind": "json-pointer", "pointer": pointer}); @@ -143,7 +143,7 @@ fn stripe_plain(lock: &Value) -> Value { /// which declares every capability the revision adds, bound to `lock`. fn stripe(lock: &Value) -> Value { let mut recipe = parse(STRIPE); - assert_eq!(recipe["schema"], SOURCE_V2); + assert_eq!(recipe["schema"], SOURCE_SCHEMA); assert_eq!(recipe["provider_headers"]["Stripe-Version"], STRIPE_VERSION); recipe["profile_schema_digest"] = lock["schema_digest"].clone(); recipe @@ -242,7 +242,22 @@ fn bases() -> Value { let platform_lock = stripe_platform_lock(); let plain_lock = stripe_plain_lock(); let pre_entry_lock = airtable_pre_entry_lock(); - let base = |recipe: Value, lock: Value, recovery: Value| json!({"recipe": recipe, "lock": lock, "recovery": recovery}); + let base = |mut recipe: Value, lock: Value, recovery: Value| { + let synthetic = crate::recipe::synthetic_review(&lock["command_schema"]["fields"]); + let fields = recipe["review"]["fields"] + .as_object_mut() + .expect("declared review"); + let expected = synthetic["fields"] + .as_object() + .expect("synthetic review fields"); + fields.retain(|name, _| expected.contains_key(name)); + for (name, declaration) in expected { + fields + .entry(name.clone()) + .or_insert_with(|| declaration.clone()); + } + json!({"recipe": recipe, "lock": lock, "recovery": recovery}) + }; let verified = Some("verified-locator"); let response = Some("response-locator"); let mut bases = json!({ @@ -1008,7 +1023,7 @@ fn document() -> Value { pre_entry_cases(), ] .concat(); - json!({"schema": SCHEMA, "source_schema": SOURCE_V2, "bases": bases(), "cases": cases}) + json!({"schema": SCHEMA, "source_schema": SOURCE_SCHEMA, "bases": bases(), "cases": cases}) } #[test] diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 00ba824c5..64d34c77b 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -1,4 +1,4 @@ -//! Recipe source `auths.gateway-recipe-source/2`: compilation, operator +//! Recipe source `auths.gateway-recipe-source/3`: compilation, operator //! review, recovery capability, and closed request construction. //! //! The compiler parses the source once into a typed AST, refuses anything @@ -20,8 +20,11 @@ use url::{Host, Url}; pub use auths_gateway_kernel::{construct, recovery}; +mod effect_review; mod lower; mod review; +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) use effect_review::synthetic_review; mod runtime; mod source; mod validate; @@ -47,7 +50,7 @@ pub(crate) use runtime::{ use source::{CredentialSource, IdempotencySource, PathSegment, RecipeSource}; /// The only recipe source schema the compiler accepts. -pub const RECIPE_SOURCE_SCHEMA: &str = "auths.gateway-recipe-source/2"; +pub const RECIPE_SOURCE_SCHEMA: &str = "auths.gateway-recipe-source/3"; const MAX_SOURCE_BYTES: usize = 65_536; const MAX_LOCK_BYTES: usize = 65_536; const MAX_BODY_BYTES: usize = construct::MAX_BODY_BYTES; @@ -513,7 +516,7 @@ pub struct CompiledRecipe { impl CompiledRecipe { /// Compiles source against the exact generated profile lock. Only - /// `auths.gateway-recipe-source/2` is accepted. + /// `auths.gateway-recipe-source/3` is accepted. /// /// # Errors /// Rejects malformed, unbounded, stale, or unsafe mappings with the code @@ -544,6 +547,7 @@ impl CompiledRecipe { let fields = parse_root_fields(&lock.command_schema)?; let namespace = OperatorNamespace::parse(&source.operator_namespace)?; validate_binding_fields(&fields, &namespace)?; + source.review.validate(&fields)?; credential_requirement(&source.credential).validate()?; validate_origin(&source.origin)?; validate::validate_source(&source, &fields)?; @@ -563,6 +567,14 @@ impl CompiledRecipe { }) } + /// Projects the declared complete review fields from already verified arguments. + pub(crate) fn effect_review( + &self, + arguments: &serde_json::Map, + ) -> Result { + self.source.review.project(arguments) + } + /// Returns the domain-separated compiled-recipe digest. #[must_use] pub const fn digest(&self) -> &[u8; 32] { diff --git a/product/runtime/auths-gateway/src/recipe/effect_review.rs b/product/runtime/auths-gateway/src/recipe/effect_review.rs new file mode 100644 index 000000000..c6b0ffc63 --- /dev/null +++ b/product/runtime/auths-gateway/src/recipe/effect_review.rs @@ -0,0 +1,165 @@ +//! Recipe-owned presentation semantics. Labels and units come only from the +//! operator-approved recipe; values come only from the sealed native command. + +use super::{FieldSchema, GatewayRecipeError}; +use serde::{Deserialize, Serialize}; +use serde_json::{Map, Value}; +use std::collections::{BTreeMap, BTreeSet}; + +const SCHEMA: &str = "auths.effect-review-contract/1"; + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct ReviewContract { + schema: String, + consequences: Vec, + #[serde(deserialize_with = "unique_fields")] + fields: BTreeMap, +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum Presentation { + Text { label: String }, + Identifier { label: String }, + Boolean { label: String }, + Integer { label: String, unit: String }, +} + +fn unique_fields<'de, D: serde::Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + struct Fields; + impl<'de> serde::de::Visitor<'de> for Fields { + type Value = BTreeMap; + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("unique review field names") + } + fn visit_map>( + self, + mut map: M, + ) -> Result { + let mut fields = BTreeMap::new(); + while let Some((key, value)) = map.next_entry()? { + if fields.len() >= super::MAX_VERIFIED_FIELDS || fields.insert(key, value).is_some() + { + return Err(serde::de::Error::custom("invalid review fields")); + } + } + Ok(fields) + } + } + deserializer.deserialize_map(Fields) +} + +fn trusted_text(text: &str, maximum: usize) -> bool { + !text.is_empty() + && text.len() <= maximum + && text.trim() == text + && text + .bytes() + .all(|byte| byte == b' ' || byte.is_ascii_graphic()) +} + +fn binding_field(name: &str) -> bool { + matches!( + name, + "operation_id" | "operator_namespace" | "recipe_digest" + ) +} + +impl ReviewContract { + pub(super) fn validate( + &self, + fields: &BTreeMap, + ) -> Result<(), GatewayRecipeError> { + let invalid = GatewayRecipeError::InvalidSource; + if self.schema != SCHEMA + || self.consequences.is_empty() + || self.consequences.len() > 8 + || self + .consequences + .iter() + .any(|text| !trusted_text(text, 512)) + || self.fields.len() != fields.keys().filter(|name| !binding_field(name)).count() + { + return Err(invalid); + } + let mut labels = BTreeSet::new(); + for (name, presentation) in &self.fields { + if binding_field(name) { + return Err(invalid); + } + let (label, compatible) = match (presentation, fields.get(name)) { + ( + Presentation::Text { label } | Presentation::Identifier { label }, + Some(FieldSchema::String { .. } | FieldSchema::Enum { .. }), + ) => (label, true), + (Presentation::Boolean { label }, Some(FieldSchema::Boolean)) => (label, true), + (Presentation::Integer { label, unit }, Some(FieldSchema::Integer { .. })) => { + (label, trusted_text(unit, 80)) + } + _ => return Err(invalid), + }; + if !compatible || !trusted_text(label, 80) || !labels.insert(label.to_ascii_lowercase()) + { + return Err(invalid); + } + } + Ok(()) + } + + /// Required full values are never truncated or interpreted as markup. + pub(super) fn project( + &self, + arguments: &Map, + ) -> Result { + let fields = self + .fields + .iter() + .map(|(name, presentation)| { + let value = arguments + .get(name) + .ok_or(GatewayRecipeError::InvalidSource)?; + let mut field = serde_json::to_value(presentation) + .map_err(|_| GatewayRecipeError::InvalidSource)?; + field["argument"] = Value::String(name.clone()); + field["value"] = value.clone(); + Ok(field) + }) + .collect::, GatewayRecipeError>>()?; + Ok(serde_json::json!({ + "schema": SCHEMA, + "presentation": "literal-complete-values/1", + "consequences": self.consequences, + "fields": fields, + })) + } +} + +/// Explicitly synthetic declarations for native test builders, never production +/// authoring defaults. Production recipes must provide their own semantics. +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn synthetic_review(fields: &Value) -> Value { + let declarations = fields + .as_object() + .into_iter() + .flat_map(|fields| fields.iter()) + .filter(|(name, _)| !binding_field(name)) + .map(|(name, field)| { + let kind = field + .get("kind") + .or_else(|| field.get("type")) + .and_then(Value::as_str); + let presentation = match kind { + Some("integer") => { + serde_json::json!({"kind": "integer", "label": name, "unit": "synthetic units"}) + } + Some("boolean") => serde_json::json!({"kind": "boolean", "label": name}), + _ => serde_json::json!({"kind": "text", "label": name}), + }; + (name.clone(), presentation) + }) + .collect::>(); + serde_json::json!({"schema": SCHEMA, "fields": declarations, "consequences": ["Synthetic fixture mutation; no production semantics or human-review claim."]}) +} diff --git a/product/runtime/auths-gateway/src/recipe/review.rs b/product/runtime/auths-gateway/src/recipe/review.rs index 2a2168cdf..66c27e92a 100644 --- a/product/runtime/auths-gateway/src/recipe/review.rs +++ b/product/runtime/auths-gateway/src/recipe/review.rs @@ -1,4 +1,4 @@ -//! Operator review of a compiled recipe: `auths.gateway-recipe-review/2`. +//! Operator review of a compiled recipe: `auths.gateway-recipe-review/3`. //! //! The review keeps every field of `/1` and adds each declaration of //! recipe source `/2` with the disclosure that says what the gateway can and @@ -13,7 +13,7 @@ use super::{CompiledRecipe, CredentialRequirement, MAX_BODY_BYTES, WriteMethod, use serde_json::{Value, json}; /// The review schema both review commands print. -pub const RECIPE_REVIEW_SCHEMA: &str = "auths.gateway-recipe-review/2"; +pub const RECIPE_REVIEW_SCHEMA: &str = "auths.gateway-recipe-review/3"; /// The schema of the derived recovery capability. pub const RECOVERY_CAPABILITY_SCHEMA: &str = "auths.gateway-recovery-capability/1"; @@ -280,7 +280,7 @@ impl CompiledRecipe { } } - /// Renders `auths.gateway-recipe-review/2`, the document both + /// Renders `auths.gateway-recipe-review/3`, the document both /// `auths-gateway review` and `auths-node gateway recipe check` print. /// Optional declarations the recipe omits are `null`. #[must_use] @@ -289,6 +289,7 @@ impl CompiledRecipe { let source = &self.source; let mut document = json!({ "schema": RECIPE_REVIEW_SCHEMA, + "effect_review_contract": self.source.review, "digest": self.digest_hex(), "operator_namespace": self.namespace.as_str(), "service": review.service(), diff --git a/product/runtime/auths-gateway/src/recipe/source.rs b/product/runtime/auths-gateway/src/recipe/source.rs index b22304f85..c1789f725 100644 --- a/product/runtime/auths-gateway/src/recipe/source.rs +++ b/product/runtime/auths-gateway/src/recipe/source.rs @@ -1,4 +1,4 @@ -//! The typed AST of `auths.gateway-recipe-source/2`. +//! The typed AST of `auths.gateway-recipe-source/3`. //! //! Every struct refuses unknown members, and every optional member is omitted //! when absent, so re-serializing a parsed source under RFC 8785 gives the @@ -14,6 +14,7 @@ use std::collections::BTreeMap; #[serde(deny_unknown_fields)] pub(super) struct RecipeSource { pub(super) schema: String, + pub(super) review: super::effect_review::ReviewContract, pub(super) profile_schema_digest: String, pub(super) service: String, pub(super) tool: String, diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index 3a4e94df9..eb221bea0 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -622,7 +622,8 @@ fn form_body_renders_an_integer_field_as_decimal_text() { "service": "refunds", "tool": "create_refund_v1", "version": 1 }); let source = json!({ - "schema": "auths.gateway-recipe-source/2", "profile_schema_digest": digest, + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": digest, + "review": crate::recipe::synthetic_review(&schema["fields"]), "service": "refunds", "tool": "create_refund_v1", "operator_namespace": "refunds", "credential": {"kind": "bearer"}, "origin": "https://api.stripe.com", "write": {"method": "POST", @@ -1395,3 +1396,137 @@ proptest::proptest! { } } } + +#[test] +fn effect_review_contract_is_complete_typed_and_recipe_bound() { + let (airtable_recipe, airtable_lock) = fixture("airtable"); + let source: Value = serde_json::from_slice(airtable_recipe).expect("source"); + let original = compiled("airtable"); + let reject = |source: &Value| { + assert!( + CompiledRecipe::compile(&serde_json::to_vec(source).expect("source"), airtable_lock) + .is_err() + ); + }; + let mut changed = source.clone(); + changed["review"]["schema"] = json!("auths.effect-review-contract/999"); + reject(&changed); + let mut changed = source.clone(); + changed["review"]["fields"] + .as_object_mut() + .expect("fields") + .remove("replacement"); + reject(&changed); + let mut changed = source.clone(); + changed["review"]["fields"]["replacement"] = + json!({"kind": "integer", "label": "Replacement", "unit": "units"}); + reject(&changed); + let mut changed = source.clone(); + changed["review"]["fields"]["replacement"]["label"] = + json!("Destination\nhttps://misleading.invalid"); + reject(&changed); + let mut changed = source.clone(); + changed["review"]["consequences"] = json!([]); + reject(&changed); + let mut changed = source.clone(); + changed["review"]["fields"]["replacement"]["label"] = json!("New record status"); + let relabeled = CompiledRecipe::compile( + &serde_json::to_vec(&changed).expect("source"), + airtable_lock, + ) + .expect("reviewed label"); + assert_ne!( + original.digest(), + relabeled.digest(), + "review semantics change the approved recipe" + ); +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one native corpus emits its bounded rejection cases and positive seeds together" +)] +fn native_review_contract_fixture_is_current() { + let (source_bytes, lock) = fixture("airtable"); + let source: Value = serde_json::from_slice(source_bytes).expect("source"); + let mut cases = Vec::new(); + for (name, pointer, value) in [ + ( + "unsupported-version", + "/review/schema", + json!("auths.effect-review-contract/999"), + ), + ("missing-field", "/review/fields", json!({})), + ("missing-consequences", "/review/consequences", json!([])), + ( + "misleading-control", + "/review/fields/replacement/label", + json!("Status\nDestination: misleading"), + ), + ( + "wrong-type", + "/review/fields/replacement", + json!({"kind": "integer", "label": "Replacement", "unit": "count"}), + ), + ] { + let mut candidate = source.clone(); + *candidate.pointer_mut(pointer).expect("existing field") = value; + let bytes = serde_json::to_vec(&candidate).expect("case"); + let refusal = CompiledRecipe::compile(&bytes, lock).expect_err(name); + cases.push(json!({"name": name, "source_json": String::from_utf8(bytes).expect("JSON"), "code": refusal.code()})); + } + let review = &source["review"]; + let fields = serde_json::to_string(&review["fields"]).expect("fields"); + let duplicate = format!( + "{{\"replacement\":{},{}", + review["fields"]["replacement"], + &fields[1..] + ); + let review_bytes = serde_json::to_string(review).expect("review"); + let candidate = serde_json::to_string(&source) + .expect("source") + .replace(&review_bytes, &review_bytes.replace(&fields, &duplicate)); + let refusal = + CompiledRecipe::compile(candidate.as_bytes(), lock).expect_err("duplicate review field"); + cases + .push(json!({"name": "duplicate-field", "source_json": candidate, "code": refusal.code()})); + let corpus = serde_json::to_vec_pretty(&json!({ + "schema": "auths.effect-review-contract-fixture/1", + "profile_lock": serde_json::from_slice::(lock).expect("profile lock"), + "source_schema": RECIPE_SOURCE_SCHEMA, + "review_schema": RECIPE_REVIEW_SCHEMA, + "accepted": compiled("airtable").review_document(), + "rejected": cases, + })) + .expect("corpus"); + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); + let path = root.join("../../../bindings/fixtures/gateway/effect-review-contract.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &corpus).expect("write corpus"); + } + assert_eq!(std::fs::read(path).expect("corpus"), corpus); + for name in ["airtable", "todoist", "github", "stripe-refund-approval"] { + let (source, lock) = if name == "stripe-refund-approval" { + ( + &include_bytes!("../../../../../examples/stripe-refund-approval/recipe.json")[..], + &include_bytes!("../../../../../examples/stripe-refund-approval/profile.lock.json") + [..], + ) + } else { + fixture(name) + }; + CompiledRecipe::compile(source, lock).expect("positive recipe seed"); + let mut seed = u32::try_from(source.len()) + .expect("bounded source") + .to_be_bytes() + .to_vec(); + seed.extend_from_slice(source); + seed.extend_from_slice(lock); + let path = root.join("fuzz/corpus/target_gateway_recipe").join(name); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &seed).expect("seed"); + } + assert_eq!(std::fs::read(path).expect("seed"), seed); + } +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 87911e48c..3235261d3 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "a6feccfc4aa0f00add3598fc643ea58b5a607847c83650450b403316c9bac899"; + "4e1b8eea0e898fa24c0f0be3a459a360a3372d0a67c9ad20fc0dd3cc683aa8a0"; #[cfg(test)] mod tests { diff --git a/product/tools/auths-openapi-derive/src/lib.rs b/product/tools/auths-openapi-derive/src/lib.rs index 8055a56a4..be35f37a7 100644 --- a/product/tools/auths-openapi-derive/src/lib.rs +++ b/product/tools/auths-openapi-derive/src/lib.rs @@ -8,8 +8,8 @@ //! restricted profile schema or the gateway recipe compiler cannot express is //! rejected with a stable code, a JSON pointer, and the flag that would //! resolve it, if one exists. Nothing derived here is authority: the outputs -//! are reviewed source that the existing profile generator and recipe -//! compiler consume unchanged. +//! are source drafts. The operator must complete the review contract with +//! domain consequences and units before the native recipe compiler accepts them. mod diagnostic; mod document; @@ -62,7 +62,7 @@ impl Derived { &self.profile_toml } - /// Returns the gateway recipe source (`auths.gateway-recipe-source/2`). + /// Returns the gateway recipe source (`auths.gateway-recipe-source/3`). #[must_use] pub fn recipe_json(&self) -> &str { &self.recipe_json diff --git a/product/tools/auths-openapi-derive/src/render.rs b/product/tools/auths-openapi-derive/src/render.rs index 74f8caa51..691ba70dc 100644 --- a/product/tools/auths-openapi-derive/src/render.rs +++ b/product/tools/auths-openapi-derive/src/render.rs @@ -171,8 +171,27 @@ fn recipe_json(request: &Request, mapping: &Mapping, digest: &str, method: &str) json!({"kind": "form", "fields": Value::Object(map)}) } }; + // OpenAPI describes transport shapes, not reviewed units or consequences. + // Empty units/consequences deliberately fail the native review contract. + let review_fields = mapping + .arguments + .iter() + .map(|argument| { + let declaration = match &argument.schema { + ArgSchema::Integer { .. } => { + json!({"kind": "integer", "label": argument.name, "unit": ""}) + } + ArgSchema::Boolean => json!({"kind": "boolean", "label": argument.name}), + ArgSchema::String { .. } | ArgSchema::Enum(_) => { + json!({"kind": "text", "label": argument.name}) + } + }; + (argument.name.clone(), declaration) + }) + .collect::>(); let recipe = json!({ - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", + "review": {"schema": "auths.effect-review-contract/1", "consequences": [], "fields": review_fields}, "profile_schema_digest": digest, "service": request.service, "tool": format!("{}_v{}", mapping.tool, request.version), @@ -340,6 +359,7 @@ fn report(request: &Request, mapping: &Mapping, source: &Source<'_>) -> Vec Option<(Vec, String)> { .find(|entry| entry["vendor"] == vendor) .expect("vendor pinned in the published corpus"); let name = format!("{}.json", vendor.to_ascii_lowercase()); - let bytes = fs::read(Path::new(&directory).join(&name)).expect("vendor document"); + let path = Path::new(&directory).join(&name); + if updating() && !path.exists() { + eprintln!("artifact generation pending for {vendor}: pinned input unavailable"); + return None; + } + let bytes = fs::read(path).expect("vendor document"); assert_eq!( bytes.len() as u64, pinned["source"]["bytes"].as_u64().unwrap(), @@ -96,9 +102,27 @@ fn check_file(path: &Path, actual: &str) { assert_eq!(expected, actual, "{} differs", path.display()); } +/// Test-only semantic declarations, independent of the untrusted OpenAPI text. +/// They permit compiler/differential tests, not installed human-review claims. +fn complete_synthetic_review(recipe: &[u8]) -> Vec { + let mut value: Value = serde_json::from_slice(recipe).unwrap(); + value["review"]["consequences"] = + json!(["Synthetic transport comparison only; no production review claim."]); + for (_, field) in value["review"]["fields"].as_object_mut().unwrap() { + if field["kind"] == "integer" { + field["unit"] = json!("synthetic units"); + } + } + serde_json::to_vec(&value).unwrap() +} + fn review(recipe: &str, lock: &[u8]) -> Value { - let compiled = CompiledRecipe::compile(recipe.as_bytes(), lock) - .expect("derived recipe compiles under recipe check"); + assert!( + CompiledRecipe::compile(recipe.as_bytes(), lock).is_err(), + "incomplete review must fail closed" + ); + let compiled = CompiledRecipe::compile(&complete_synthetic_review(recipe.as_bytes()), lock) + .expect("explicit synthetic review permits native transport compilation"); let header = match compiled.review().credential() { auths_gateway::CredentialRequirement::Bearer => "Authorization".to_owned(), auths_gateway::CredentialRequirement::HeaderApiKey { header } => header.clone(), @@ -234,7 +258,7 @@ fn every_corpus_case_produces_its_exact_output() { "expected outputs without a case: {stale:?}" ); if !skipped.is_empty() { - eprintln!("vendor cases skipped without AUTHS_OPENAPI_CORPUS_DIR: {skipped:?}"); + eprintln!("vendor cases pending without pinned inputs: {skipped:?}"); } } @@ -307,7 +331,7 @@ fn derived_airtable_and_todoist_recipes_compare_with_the_hand_authored_fixtures( let hand = CompiledRecipe::compile(&hand_recipe, &hand_lock).unwrap(); let airtable = derived("airtable-set-demo-status").unwrap(); let ours = CompiledRecipe::compile( - airtable.recipe_json().as_bytes(), + &complete_synthetic_review(airtable.recipe_json().as_bytes()), &expected_lock("airtable-set-demo-status"), ) .unwrap(); @@ -335,7 +359,7 @@ fn derived_airtable_and_todoist_recipes_compare_with_the_hand_authored_fixtures( let hand = CompiledRecipe::compile(&hand_recipe, &hand_lock).unwrap(); let todoist = derived("todoist-rest-create-task").unwrap(); let ours = CompiledRecipe::compile( - todoist.recipe_json().as_bytes(), + &complete_synthetic_review(todoist.recipe_json().as_bytes()), &expected_lock("todoist-rest-create-task"), ) .unwrap(); @@ -371,7 +395,7 @@ fn derived_github_request_equals_the_hand_authored_request_up_to_profile_bounds( let (hand_recipe, hand_lock) = fixture("github"); let hand = CompiledRecipe::compile(&hand_recipe, &hand_lock).unwrap(); let ours = CompiledRecipe::compile( - github.recipe_json().as_bytes(), + &complete_synthetic_review(github.recipe_json().as_bytes()), &expected_lock("github-issues-create-fixed-repository"), ) .unwrap(); @@ -379,11 +403,12 @@ fn derived_github_request_equals_the_hand_authored_request_up_to_profile_bounds( // hand-authored profile requires a 1-byte title and caps operation IDs at // 64 bytes, so the digests differ. assert_ne!(ours.digest_hex(), hand.digest_hex()); - // With the hand-authored profile digest substituted, the derived request + // With the hand-authored profile digest and explicit review contract, the derived request // compiles to exactly the hand-authored recipe digest. let hand_source: Value = serde_json::from_slice(&hand_recipe).unwrap(); let mut substituted: Value = serde_json::from_str(github.recipe_json()).unwrap(); substituted["profile_schema_digest"] = hand_source["profile_schema_digest"].clone(); + substituted["review"] = hand_source["review"].clone(); let same = CompiledRecipe::compile(&serde_json::to_vec(&substituted).unwrap(), &hand_lock).unwrap(); assert_eq!(same.digest_hex(), hand.digest_hex()); diff --git a/qualification/reference/packet_plan.py b/qualification/reference/packet_plan.py index 6fe8f2b69..9cac1dc53 100644 --- a/qualification/reference/packet_plan.py +++ b/qualification/reference/packet_plan.py @@ -208,7 +208,7 @@ def prepare(args): write_bytes(args.work / 'profile.lock.json', lock, new=True) review = child(args.gateway, ['review', '--recipe', args.work / 'recipe.json', '--profile-lock', args.work / 'profile.lock.json']) - require(review.get('schema') == 'auths.gateway-recipe-review/2', 'qualification.packets.native-review') + require(review.get('schema') == 'auths.gateway-recipe-review/3', 'qualification.packets.native-review') extension = None if reference is stripe_platform: extension = {} diff --git a/qualification/simulation/live/stripe-platform/recipe.json b/qualification/simulation/live/stripe-platform/recipe.json index 9f9f90ce1..ba4893b10 100644 --- a/qualification/simulation/live/stripe-platform/recipe.json +++ b/qualification/simulation/live/stripe-platform/recipe.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-recipe-source/2", + "schema": "auths.gateway-recipe-source/3", "profile_schema_digest": "d2f5b926a3b6989d13b3a4614372e298442de697d92d5e06330288f7de4e257a", "service": "stripe-platform-refunds", "tool": "create_refund_v1", @@ -167,5 +167,27 @@ "name": "metadata[auths_echo]" }, "observe": "/metadata/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.", + "The provider determines refund settlement timing. A response or receipt does not itself establish settlement." + ], + "fields": { + "amount": { + "kind": "integer", + "label": "Amount", + "unit": "minor units of the declared currency" + }, + "currency": { + "kind": "identifier", + "label": "Currency" + }, + "payment_intent": { + "kind": "identifier", + "label": "Payment intent" + } + } } } From eb3c31fb86a79ae16f02bf15c94453da6f7f99be Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 05:08:58 +0000 Subject: [PATCH 021/136] feat(gateway)!: return journal state without replay I/O --- .../gateway/attempt-scenarios-v3.json | 9 +- bindings/fixtures/gateway/codes.json | 8 - .../fixtures/gateway/custody-hostile.json | 6 +- .../fixtures/gateway/production-codes.json | 13 +- .../fixtures/gateway/replay-projection.json | 104 ++++++ .../lib/selftest.py.tmpl | 2 +- bindings/python/python/auths/gateway.py | 22 +- bindings/python/tests/test_gateway_client.py | 22 ++ bindings/typescript/src/gateway.ts | 11 +- .../test/unit/gateway-client.test.js | 16 +- compliance.toml | 7 +- ...017-bound-effect-and-recovery-ownership.md | 20 ++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 17 +- docs/plans/0074-implementation-status.md | 37 +- .../0009-bound-effect-and-recovery.md | 17 + ...ound-effects-and-recovery-state-machine.md | 8 + examples/stripe-refund-approval/README.md | 2 +- examples/stripe-refund-approval/journey.py | 2 +- .../typescript/journey.ts | 2 +- .../src/execution.rs | 31 +- .../tests/execution.rs | 15 +- .../runtime/auths-gateway-kernel/src/order.rs | 43 ++- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/audit.rs | 3 +- .../runtime/auths-gateway/src/bounds_tests.rs | 2 + product/runtime/auths-gateway/src/engine.rs | 33 +- .../auths-gateway/src/observed_tests.rs | 17 +- .../src/pending_vectors/attempts.rs | 24 +- .../src/pending_vectors/codes.rs | 1 - .../src/pending_vectors/production.rs | 8 +- .../src/qualification_simulation.rs | 45 ++- .../auths-gateway/src/scenario_tests.rs | 319 ++++++++++++++---- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 74 ++-- product/runtime/auths-gateway/src/submit.rs | 57 ++-- qualification/reference/family_corpus.py | 19 +- qualification/reference/native_observation.py | 7 +- qualification/simulation/live/airtable.py | 6 +- qualification/simulation/live/stripe.py | 4 +- 39 files changed, 734 insertions(+), 303 deletions(-) create mode 100644 bindings/fixtures/gateway/replay-projection.json diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 37f5cebbc..d91b1c308 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -778,7 +778,7 @@ "provider_entries": 1 }, { - "id": "linked-attempting-reobserved", + "id": "linked-grant-replay-retains-unknown", "recipe": "airtable", "setup": { "crash": "after-write-before-response", @@ -786,14 +786,13 @@ }, "stages": [ "reserved", - "entry-granted", - "observed-by-provider" + "entry-granted" ], "code": null, - "leases": 2, + "leases": 1, "credential_reads": 0, "action_reads": 1, - "provider_entries": 1 + "provider_entries": 0 } ], "record_cases": [ diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 9a49e225f..98cb9ab50 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -408,14 +408,6 @@ "id": "argument-above-smallest-sum-limit" } }, - { - "code": "gateway.policy.count-unavailable", - "owner": "ReserveRefusal", - "stage": "before-claim", - "status": "changed", - "epic": 4, - "case": null - }, { "code": "gateway.policy.evaluator-mismatch", "owner": "engine", diff --git a/bindings/fixtures/gateway/custody-hostile.json b/bindings/fixtures/gateway/custody-hostile.json index 36a14c18e..5255f9f06 100644 --- a/bindings/fixtures/gateway/custody-hostile.json +++ b/bindings/fixtures/gateway/custody-hostile.json @@ -809,11 +809,11 @@ "id": "lease-never-precedes-claim", "class": "selection", "given": [ - "the logical operation was already claimed" + "the logical operation has an entry grant and no recorded response" ], "expect": { - "stage": "not-entered", - "code": "gateway.attempt.replay", + "stage": "unknown", + "code": null, "leases": 0, "provider_entries": 0 } diff --git a/bindings/fixtures/gateway/production-codes.json b/bindings/fixtures/gateway/production-codes.json index 2933726c8..732e12242 100644 --- a/bindings/fixtures/gateway/production-codes.json +++ b/bindings/fixtures/gateway/production-codes.json @@ -10,15 +10,12 @@ "case": null }, { - "code": "gateway.attempt.replay", + "code": "gateway.attempt.state-unavailable", "owner": "engine", - "stage": "recorded", - "status": "existing", - "epic": null, - "case": { - "fixture": "custody-hostile.json", - "id": "lease-never-precedes-claim" - } + "stage": "journal", + "status": "implemented", + "epic": 5, + "case": null }, { "code": "gateway.commissioning.binding-mismatch", diff --git a/bindings/fixtures/gateway/replay-projection.json b/bindings/fixtures/gateway/replay-projection.json new file mode 100644 index 000000000..d6595a7de --- /dev/null +++ b/bindings/fixtures/gateway/replay-projection.json @@ -0,0 +1,104 @@ +{ + "schema": "auths.gateway-replay-projection-fixture/1", + "scope": "native synthetic driver and file journal; no installed authority or independent recovery claim", + "unknown_replay": { + "result": { + "outcome": "unknown" + }, + "additional_leases": 0, + "additional_reads": 0, + "additional_writes": 0, + "journal_unchanged": true + }, + "unacknowledged_grants": [ + { + "ambiguous_ack": false, + "state_unavailable": false, + "result": { + "outcome": "reserved", + "revision": 1 + }, + "provider_writes": 0, + "provider_reads": 0 + }, + { + "ambiguous_ack": true, + "state_unavailable": false, + "result": { + "outcome": "unknown" + }, + "provider_writes": 0, + "provider_reads": 0 + }, + { + "ambiguous_ack": true, + "state_unavailable": true, + "result": { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + "provider_writes": 0, + "provider_reads": 0 + } + ], + "concurrent_replays": { + "results": [ + { + "outcome": "unknown" + }, + { + "outcome": "unknown" + } + ], + "additional_leases": 0, + "additional_reads": 0, + "additional_writes": 0, + "journal_unchanged": true + }, + "reserved_decoding": { + "valid": [ + { + "outcome": "reserved", + "revision": 1 + }, + { + "outcome": "reserved", + "revision": 9007199254740991 + } + ], + "invalid": [ + { + "outcome": "reserved" + }, + { + "outcome": "reserved", + "revision": 0 + }, + { + "outcome": "reserved", + "revision": -1 + }, + { + "outcome": "reserved", + "revision": 9007199254740992 + }, + { + "outcome": "reserved", + "revision": true + }, + { + "outcome": "reserved", + "revision": "1" + }, + { + "outcome": "reserved", + "revision": 1.5 + }, + { + "outcome": "reserved", + "revision": 1, + "may_send": true + } + ] + } +} \ No newline at end of file diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl index e61347eb3..5d622784d 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl @@ -100,7 +100,7 @@ BEFORE_LEASE = { "refund-other-account": ("not-entered", "gateway.policy.scope-denied"), "refund-over-sum": ("not-entered", "gateway.policy.sum-exhausted"), "refund-5-window": ("not-entered", "gateway.policy.window-exhausted"), - "refund-1-replay": ("not-entered", "gateway.attempt.replay"), + "refund-1-replay": ("not-entered", "gateway.effect.operation-conflict"), "refund-8-reuse": ("denied", "action-body-mismatch"), "refund-2-retry": ("not-entered", "gateway.policy.window-exhausted"), } diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index 1424b8197..e84e21802 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -88,7 +88,7 @@ class GatewayDenied: @dataclass(frozen=True) class GatewayIndeterminate: - """Native proof verification could not authorize the action.""" + """Native verification or required durable state is indeterminate.""" code: str outcome: Literal["indeterminate"] = "indeterminate" @@ -102,6 +102,14 @@ class GatewayNotEntered: outcome: Literal["not-entered"] = "not-entered" +@dataclass(frozen=True) +class GatewayReserved: + """Reserved without an entry grant; continuation requires fresh authorization.""" + + revision: int + outcome: Literal["reserved"] = "reserved" + + @dataclass(frozen=True) class GatewayUnknown: """Provider entry or effect is ambiguous; do not automatically retry.""" @@ -160,6 +168,7 @@ class GatewayObservedByProvider: GatewayDenied, GatewayIndeterminate, GatewayNotEntered, + GatewayReserved, GatewayUnknown, GatewayResponseRecorded, GatewayObserved, @@ -218,6 +227,16 @@ def _parse_result(raw: bytes) -> GatewayResult: if outcome == "indeterminate": return GatewayIndeterminate(code) return GatewayNotEntered(code) + if outcome == "reserved": + revision = value.get("revision") + if ( + set(value) != {"outcome", "revision"} + or not isinstance(revision, int) + or isinstance(revision, bool) + or not 1 <= revision <= 9_007_199_254_740_991 + ): + raise GatewayProtocolError("gateway returned invalid reservation") + return GatewayReserved(revision) if outcome == "unknown" and set(value) == {"outcome"}: return GatewayUnknown() if outcome == "observed-by-provider": @@ -579,6 +598,7 @@ async def _exchange(self, payload: bytes, failure: str) -> bytes: "GatewayPreEntryResult", "GatewayProtocolError", "GatewayProviderEvidence", + "GatewayReserved", "GatewayResponseRecorded", "GatewayResult", "GatewaySignedObservation", diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index a1109ec7f..33d6e1673 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -29,6 +29,8 @@ GatewayProviderEvidence, GatewaySignedObservation, GatewayUnknown, + GatewayReserved, + GatewayIndeterminate, ) _ECHO = "auths-e1-" + "ab" * 32 @@ -424,3 +426,23 @@ def test_connect_failure_names_the_path_and_cause(socket_dir: Path) -> None: assert "outcome may be unknown" in text assert str(missing) in text assert os.strerror(errno.ENOENT) in text + + +def test_native_replay_projection_corpus() -> None: + from auths.gateway import _parse_result + + corpus = json.loads( + (Path(__file__).resolve().parents[2] / "fixtures/gateway/replay-projection.json").read_text() + ) + assert corpus["schema"] == "auths.gateway-replay-projection-fixture/1" + assert _parse_result(json.dumps(corpus["unknown_replay"]["result"]).encode()) == GatewayUnknown() + expected = [GatewayReserved(1), GatewayUnknown(), + GatewayIndeterminate("gateway.attempt.state-unavailable")] + assert len(corpus["unacknowledged_grants"]) == len(expected) + for case, result in zip(corpus["unacknowledged_grants"], expected): + assert _parse_result(json.dumps(case["result"]).encode()) == result + for value in corpus["reserved_decoding"]["valid"]: + assert _parse_result(json.dumps(value).encode()) == GatewayReserved(value["revision"]) + for value in corpus["reserved_decoding"]["invalid"]: + with pytest.raises(GatewayProtocolError): + _parse_result(json.dumps(value).encode()) diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index 1d0403dd5..de066d8f7 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -80,7 +80,9 @@ export type GatewayProviderEvidence = Readonly<{ }>; /** - * Proof decision and transport/observation stages, without effect qualification. + * Native decision and journal stages, without effect qualification. `reserved` + * has no entry grant; continuation needs fresh authorization. `indeterminate` + * can mean required journal state is unavailable, not that entry was absent. * `observed-by-provider` means a read-back returned this attempt's echo token and the * verified value; anyone who knows the namespace, operation ID, and action commitment * can compute that token, so the link holds only while no other writer of that @@ -90,6 +92,7 @@ export type GatewayResult = | Readonly<{ outcome: "denied"; code: string }> | Readonly<{ outcome: "indeterminate"; code: string }> | Readonly<{ outcome: "not-entered"; code: string }> + | Readonly<{ outcome: "reserved"; revision: number }> | Readonly<{ outcome: "unknown" }> | Readonly<{ outcome: "response-recorded"; status: number }> | Readonly<{ outcome: "observed"; status: number; matched: boolean }> @@ -225,6 +228,12 @@ function parseResult(bytes: Uint8Array): GatewayResult { } return { outcome, code: value.code }; } + if (outcome === "reserved") { + if (!exactKeys(value, ["outcome", "revision"]) || typeof value.revision !== "number" || !Number.isSafeInteger(value.revision) || value.revision < 1) { + throw new GatewayProtocolError("gateway returned invalid reservation"); + } + return { outcome, revision: value.revision }; + } if (outcome === "unknown" && exactKeys(value, ["outcome"])) { return { outcome }; } diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index ae9746dd1..869740253 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -1,12 +1,12 @@ import assert from "node:assert/strict"; -import { mkdtemp, rm } from "node:fs/promises"; +import { mkdtemp, readFile, rm } from "node:fs/promises"; import { createServer } from "node:net"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { test } from "node:test"; import { GatewayClient, GatewayEndpoint, GatewayProtocolError } from "../../dist/gateway.js"; -test("gateway client submits proof/action only and separates observed from effect", { skip: process.platform === "win32" }, async () => { +test("gateway client submits proof/action/exact approval and separates observed from effect", { skip: process.platform === "win32" }, async () => { const directory = await mkdtemp(join(tmpdir(), "auths-gateway-")); const path = join(directory, "app.sock"); const seen = []; @@ -313,3 +313,15 @@ test("operator gate refusals remain not-entered with the native code", { skip: p assert.deepEqual(await replyOnce(JSON.stringify({ outcome: "not-entered", code })), { outcome: "not-entered", code }); } }); + + +test("gateway decodes the native replay and reservation corpus", { skip: process.platform === "win32" }, async () => { + const corpus = JSON.parse(await readFile(new URL("../../../fixtures/gateway/replay-projection.json", import.meta.url), "utf8")); + assert.equal(corpus.schema, "auths.gateway-replay-projection-fixture/1"); + for (const result of [corpus.unknown_replay.result, ...corpus.unacknowledged_grants.map((item) => item.result), ...corpus.reserved_decoding.valid]) { + assert.deepEqual(await replyOnce(JSON.stringify(result)), result); + } + for (const invalid of corpus.reserved_decoding.invalid) { + await assert.rejects(replyOnce(JSON.stringify(invalid)), GatewayProtocolError); + } +}); diff --git a/compliance.toml b/compliance.toml index 61be59a3f..bd56c8488 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-review/1", "auths.private-effect-signing/1", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,11 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +effect-replay = [ + "product/runtime/auths-gateway/src/scenario_tests.rs#native_replay_projection_fixture_is_current", + "bindings/python/tests/test_gateway_client.py#test_native_replay_projection_corpus", + "bindings/typescript/test/unit/gateway-client.test.js", +] effect-review = [ "product/runtime/auths-gateway/src/recipe/tests.rs#native_review_contract_fixture_is_current", "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index a3f2b8ce2..20b726b66 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -303,3 +303,23 @@ silently approving business meaning from untrusted descriptions. The full Todoist vendor input currently fails the pinned digest; equivalent frozen native excerpt outputs update the render artifacts while full vendor execution remains explicitly pending. No source pin or verification rule was weakened. + + +## Public replay and unacknowledged grants + +The mutation submission driver returns stored facts for equal bindings that +already have a grant or terminal result. Replay stops before a credential lease +and cannot invoke the operator observation path. An equal pre-grant reservation +may continue only through the separate fresh authorization and grant checks. + +The native result represents that reservation explicitly with its bounded +revision. If admission or grant acknowledgement is unavailable, reload the exact +bound journal: reserved remains reserved; a retained grant without conclusive +response remains unknown; missing/corrupt/unavailable state is indeterminate. +These reads cannot return a permit or infer non-entry. Historical observation +returned on replay must not be counted as a new read-back confirmation. + +The old explicit operator observation mechanics remain temporarily reachable +only on the operator surface. They are not the final AP074 recovery contract: +that direct path, automatic post-write observations and all ancillary reads must +be replaced by independently authorized bounded acquisitions before completion. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index b2b2a3194..07d5cac92 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -134,16 +134,23 @@ held which key, is operator evidence and is not produced by this code. `AUTHS_POSTGRES_URL`, `AUTHS_POSTGRES_CA_PEM`, and `AUTHS_POSTGRES_SERVER_NAME`. Connections are TLS-only with certificate and server-name verification. The schema is - `auths.lifecycle.postgresql/6`; it installs only into an empty database. - A database created at schema 4 or earlier is disposable prelaunch state: + `auths.lifecycle.postgresql/7`; it installs only into an empty database. + A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/3`; a store holding `/2` records is refused as + `auths.gateway-attempt/6`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. - **Several gateway processes** may serve from the same database. Each logical operation is claimed once, by an insert-once row; stage changes are compare-and-swap on the exact stored record. A second process that loses a - race records nothing and answers `gateway.attempt.replay`. Gateway claims - do not take the lifecycle store's singleton contract-row lock. + grant race records nothing and loads the matching journal state. An equal + binding with a prior grant or terminal outcome returns history without a + credential lease or provider read. A reserved operation can progress only + through fresh authorization and the fenced single-winner grant. Changed + bindings return `gateway.effect.operation-conflict`. An unavailable journal + reports `gateway.attempt.state-unavailable`, never proof of non-entry. + PostgreSQL writers share the table-scoped advisory transaction fence; + file writers share the bounded writer lock. The lifecycle store's singleton + contract-row lock is not the gateway's fence. - **Spend limits.** A grant's bounded policy (evaluator `auths.gateway.argument-ceiling-window-count/2`) counts per link subject in fixed, epoch-aligned windows, in the attempt store: every gateway process diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 39cc72480..44f5acc61 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -117,9 +117,9 @@ The checkpoint sections below are historical records; the phase and acceptance ledgers at the end describe current closure. Do not treat earlier "pending" notes as a reason to reimplement a later completed source cutover. -1. Finish truthful public reservation/recovery projections and independently - authorized bounded observation. `Reserved` is not provider uncertainty, and - replay must not implicitly authorize provider reads. Preserve immutable +1. Finish independently authorized bounded observation and full native recovery + actions/charge/evidence projections. Public `Reserved` and zero-provider-I/O + application replay are now implemented. Preserve immutable admission/grant history and the one-use transport boundary already wired. 2. Complete typed acquisition, separate recipient disclosure and exact ACK in the existing native owners. Bind and account for all credential-bearing @@ -344,6 +344,37 @@ closure regeneration passed after that correction (one artifact-generation test) cross-language/installed evidence. P2–P4 remain open and no complete A01–A22 acceptance claim follows from this checkpoint. +## Replay projection checkpoint + +- Application replay of a granted or terminal effect now reads only its full + matching native binding and returns the retained journal outcome. It never + enters the credential/observation path. A reserved effect remains resumable + only through fresh approval/authority and the single-winner grant already + implemented. Changed bindings remain explicit conflicts. +- The public native result adds `reserved` and its bounded journal revision. + An unacknowledged grant reloads the journal: pre-grant state is reserved, + committed grant state is unknown, and unavailable/corrupt state is + indeterminate (`gateway.attempt.state-unavailable`). None returns a permit. + Python and TypeScript decode the native variant; they do not decide recovery. +- Native `replay-projection.json` artifact construction passed on `ed907973` + plus this source using `scenario_tests::native_replay_projection_fixture_is_current`. + It drives the real file store and submission driver with a synthetic command + oracle, concurrent reopened-store replay, pre-commit failure, post-commit lost + acknowledgement and unavailable reread. Counts show zero replay custody/read/ + write calls and no journal change. It also constructs native valid/invalid + reservation decoding cases consumed by authored binding tests. +- Qualification execution forbids replay leases and new confirmation credit. + Maintained family corpora, live harness expectations and examples now distinguish + historical outcomes from binding conflicts. Retained operator observation tests + explicitly invoke that path rather than using replay. That existing operator + path, automatic post-write reads and other ancillary reads still need independent + bounded native acquisition authority/accounting; this checkpoint does not close + A11/A15, installed bindings, full adapter faults or the authenticated journey. +- Attempt-scenario, stable-code, custody and final semantic-closure corpus + construction also passed via their exact native artifact generators. Binding tests, broad conformance, + translated formal artifacts and hosted CI are not yet executed. No AP073 work + or delegation occurred. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 103ddbe66..cdfc6bcd4 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -161,3 +161,20 @@ corpora cover missing/type/version/label/duplicate cases and hostile text. Installed reviewer authentication, frontend parity and domain qualification remain separate gates; the OpenAPI mapper deliberately emits an unusable draft until its review facts are supplied. + + +### Replay projection evidence checkpoint + +Both mutation families now return granted/terminal history without replay I/O. +The pure order predicate stops on replay; the runtime compares the full native +binding before projecting journal state. A new `reserved` result retains the +pre-grant distinction and bounded revision. Ambiguous acknowledgement never +constructs a permit, including when a successful reread finds a committed grant. + +`bindings/fixtures/gateway/replay-projection.json` is generated by the native +submission driver and real file adapter with synthetic verified commands. It +covers concurrent reopened-store replay, no-commit/committed-ack-loss and failed +reread, exact external counters and malformed reservation projections. It is +narrow mechanism evidence; installed authority and PostgreSQL fault evidence +remain open. Existing explicit operator observation tests retain their original +scope and are not evidence of independent AP074 recovery authorization. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 0165eb62a..ee7cfa248 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -287,6 +287,14 @@ For this milestone, provider-entry and disclosure-entry permits are one-use, and - An ambiguous commit requires loading the authoritative journal before doing anything else. Unavailable state fails closed. - A durable reservation with no entry grant may progress only through fresh authorization and an atomic single-winner grant; reopening it does not bypass approval or capacity checks. - Once an entry grant exists, restart must not reissue it, including when no response or ACK exists. +- The native submission projection names a retained pre-grant reservation as + `reserved` with its exact JSON-safe journal revision. After an unacknowledged + grant, loading that state does not issue a capability. A retained grant with + no conclusive evidence projects `unknown`; unavailable or mismatched journal + state projects `indeterminate` with `gateway.attempt.state-unavailable`. + Identical admitted/terminal replay returns stored facts with no credential + lease, provider read or new observation credit. Reservation continuation is + the separate fresh-authorization rule above. - Provider idempotency may improve provider guarantees but does not override the default prohibition on Auths re-entry. Any future retry mode requires an explicit versioned protocol and evidence for key scope, retention, fencing and late requests. - Late valid response/ACK evidence can refine an unknown outcome. Revocation or expiry must not erase legitimate history or prevent recording a previously authorized delivery's exact ACK. Recording history confers no current execution authority. - Read-only recovery requires its own bounded authority and accounting. It cannot borrow a revoked writer's proof, use an expired approval as current authority, acquire broader credentials or change the original actor attribution. diff --git a/examples/stripe-refund-approval/README.md b/examples/stripe-refund-approval/README.md index f2be31022..7b2da4dd8 100644 --- a/examples/stripe-refund-approval/README.md +++ b/examples/stripe-refund-approval/README.md @@ -226,7 +226,7 @@ gateway code. | `--connect-account acct_1AuthsOtherAcct`, which the grant does not list | gateway | `not-entered` `gateway.policy.scope-denied` | 0 | | 50.00 when 45.00 of the day's 60.00 USD is left | gateway | `not-entered` `gateway.policy.sum-exhausted` | 0 | | A third refund on the same UTC day | gateway | `not-entered` `gateway.policy.window-exhausted` | 0 | -| `refund-1` requested again, with fresh approvals | gateway | `not-entered` `gateway.attempt.replay` | 0 | +| `refund-1` requested again, with fresh approvals | gateway | `not-entered` `gateway.effect.operation-conflict` | 0 | | `refund-1`'s proof sent for another refund | gateway | `denied` `action-body-mismatch` | 0 | | The first lowered-threshold refund requested again at the installed threshold, after the window is full | gateway | `not-entered` `gateway.policy.window-exhausted`: a verification denial claims nothing, so this is not a replay | 0 | | Managers B and C run `auths approve … --decline` | managers B and C | `not-submitted` (`approvers-declined`): manager A's approval alone cannot make a quorum, so nothing is sent | 0 | diff --git a/examples/stripe-refund-approval/journey.py b/examples/stripe-refund-approval/journey.py index d1a21c340..725acb271 100644 --- a/examples/stripe-refund-approval/journey.py +++ b/examples/stripe-refund-approval/journey.py @@ -843,7 +843,7 @@ def self_approval() -> Dict[str, Any]: "refund-other-account": ("not-entered", "gateway.policy.scope-denied"), "refund-over-sum": ("not-entered", "gateway.policy.sum-exhausted"), "refund-5-window": ("not-entered", "gateway.policy.window-exhausted"), - "refund-1-replay": ("not-entered", "gateway.attempt.replay"), + "refund-1-replay": ("not-entered", "gateway.effect.operation-conflict"), "refund-8-reuse": ("denied", "action-body-mismatch"), "refund-2-retry": ("not-entered", "gateway.policy.window-exhausted"), } diff --git a/examples/stripe-refund-approval/typescript/journey.ts b/examples/stripe-refund-approval/typescript/journey.ts index 48c1682ce..35fc4117a 100644 --- a/examples/stripe-refund-approval/typescript/journey.ts +++ b/examples/stripe-refund-approval/typescript/journey.ts @@ -675,7 +675,7 @@ async function main(): Promise { "refund-other-account": ["not-entered", "gateway.policy.scope-denied"], "refund-over-sum": ["not-entered", "gateway.policy.sum-exhausted"], "refund-5-window": ["not-entered", "gateway.policy.window-exhausted"], - "refund-1-replay": ["not-entered", "gateway.attempt.replay"], + "refund-1-replay": ["not-entered", "gateway.effect.operation-conflict"], "refund-8-reuse": ["denied", "action-body-mismatch"], "refund-2-retry": ["not-entered", "gateway.policy.window-exhausted"], }; diff --git a/product/qualification/auths-recipe-qualification-issuance/src/execution.rs b/product/qualification/auths-recipe-qualification-issuance/src/execution.rs index 1dc21ff9b..01ca64cfc 100644 --- a/product/qualification/auths-recipe-qualification-issuance/src/execution.rs +++ b/product/qualification/auths-recipe-qualification-issuance/src/execution.rs @@ -467,30 +467,15 @@ impl RunCase { { return Err(IssuanceError::CaseFailed); } - let mut unresolved = false; for (step, actual) in self.steps.iter().zip(observations) { - if step.operation == Operation::Replay { - let read_only_completion = unresolved - && actual.credential_leases <= 1 - && matches!( - actual.verdict.outcome, - RunOutcome::Unknown | RunOutcome::ResponseRecorded | RunOutcome::Observed - ); - if actual.provider_entries != 0 - || (actual.credential_leases != 0 && !read_only_completion) - { - return Err(IssuanceError::CaseFailed); - } - } - if step.operation != Operation::Oracle { - if actual.provider_entries > 0 { - unresolved = matches!( - actual.verdict.outcome, - RunOutcome::Unknown | RunOutcome::ResponseRecorded - ); - } else if actual.verdict.outcome == RunOutcome::Observed { - unresolved = false; - } + // Replay may return historical evidence, but cannot count it as a + // new observation or authorize another credential lease or entry. + if step.operation == Operation::Replay + && (actual.provider_entries != 0 + || actual.credential_leases != 0 + || actual.confirmed_by_read_back != 0) + { + return Err(IssuanceError::CaseFailed); } } if matches!( diff --git a/product/qualification/auths-recipe-qualification-issuance/tests/execution.rs b/product/qualification/auths-recipe-qualification-issuance/tests/execution.rs index 19c134b45..d48c135ae 100644 --- a/product/qualification/auths-recipe-qualification-issuance/tests/execution.rs +++ b/product/qualification/auths-recipe-qualification-issuance/tests/execution.rs @@ -136,7 +136,7 @@ fn commissioning_client_refusal_cannot_replace_an_ordinary_installed_effect() { } #[test] -fn replay_can_complete_an_unresolved_read_back_but_never_write_or_reacquire_after_observation() { +fn replay_returns_history_without_a_lease_entry_or_new_confirmation() { use auths_recipe_qualification::BoundedText; let mut case = executable_corpus() .cases @@ -144,26 +144,21 @@ fn replay_can_complete_an_unresolved_read_back_but_never_write_or_reacquire_afte .find(|case| case.scenario == Scenario::AmbiguousResponse) .expect("ambiguous response"); let replay = &mut case.steps[1].expected; - replay.credential_leases = 1; + replay.credential_leases = 0; replay.verdict.outcome = RunOutcome::Unknown; replay.verdict.code = BoundedText::parse("unknown").expect("code"); assert!(run(&case, |_, _| {}).is_ok()); let replay = &mut case.steps[1].expected; replay.verdict.outcome = RunOutcome::Observed; replay.verdict.evidence_sha256 = Some(tuple().profile_lock_sha256); - replay.confirmed_by_read_back = 1; + replay.confirmed_by_read_back = 0; assert!(run(&case, |_, _| {}).is_ok()); for mutation in 0..3 { let mut changed = case.clone(); match mutation { 0 => changed.steps[1].expected.provider_entries = 1, - 1 => changed.steps[1].expected.credential_leases = 2, - _ => { - changed.steps[0].expected.verdict.outcome = RunOutcome::Observed; - changed.steps[0].expected.verdict.evidence_sha256 = - Some(tuple().profile_lock_sha256); - changed.steps[0].expected.confirmed_by_read_back = 1; - } + 1 => changed.steps[1].expected.credential_leases = 1, + _ => changed.steps[1].expected.confirmed_by_read_back = 1, } assert_eq!(run(&changed, |_, _| {}), Err(IssuanceError::CaseFailed)); } diff --git a/product/runtime/auths-gateway-kernel/src/order.rs b/product/runtime/auths-gateway-kernel/src/order.rs index a1a5e77b0..38d77a0bb 100644 --- a/product/runtime/auths-gateway-kernel/src/order.rs +++ b/product/runtime/auths-gateway-kernel/src/order.rs @@ -37,7 +37,7 @@ pub enum Mode { Entry, /// The lease for the read-back after a recorded response. ReadBack, - /// The lease for a replay's read-only re-observation. + /// The lease for an explicit operator re-observation. Reobserve, } @@ -80,7 +80,7 @@ pub enum Phase { Prepare, /// Awaiting the claim. Claim, - /// Awaiting whether a replayed attempt can be re-observed. + /// Awaiting an explicit operator re-observation start. Resume, /// Awaiting the connection reload before a lease. Reload(Mode), @@ -241,7 +241,7 @@ pub enum SubmitEvent { Preparation(bool), /// The claim result. Claim(ClaimResult), - /// The replayed attempt can be re-observed. + /// An explicit operator attempt can be re-observed. Resume(bool), /// The connection record is unchanged. Reload(bool), @@ -307,7 +307,7 @@ pub enum Refusal { pub enum Stop { /// Refused before the claim; nothing was stored. Refused, - /// The claim could not be stored; nothing was stored. + /// The claim was not acknowledged; durable state may be unavailable. StoreUnavailable, /// The claim step recorded `not-entered`. ClaimRefused, @@ -319,8 +319,12 @@ pub enum Stop { Response, /// A read-back recorded its transition. Observed, - /// A replay recorded nothing. - ReplayRefused, + /// An identical replay returned only the matching journal state. + Stored, + /// A grant was not acknowledged; only a fresh journal read can report state. + GrantUnavailable, + /// An explicit operator re-observation recorded nothing. + ReobservationUnrecorded, /// An event the phase does not expect. Halted, } @@ -340,8 +344,6 @@ pub enum SubmitAction { Prepare, /// Claim the logical operation. Claim, - /// Load the replayed attempt and decide whether it can be re-observed. - Resume, /// Reload the connection record before a lease. Reload(Mode), /// Lease the credential. @@ -439,7 +441,7 @@ pub const fn lease_failed(state: SubmitState, mode: Mode, refusal: Refusal) -> S match mode { Mode::Entry => not_entered(state, refusal), Mode::ReadBack => stop(state, Stop::Response), - Mode::Reobserve => stop(state, Stop::ReplayRefused), + Mode::Reobserve => stop(state, Stop::ReobservationUnrecorded), } } @@ -541,7 +543,7 @@ pub const fn after_claim(state: SubmitState, result: ClaimResult) -> SubmitDecis SubmitAction::Reload(Mode::Entry), ), ClaimResult::Refused => stop(state, Stop::ClaimRefused), - ClaimResult::Replay => go(state, Phase::Resume, SubmitAction::Resume), + ClaimResult::Replay => stop(state, Stop::Stored), ClaimResult::Unavailable => stop(state, Stop::StoreUnavailable), } } @@ -646,7 +648,7 @@ pub const fn after_read_back(state: SubmitState, mode: Mode, recorded: bool) -> match mode { Mode::Entry => halt(state), Mode::ReadBack => stop(state, Stop::Response), - Mode::Reobserve => stop(state, Stop::ReplayRefused), + Mode::Reobserve => stop(state, Stop::ReobservationUnrecorded), } } } @@ -722,7 +724,7 @@ pub const fn lease_step(state: SubmitState, event: SubmitEvent) -> SubmitDecisio SubmitAction::Reload(Mode::Reobserve), ) } else { - stop(state, Stop::ReplayRefused) + stop(state, Stop::ReobservationUnrecorded) } } _ => halt(state), @@ -815,7 +817,7 @@ pub const fn entry_step(state: SubmitState, event: SubmitEvent) -> SubmitDecisio }, Phase::Grant => match event { SubmitEvent::Granted(true) => go(state, Phase::Send, SubmitAction::Send), - SubmitEvent::Granted(false) => stop(state, Stop::Unknown), + SubmitEvent::Granted(false) => stop(state, Stop::GrantUnavailable), _ => halt(state), }, Phase::Send => match event { @@ -1032,18 +1034,15 @@ mod tests { SubmitEvent::Admission(true), SubmitEvent::Preparation(true), SubmitEvent::Claim(ClaimResult::Replay), - SubmitEvent::Resume(true), - SubmitEvent::Reload(true), - SubmitEvent::Lease(true), - SubmitEvent::Prefix(true), - SubmitEvent::Account(AccountResult::Mismatch), ]; let actions = run(STRIPE, &replay); assert!(!actions.contains(&SubmitAction::Send)); - assert_eq!( - actions.last(), - Some(&SubmitAction::Stop(Stop::ReplayRefused)) + assert!( + !actions + .iter() + .any(|action| matches!(action, SubmitAction::Lease(_) | SubmitAction::ReadBack(_))) ); + assert_eq!(actions.last(), Some(&SubmitAction::Stop(Stop::Stored))); let refused = run( STRIPE, &[ @@ -1070,7 +1069,7 @@ mod tests { ); assert_eq!( next_step(state, SubmitEvent::Granted(false)).action, - SubmitAction::Stop(Stop::Unknown) + SubmitAction::Stop(Stop::GrantUnavailable) ); assert_eq!( next_step(state, SubmitEvent::Write(WriteResult::Response)).action, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 6098987c1..e7468caa9 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"0edb2037eb7b5d6f13acfce85c54f62a82bf7fdd31bc7e626c4fec183cef61dd"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"41ebd1f7420603da8198c27ff90f830771f79917dacb477688c44c974ba79263"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"74136bc570da7b9338b5a1a1ed9d3fd892c55135160964f9d3ac0e2cf5741375"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f5fd3b28bf0663b46aee082f202bfe101234cd258bf0c5a492a73abe3231af99"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"39ad3705eb3aee2377497ced44b67b66adf871ae94467479bae06e2903d6455a"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76e09a14fbaa9b8be5f67790513d85cdf858e19a01839fd89b614182f61a10be"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"dcb58c43228b145b5405224c77f61bb0858923296872f5288170ba9c6d9d40e3"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"26d026f98463cafd65f059ddaae1441d57d98549f506709b0058c8cf8d8fb385"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2a343bbe4c0a5819e4936fe0783aa75a0041cdd41d640abf43572cc7fc8083ff"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4f03d8893a8ad762164055f519e74245d35d2cb9d4d700d25a4ab6ac9e90169"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"e00670a5ef24eb856cc2c6dcda8e5a263842f55c76bb939c0c27bd9df37e5522"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"772d032e0a0d9c924fb6d6c188528db85a97e71c9e466ddc19eee277baf83614"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"6e68a8fcc16e40c4c7a5d3e1a8fee47b4d5eec930da6349ddffbbcc5e3265758"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"825f2ee17f0876c51c76e21fff06ea0c4690fd77ddb9850259936f062cc23aec"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"3ebd3d4687a472b1f771d3d0467366d9e746bd73fa462e53f4020125e1850313"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"092e10290e9103a141b088a38c71c80f67718e1e644ddbc0e84adb5ca3f711a8"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"80581b4e946732ba2093c6bf1212a4e32cb3af1086a25ce5482891e9bd528b1d"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0f88771f2af4e10933eaed781f1c7c0622af236a667a233afe9e585c30bbca22"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"41ebd1f7420603da8198c27ff90f830771f79917dacb477688c44c974ba79263"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"38251ad6f22f9d07ef9a219c79fa265ca36f1526eca5f147d7efa46b52ad609d"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f5fd3b28bf0663b46aee082f202bfe101234cd258bf0c5a492a73abe3231af99"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"39ad3705eb3aee2377497ced44b67b66adf871ae94467479bae06e2903d6455a"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"1bd5b1fc481892c04a3439b6c3db2881720d22efaf491033d12ff280d91ac52c"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"dcb58c43228b145b5405224c77f61bb0858923296872f5288170ba9c6d9d40e3"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"26d026f98463cafd65f059ddaae1441d57d98549f506709b0058c8cf8d8fb385"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c9ab9056397c14401c280e057230cd1743d034fc85738391067cde66013547d3"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"62af244eb9fb63e9e633f212a8cb0951abc0e19b2f6021ac7df95988d4a0a6bc"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"326ad8806fec2fd01379c7d89dedfbee5ee33766b8a2a2374dc8e1f8af90c05b"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"505a500154e46276b676a212bd6d0de5a5192a4a8f9149f0fc80c1352ad7bc71"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"825f2ee17f0876c51c76e21fff06ea0c4690fd77ddb9850259936f062cc23aec"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"ead73266efa205dc8c7761899dd91e0e9b388945cd20761b017f338179ff62f3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"78ea96a8a82bd8273b38c531b9e73e5004ff02fe5cab0a91314e681ba97e2696"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"d1508297e9f9b25cb1573034fb2d2ab8bd73383513b577e2e108e4d16ccbdabd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0f88771f2af4e10933eaed781f1c7c0622af236a667a233afe9e585c30bbca22"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/audit.rs b/product/runtime/auths-gateway/src/audit.rs index 7d9dc6f8c..5b1b48c4e 100644 --- a/product/runtime/auths-gateway/src/audit.rs +++ b/product/runtime/auths-gateway/src/audit.rs @@ -312,7 +312,8 @@ fn refusal_code(result: GatewaySubmitResult) -> String { GatewaySubmitResult::Denied { code } | GatewaySubmitResult::Indeterminate { code } | GatewaySubmitResult::NotEntered { code } => code, - GatewaySubmitResult::Unknown + GatewaySubmitResult::Reserved { .. } + | GatewaySubmitResult::Unknown | GatewaySubmitResult::ResponseRecorded { .. } | GatewaySubmitResult::Observed { .. } | GatewaySubmitResult::ObservedByProvider { .. } => "audit.unexpected-result".to_owned(), diff --git a/product/runtime/auths-gateway/src/bounds_tests.rs b/product/runtime/auths-gateway/src/bounds_tests.rs index 78e64710f..776091195 100644 --- a/product/runtime/auths-gateway/src/bounds_tests.rs +++ b/product/runtime/auths-gateway/src/bounds_tests.rs @@ -333,6 +333,7 @@ async fn run(id: &str, backend: Backend) -> (String, Option, (usize, usi GatewaySubmitResult::Denied { code } => ("denied".to_owned(), Some(code)), GatewaySubmitResult::Indeterminate { code } => ("indeterminate".to_owned(), Some(code)), GatewaySubmitResult::NotEntered { code } => ("not-entered".to_owned(), Some(code)), + GatewaySubmitResult::Reserved { .. } => ("reserved".to_owned(), None), GatewaySubmitResult::Unknown => ("unknown".to_owned(), None), GatewaySubmitResult::ResponseRecorded { .. } | GatewaySubmitResult::Observed { .. } @@ -769,6 +770,7 @@ fn verdict(result: &GatewaySubmitResult) -> (&'static str, Option<&str>) { GatewaySubmitResult::Denied { code } => ("denied", Some(code)), GatewaySubmitResult::Indeterminate { code } => ("indeterminate", Some(code)), GatewaySubmitResult::NotEntered { code } => ("not-entered", Some(code)), + GatewaySubmitResult::Reserved { .. } => ("reserved", None), GatewaySubmitResult::Unknown | GatewaySubmitResult::ResponseRecorded { .. } | GatewaySubmitResult::Observed { .. } diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 1fac44300..644a54dc0 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -82,14 +82,20 @@ pub enum GatewayEngineConfigurationError { /// Closed, secret-free application result. A recorded response or matching /// read-back does not prove provider effect or exclusive causation. #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] -#[serde(tag = "outcome", rename_all = "kebab-case")] +#[serde(tag = "outcome", rename_all = "kebab-case", deny_unknown_fields)] pub enum GatewaySubmitResult { /// Native proof verification denied the action. Denied { code: String }, - /// Native proof verification could not reach an authorized conclusion. + /// Native verification or required durable state is unavailable/indeterminate. Indeterminate { code: String }, /// Proof was authorized but this operation did not enter write transport. NotEntered { code: String }, + /// A durable reservation exists without an entry grant. Continuing requires + /// fresh native authority, exact approval and a new single-winner grant. + Reserved { + #[serde(deserialize_with = "decode_journal_revision")] + revision: u64, + }, /// Write entry/effect is ambiguous; no automatic retry is permitted. Unknown, /// A complete bounded HTTP response exists, but no read-back was recorded. @@ -106,6 +112,16 @@ pub enum GatewaySubmitResult { }, } +fn decode_journal_revision<'de, D: serde::Deserializer<'de>>( + deserializer: D, +) -> Result { + let revision = u64::deserialize(deserializer)?; + if !(1..=9_007_199_254_740_991).contains(&revision) { + return Err(serde::de::Error::custom("invalid journal revision")); + } + Ok(revision) +} + /// Secret-free summary of stored provider evidence. The response bytes and /// the observation locator stay in the operator's attempt store. #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] @@ -1501,11 +1517,14 @@ impl GatewayEngine { } } -/// The result a stored attempt answers when a re-observation recorded -/// nothing new. -fn stored_result(snapshot: &crate::GatewayAttemptSnapshot) -> GatewaySubmitResult { +/// Public journal facts, used for replay and inspection. This projection never +/// creates authority, performs I/O or counts retained evidence as a new observation. +pub(crate) fn stored_result(snapshot: &crate::GatewayAttemptSnapshot) -> GatewaySubmitResult { use crate::GatewayAttemptStage as Stage; match (snapshot.stage(), snapshot.response_status()) { + (Stage::Reserved, _) => GatewaySubmitResult::Reserved { + revision: snapshot.revision(), + }, (Stage::NotEntered, _) => GatewaySubmitResult::NotEntered { code: snapshot .refusal() @@ -1977,10 +1996,6 @@ pub(crate) fn not_entered(code: &'static str) -> GatewaySubmitResult { } } -pub(crate) fn replay_refused() -> GatewaySubmitResult { - not_entered("gateway.attempt.replay") -} - fn wall_clock_seconds() -> Option { SystemTime::now() .duration_since(UNIX_EPOCH) diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index dbee2cd64..d56b2e98c 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -855,7 +855,9 @@ fn requirement_grant(harness: &Harness, from: u64, until: u64) -> SignedGrant { .expect("grant") } -async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused(backend: Backend) { +async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_returns_history( + backend: Backend, +) { let harness = Harness::open(update_recipe(), backend); let long = || requirement_grant(&harness, NOW - 3_600, NOW + 86_400); let observation = harness.read_back(RECORD, NOW).await; @@ -868,9 +870,10 @@ async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused NOW, None, ); + let first = harness.submit(&within, NOW + 5).await; assert!( matches!( - harness.submit(&within, NOW + 5).await, + first, GatewaySubmitResult::ObservedByProvider { status: Some(200), .. @@ -881,8 +884,8 @@ async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused assert_eq!(harness.provider.counts().0, 1); assert_eq!( harness.submit(&within, NOW + 10).await, - crate::engine::replay_refused(), - "the durable claim refuses the same action again inside its window" + first, + "the durable journal returns history for the same action inside its window" ); let later = NOW + 3_600; let reauthored = sdk_submission( @@ -895,8 +898,8 @@ async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused ); assert_eq!( harness.submit(&reauthored, later + 5).await, - crate::engine::replay_refused(), - "and a fresh action for the same logical operation after the window" + crate::engine::not_entered("gateway.effect.operation-conflict"), + "a fresh action conflicts with the same logical operation after the window" ); assert_eq!(harness.provider.counts().0, 1); @@ -1541,7 +1544,7 @@ on_both_stores!( observer_in_the_authority_chain_is_refused, observer_key_in_the_authority_chain_is_refused_by_key, action_fact_policy_is_bound_into_the_pinned_configuration, - sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused, + sdk_action_window_admits_a_later_gateway_clock_and_replay_returns_history, sdk_action_window_is_cut_to_the_grant_expiry, a_longer_action_window_never_extends_observation_freshness, two_of_three_root_authorizes_only_with_two_distinct_roots, diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index cdf16b595..79ff31ce1 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -1,4 +1,4 @@ -//! Attempt scenarios for attempt record `/4`: the pre-entry re-read, the +//! Attempt scenarios for attempt record `/6`: the pre-entry re-read, the //! relative ceiling, the lease-time account and denied reads, account-scope //! headers, the retention rule, the entry deadline, and response-locator //! recovery. @@ -8,12 +8,10 @@ //! (empty when nothing is stored), the refusal code, and the lease, read, and //! write counts. //! -//! `record_cases` are the claim, response, observation, and `unknown` -//! scenarios of the retired attempt record `/2`, moved here unchanged when -//! record `/3` replaced it. One `/2` scenario is not carried: -//! `crash-after-entry-not-reobserved` asserted that a stored `attempting` -//! record is never re-observed, which record `/3` reverses for a linked -//! recipe; `linked-attempting-reobserved` replaces it. +//! `record_cases` retain explicit operator observation mechanics as a reference; +//! application replay only returns stored state. Neither oracle establishes +//! independently authorized AP074 recovery. A grant with a lost response remains +//! unknown on replay, including when a recipe has a linked observation plan. use super::{NOW, recipes, require_current}; use serde_json::{Map, Value, json}; @@ -479,12 +477,12 @@ fn entry_and_recovery_cases() -> Vec { &counts(1, 3, 1, 1), ), scenario( - "linked-attempting-reobserved", + "linked-grant-replay-retains-unknown", "airtable", json!({"crash": "after-write-before-response", "replay": "same-binding"}), - &["reserved", "entry-granted", "observed-by-provider"], + &["reserved", "entry-granted"], None, - &counts(2, 0, 1, 1), + &counts(1, 0, 1, 0), ), ] } @@ -495,7 +493,11 @@ const RECORD_CASES: &[(&str, &str, u64)] = &[ ("same-id-fresh-challenge", "reserved->binding-conflict", 0), ("changed-action-same-id", "reserved->binding-conflict", 0), ("crash-after-claim", "reserved->reserved-on-restart", 0), - ("complete-http-response", "entry-granted->response-recorded", 1), + ( + "complete-http-response", + "entry-granted->response-recorded", + 1, + ), ("ambiguous-transport", "entry-granted->unknown", 1), ("matching-read-back", "response-recorded->observed-match", 1), ( diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 4d091f3d8..befd670db 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -55,7 +55,6 @@ const ROWS: &[&str] = &[ "gateway.credential.unavailable engine recorded changed 3 -", "gateway.idempotency.window-exceeds-retention engine before-claim new 3 A:idempotency-window-exceeds-retention", "gateway.policy.above-sum-limit engine before-claim new 4 B:argument-above-smallest-sum-limit", - "gateway.policy.count-unavailable ReserveRefusal before-claim changed 4 -", "gateway.policy.evaluator-mismatch engine before-claim existing - B:policy-type-v1-refused", "gateway.policy.evaluator-unregistered engine before-claim existing - B:evaluator-v1-refused", "gateway.policy.expanded engine before-claim existing - B:child-raises-sum-limit", diff --git a/product/runtime/auths-gateway/src/pending_vectors/production.rs b/product/runtime/auths-gateway/src/pending_vectors/production.rs index 62632914b..b87d4b6d3 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/production.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/production.rs @@ -87,7 +87,7 @@ const ROWS: &[&str] = &[ "gateway.support.unavailable support support-bundle implemented 4 -", "gateway.support.attempts-unavailable support support-bundle implemented 4 -", "gateway.support.connection-unavailable support support-bundle implemented 4 -", - "gateway.attempt.replay engine recorded existing - C:lease-never-precedes-claim", + "gateway.attempt.state-unavailable engine journal implemented 5 -", "gateway.connection.credential-generation-missing engine before-claim existing - C:lease-generation-not-held", "gateway.credential.unavailable engine recorded existing - C:lease-commitment-mismatch", "gateway.install.credential-store-unavailable install install existing - -", @@ -667,10 +667,10 @@ fn lease_cases() -> Vec { scenario( "lease-never-precedes-claim", "selection", - &["the logical operation was already claimed"], + &["the logical operation has an entry grant and no recorded response"], json!({ - "stage": "not-entered", - "code": "gateway.attempt.replay", + "stage": "unknown", + "code": null, "leases": 0, "provider_entries": 0, }), diff --git a/product/runtime/auths-gateway/src/qualification_simulation.rs b/product/runtime/auths-gateway/src/qualification_simulation.rs index a87624dfd..13a0c020f 100644 --- a/product/runtime/auths-gateway/src/qualification_simulation.rs +++ b/product/runtime/auths-gateway/src/qualification_simulation.rs @@ -259,8 +259,9 @@ fn publish(family: Family, recipe: &CompiledRecipe, cases: &[Measurement]) { /// Runs each lifecycle against real durable claims, with both original and /// fresh proof commitments. A lost response or response-record crash must -/// use only recovery the recipe's derived capability permits: Airtable's -/// verified locator and echo can re-observe; Stripe needs its response locator. +/// retain unknown on replay. Explicit operator observation mechanics are tested +/// separately: Airtable has a verified locator; Stripe needs its response locator. +/// These simulations do not establish AP074 independent recovery authorization. async fn lifecycle( family: Family, provider: &OracleProvider

, @@ -289,6 +290,7 @@ async fn lifecycle( "{result:?}" ); } + let cases_result = result.clone(); let mut cases = vec![measurement( if ambiguous { "ambiguous-write" @@ -317,35 +319,42 @@ async fn lifecycle( let before = provider.checked.load(Ordering::SeqCst); let entries_before = provider.inner.entries(); let result = run(attempts, &recipe, &observer, &io).await; - let recovery = ambiguous && matches!(family, Family::Airtable) && commitment == ORIGINAL; - if recovery { - assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), - "{} {name} ambiguous={ambiguous}: {result:?}", - family.name() - ); + let same_binding = commitment == ORIGINAL; + if same_binding { + assert_eq!(result, cases_result, "{name}: return historical result"); } else { - assert!(!matches!( + assert_eq!( result, - GatewaySubmitResult::ObservedByProvider { .. } - )); + crate::engine::not_entered("gateway.effect.operation-conflict") + ); } - assert_eq!( - io.leases(), - usize::from(recovery), - "{name}: only declared read-back recovery leases" - ); + assert_eq!(io.leases(), 0, "{name}: replay never leases credentials"); assert_eq!( provider.checked.load(Ordering::SeqCst), before, "{name}: no second write" ); - cases.push(measurement( + let mut observed = measurement( name, &result, io.leases(), provider.inner.entries() - entries_before, + ); + observed.confirmed_by_read_back = 0; // Historical evidence is not a new provider read. + cases.push(observed); + } + if ambiguous && matches!(family, Family::Airtable) { + let io = TestIo::new(provider, family.command(&recipe, &args, ORIGINAL)); + let entries_before = provider.inner.entries(); + let result = super::reobserve_operator(store.attempts(), &recipe, &observer, &io) + .await + .expect("explicit operator observation mechanics"); + assert!(matches!( + result, + GatewaySubmitResult::ObservedByProvider { .. } )); + assert_eq!(provider.inner.entries(), entries_before); + cases.push(measurement("operator-read-back", &result, io.leases(), 0)); } cases } diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 975af7973..e53d7dc2c 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -11,7 +11,7 @@ #![allow(clippy::too_many_lines, reason = "scenario tables read top to bottom")] -use crate::engine::{GatewaySubmitResult, VerifiedCommand, replay_refused}; +use crate::engine::{GatewaySubmitResult, VerifiedCommand}; use crate::harness::{OBSERVER_SEED, ROOT_SEED, Signer, context}; use crate::pending_vectors::attempts::FILE as SCENARIOS; use crate::recipe::GuardChecks; @@ -66,6 +66,10 @@ struct RecordingStore { inner: Arc, stages: Mutex>, lose_response_record: AtomicBool, + refuse_entry_grant: AtomicBool, + lose_entry_grant_ack: AtomicBool, + hide_grant_state: AtomicBool, + fail_attempt_load: AtomicBool, } impl RecordingStore { @@ -74,6 +78,10 @@ impl RecordingStore { inner, stages: Mutex::new(Vec::new()), lose_response_record: AtomicBool::new(false), + refuse_entry_grant: AtomicBool::new(false), + lose_entry_grant_ack: AtomicBool::new(false), + hide_grant_state: AtomicBool::new(false), + fail_attempt_load: AtomicBool::new(false), }) } @@ -105,6 +113,11 @@ impl GatewayAttemptStore for RecordingStore { let mut replacement = None; self.inner.fenced_replace(keys, &mut |snapshot| { let next = decide(snapshot)?; + if Self::stage_of(&next).as_deref() == Some("entry-granted") + && self.refuse_entry_grant.swap(false, Ordering::SeqCst) + { + return Err(GatewayAttemptError::Unavailable); + } replacement = Some(next.clone()); Ok(next) })?; @@ -112,6 +125,15 @@ impl GatewayAttemptStore for RecordingStore { && let Some(next) = replacement { self.record(&next); + if Self::stage_of(&next).as_deref() == Some("entry-granted") + && self.lose_entry_grant_ack.swap(false, Ordering::SeqCst) + { + self.fail_attempt_load.store( + self.hide_grant_state.load(Ordering::SeqCst), + Ordering::SeqCst, + ); + return Err(GatewayAttemptError::Unavailable); + } } Ok(()) } @@ -148,6 +170,9 @@ impl GatewayAttemptStore for RecordingStore { kind: GatewayRecordKind, key: &GatewayAttemptKey, ) -> Result>, GatewayAttemptError> { + if kind == GatewayRecordKind::Attempt && self.fail_attempt_load.load(Ordering::SeqCst) { + return Err(GatewayAttemptError::Unavailable); + } self.inner.load(kind, key) } @@ -436,6 +461,38 @@ async fn run( .await } +/// Explicit operator mechanics retained as a test oracle while independently +/// authorized recovery is implemented. This is never an application replay and +/// establishes no AP074 recovery-authority or bounded-acquisition claim. +async fn reobserve_operator( + attempts: &GatewayAttempts, + recipe: &CompiledRecipe, + observer: &GatewayObserver, + io: &TestIo<'_, P>, +) -> Option { + let request = &io.verified.as_ref().expect("command").request; + let attempt = attempts + .resume_observable_operation( + request.namespace(), + request.operation_id(), + *recipe.digest(), + ) + .await + .expect("operator lookup")?; + let context = test_context(observer); + submit::reobserve( + &SubmitContext { + recipe, + attempts, + context: &context, + observer: Some(observer), + }, + io, + attempt, + ) + .await +} + // --------------------------------------------------------------------------- // The record double of the `/2` record scenarios. @@ -627,16 +684,6 @@ impl Record { run(self.store.attempts(), &self.recipe, &self.observer, &io).await } - async fn submit_on( - &self, - attempts: &GatewayAttempts, - command: &VerifiedCommand, - provider: &RecordProvider, - ) -> GatewaySubmitResult { - let io = TestIo::new(provider, command.clone()); - run(attempts, &self.recipe, &self.observer, &io).await - } - async fn snapshot(&self, command: &VerifiedCommand) -> GatewayAttemptSnapshot { self.store .attempts() @@ -777,22 +824,32 @@ async fn run_resolution_case(id: &str, backend: Backend) -> (String, usize) { &provider, ) .await; + let expected = if changed { + crate::engine::not_entered("gateway.effect.operation-conflict") + } else { + first.clone() + }; + assert_eq!(replay, expected, "{id}: first {first:?}"); + assert_eq!( + before, + record.describe(&original).await, + "replay preserves journal" + ); if matches!( - record.snapshot(&original).await.stage(), - GatewayAttemptStage::ObservedByProvider - ) && before != "observed-by-provider" - { + id, + "timeout-after-delivery-read-back" | "restart-during-unknown" + ) { + let io = TestIo::new(&provider, original.clone()); assert!(matches!( - replay, - GatewaySubmitResult::ObservedByProvider { status: None, .. } + reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io + ) + .await, + Some(GatewaySubmitResult::ObservedByProvider { status: None, .. }) )); - } else { - let expected = if changed { - crate::engine::not_entered("gateway.effect.operation-conflict") - } else { - replay_refused() - }; - assert_eq!(replay, expected, "{id}: first {first:?}"); } ( format!("{before}->{}", record.describe(&original).await), @@ -1530,17 +1587,20 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { RunStep { operation: Operation::Replay, evidence_comparison: EvidenceComparison::Static {}, - expected: expected( - RunOutcome::Refused, - if scenario == Scenario::FreshChallengeReplay { - "gateway.effect.operation-conflict" - } else { - "gateway.attempt.replay" - }, - 0, - 0, - 0, - ), + expected: if scenario == Scenario::FreshChallengeReplay { + expected( + RunOutcome::Refused, + "gateway.effect.operation-conflict", + 0, + 0, + 0, + ) + } else { + let mut stored = + expected(RunOutcome::Observed, "observed-by-provider", 0, 0, 0); + stored.verdict.evidence_sha256 = Some(evidence); + stored + }, }, ] }; @@ -1556,19 +1616,31 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { }; let io = TestIo::new(&provider, command); let writes_before = provider.writes(); - let result = run( - record.store.attempts(), - &record.recipe, - &record.observer, - &io, - ) - .await; + let reads_before = provider.reads(); + let result = if recovering && index == 1 { + reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await + .expect("explicit operator observation") + } else { + run( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await + }; let (outcome, code, evidence_sha256, confirmed) = match result { GatewaySubmitResult::ObservedByProvider { evidence, .. } => ( RunOutcome::Observed, "observed-by-provider".to_owned(), Some(Sha256Digest::try_from(evidence.evidence_digest).expect("evidence")), - 1, + u32::from(provider.reads() > reads_before), ), GatewaySubmitResult::Unknown => { (RunOutcome::Unknown, "unknown".to_owned(), None, 0) @@ -1656,12 +1728,15 @@ async fn conformance_claim_exactly_once_and_replay(backend: Backend) { let record = Record::open("airtable", backend); let provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); let original = record.airtable(ORIGINAL, "Approved"); + let first = record.submit(&original, &provider).await; assert!(matches!( - record.submit(&original, &provider).await, + first, GatewaySubmitResult::ObservedByProvider { .. } )); + let before = record.snapshot(&original).await; for _ in 0..3 { - assert_eq!(record.submit(&original, &provider).await, replay_refused()); + assert_eq!(record.submit(&original, &provider).await, first); + assert_eq!(record.snapshot(&original).await, before); } assert!(matches!( record @@ -1796,7 +1871,7 @@ async fn conformance_fresh_challenge(backend: Backend) { record .submit(&record.airtable(ORIGINAL, "Approved"), &provider) .await, - replay_refused() + first ); for command in [ record.airtable(FRESH, "Approved"), @@ -1826,19 +1901,34 @@ async fn conformance_unknown_and_reobserve(backend: Backend) { "an unknown write is not read back in-line" ); record.store.restart(); - let fresh = record.airtable(ORIGINAL, "Approved"); - let GatewaySubmitResult::ObservedByProvider { status, evidence } = - record.submit(&fresh, &provider).await + let io = TestIo::new(&provider, original.clone()); + assert_eq!( + record.submit(&original, &provider).await, + GatewaySubmitResult::Unknown + ); + assert_eq!(provider.reads(), 0, "replay is not recovery authority"); + let resolved = reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await + .expect("operator observation"); + let GatewaySubmitResult::ObservedByProvider { + status, + ref evidence, + } = resolved else { panic!("expected observed-by-provider"); }; assert_eq!(status, None); assert_eq!(evidence.echo, original_token()); - assert_eq!(Some(evidence.echo.as_str()), fresh.request.echo_token()); + assert_eq!(Some(evidence.echo.as_str()), original.request.echo_token()); assert_eq!( - record.submit(&fresh, &provider).await, - replay_refused(), - "terminal stage is not re-read" + record.submit(&original, &provider).await, + resolved, + "terminal stage is returned without re-reading the provider" ); assert_eq!((provider.writes(), provider.reads()), (1, 1)); } @@ -1878,17 +1968,18 @@ async fn conformance_concurrent_reobservation(backend: Backend) { ); let first = record.store.reopen(); let second = record.store.reopen(); - let fresh = record.airtable(FRESH, "Approved"); + let left_io = TestIo::new(&provider, original.clone()); + let right_io = TestIo::new(&provider, original.clone()); let (left, right) = tokio::join!( - record.submit_on(&first, &fresh, &provider), - record.submit_on(&second, &fresh, &provider) + reobserve_operator(&first, &record.recipe, &record.observer, &left_io), + reobserve_operator(&second, &record.recipe, &record.observer, &right_io) ); let terminal = [&left, &right] .iter() - .filter(|result| matches!(result, GatewaySubmitResult::ObservedByProvider { .. })) + .filter(|result| matches!(result, Some(GatewaySubmitResult::ObservedByProvider { .. }))) .count(); assert_eq!(terminal, 1, "{left:?} {right:?}"); - assert!(left == replay_refused() || right == replay_refused()); + assert!(left.is_none() || right.is_none()); assert_eq!( record.snapshot(&original).await.stage(), GatewayAttemptStage::ObservedByProvider @@ -1960,7 +2051,9 @@ async fn conformance_mechanism_fails_closed(backend: Backend) { let provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); assert_eq!( record.submit(&command, &provider).await, - crate::engine::not_entered("gateway.attempt.unavailable") + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + } ); assert_eq!((provider.writes(), provider.reads()), (0, 0)); } @@ -2582,3 +2675,111 @@ fn a_file_batch_crashed_at_any_step_is_rolled_back() { GatewayInsert::Exists { index: 0 } ); } + +/// Native public state and zero-I/O replay corpus. The command oracle is +/// synthetic; the file journal and shared submission driver are real. +#[tokio::test] +async fn native_replay_projection_fixture_is_current() { + let record = Record::open("airtable", Backend::File); + let provider = RecordProvider::new(Delivery::TimeoutAfterApplying, Reading::Faithful); + let command = record.airtable(ORIGINAL, "Approved"); + assert_eq!( + record.submit(&command, &provider).await, + GatewaySubmitResult::Unknown + ); + let before = record.snapshot(&command).await; + let io = TestIo::new(&provider, command.clone()); + let replay = run( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await; + assert_eq!(replay, GatewaySubmitResult::Unknown); + assert_eq!(io.leases(), 0); + assert_eq!((provider.writes(), provider.reads()), (1, 0)); + assert_eq!(before, record.snapshot(&command).await); + let mut grants = Vec::new(); + for (ambiguous, state_unavailable) in [(false, false), (true, false), (true, true)] { + let record = Record::open("airtable", Backend::File); + let provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); + let command = record.airtable(ORIGINAL, "Approved"); + let store = RecordingStore::new(record.store.raw()); + store.refuse_entry_grant.store(!ambiguous, Ordering::SeqCst); + store + .hide_grant_state + .store(state_unavailable, Ordering::SeqCst); + store + .lose_entry_grant_ack + .store(ambiguous, Ordering::SeqCst); + let attempts = + GatewayAttempts::new(store, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let io = TestIo::new(&provider, command.clone()); + let result = run(&attempts, &record.recipe, &record.observer, &io).await; + let expected = if state_unavailable { + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + } + } else if ambiguous { + GatewaySubmitResult::Unknown + } else { + GatewaySubmitResult::Reserved { revision: 1 } + }; + assert_eq!(result, expected); + assert_eq!((provider.writes(), provider.reads()), (0, 0)); + grants.push(json!({"ambiguous_ack": ambiguous, "state_unavailable": state_unavailable, "result": result, "provider_writes": 0, "provider_reads": 0})); + } + let first_store = record.store.reopen(); + let second_store = record.store.reopen(); + let left_io = TestIo::new(&provider, command.clone()); + let right_io = TestIo::new(&provider, command.clone()); + let (left, right) = tokio::join!( + run(&first_store, &record.recipe, &record.observer, &left_io), + run(&second_store, &record.recipe, &record.observer, &right_io) + ); + assert_eq!(left, GatewaySubmitResult::Unknown); + assert_eq!(right, GatewaySubmitResult::Unknown); + assert_eq!(left_io.leases() + right_io.leases(), 0); + assert_eq!((provider.writes(), provider.reads()), (1, 0)); + assert_eq!(before, record.snapshot(&command).await); + let valid_reserved = [ + json!({"outcome": "reserved", "revision": 1}), + json!({"outcome": "reserved", "revision": 9_007_199_254_740_991_u64}), + ]; + let invalid_reserved = [ + json!({"outcome": "reserved"}), + json!({"outcome": "reserved", "revision": 0}), + json!({"outcome": "reserved", "revision": -1}), + json!({"outcome": "reserved", "revision": 9_007_199_254_740_992_u64}), + json!({"outcome": "reserved", "revision": true}), + json!({"outcome": "reserved", "revision": "1"}), + json!({"outcome": "reserved", "revision": 1.5}), + json!({"outcome": "reserved", "revision": 1, "may_send": true}), + ]; + for valid in &valid_reserved { + assert!(matches!( + serde_json::from_value::(valid.clone()), + Ok(GatewaySubmitResult::Reserved { .. }) + )); + } + for invalid in &invalid_reserved { + assert!(serde_json::from_value::(invalid.clone()).is_err()); + } + let cases = json!({ + "schema": "auths.gateway-replay-projection-fixture/1", + "scope": "native synthetic driver and file journal; no installed authority or independent recovery claim", + "unknown_replay": {"result": replay, "additional_leases": io.leases(), "additional_reads": 0, "additional_writes": 0, "journal_unchanged": true}, + "unacknowledged_grants": grants, + "concurrent_replays": {"results": [left, right], "additional_leases": 0, "additional_reads": 0, "additional_writes": 0, "journal_unchanged": true}, + "reserved_decoding": {"valid": valid_reserved, "invalid": invalid_reserved}, + }); + let bytes = serde_json::to_vec_pretty(&cases).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/replay-projection.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 3235261d3..397c52d54 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "4e1b8eea0e898fa24c0f0be3a459a360a3372d0a67c9ad20fc0dd3cc683aa8a0"; + "ef769b2899436075fec0257e16dcc04eff7bac8fcf60a991b06f0de1b7c510db"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 103445f7a..e78c57483 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -1848,14 +1848,6 @@ async fn blocking( .map_err(|_| GatewayAttemptError::Unavailable)? } -/// The plan a reopened attempt must match: the one a new verified request -/// resolves to, or, for the operator's re-observation, the stored one. -#[derive(Clone, Copy)] -enum ExpectedPlan<'a> { - Request(Option<&'a ObservationTemplate>), - Stored, -} - /// A fresh `reserved` claim record for `request`, with a random nonce and /// no counters. fn claim_record( @@ -2065,36 +2057,35 @@ impl GatewayAttempts { .transpose() } - /// Reopens a stored attempt for one read-only observation from its - /// stored plan. It returns `None` unless the recipe digest is unchanged, - /// the new verified request resolves to the same plan, and the stage can - /// be resolved by a read-back: an `entry-granted` or `unknown` record only - /// for a verified-locator link, and a `response-recorded` record for any - /// declared link whose locator is recorded. A re-observation records only - /// positive evidence under compare-and-swap, so it may run while the - /// original attempt is in flight; the in-flight process then loses its - /// own compare-and-swap, and no second write happens either way. - /// - /// # Errors - /// Malformed state is a hard failure. - pub async fn resume_observable( + /// Reads history only when the complete immutable binding matches the + /// approved native effect. Renewed approval is not part of that identity. + pub(crate) async fn read_effect( &self, - request: &ClosedProviderRequest, - recipe_digest: [u8; 32], - ) -> Result, GatewayAttemptError> { - self.resume( - request.namespace(), - request.operation_id(), - recipe_digest, - ExpectedPlan::Request(request.observation_template()), - ) - .await + approved: &ApprovedEffect, + ) -> Result, GatewayAttemptError> { + let request = &approved.command().request; + let Some((_, record)) = self + .load(request.namespace(), request.operation_id()) + .await? + else { + return Ok(None); + }; + if record.binding_canonical.as_bytes() + != approved + .effect() + .binding() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + record.snapshot(true).map(Some) } /// Reopens a stored attempt for the operator's read-only - /// re-observation, under the rules of - /// [`Self::resume_observable`] except that the plan comes from the - /// stored record alone, since the operator supplies no request. + /// re-observation. The recipe must match and the stored stage must permit + /// evidence from its stored plan. Application replay cannot call this path. /// /// # Errors /// Malformed state is a hard failure. @@ -2103,17 +2094,6 @@ impl GatewayAttempts { namespace: &OperatorNamespace, operation_id: &LogicalOperationId, recipe_digest: [u8; 32], - ) -> Result, GatewayAttemptError> { - self.resume(namespace, operation_id, recipe_digest, ExpectedPlan::Stored) - .await - } - - async fn resume( - &self, - namespace: &OperatorNamespace, - operation_id: &LogicalOperationId, - recipe_digest: [u8; 32], - expected_plan: ExpectedPlan<'_>, ) -> Result, GatewayAttemptError> { let Some((stored, record)) = self.load(namespace, operation_id).await? else { return Ok(None); @@ -2132,10 +2112,6 @@ impl GatewayAttempts { }; let resumable = stage_resolvable && record.recipe_digest == hex::encode(recipe_digest) - && match expected_plan { - ExpectedPlan::Request(plan) => record.observation_plan.as_ref() == plan, - ExpectedPlan::Stored => true, - } && record.observation_request().is_some(); let key = self.key(namespace, operation_id)?; Ok(resumable.then(|| ObservableGatewayAttempt { diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 8aff748b4..21891b8e5 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -10,7 +10,7 @@ //! provider double through the same driver. use crate::effect::ApprovedEffect; -use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered, replay_refused}; +use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered}; use crate::pre_entry::{self, PreEntryObservation, SelectedRequirement}; use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES, ReadBack}; use crate::store::BoundedClaim; @@ -305,7 +305,7 @@ pub(crate) async fn run(cx: &SubmitContext<'_>, io: &I) -> GatewayS /// Runs the operator's read-only re-observation of `attempt`, which /// [`GatewayAttempts::resume_observable_operation`] reopened, through the -/// same step machine a replay takes: a reload, a fresh lease that passes +/// existing operator step machine: a reload, a fresh lease that passes /// every credential check, and one read-back from the stored plan. The /// caller has already prepared the entry. Returns the recorded result, or /// `None` when the read-back recorded nothing. @@ -373,7 +373,6 @@ impl Run<'_, I> { SubmitEvent::Preparation(valid) } SubmitAction::Claim => SubmitEvent::Claim(self.claim().await), - SubmitAction::Resume => SubmitEvent::Resume(self.resume().await), SubmitAction::Reload(_) => SubmitEvent::Reload(self.io.reload().await), SubmitAction::ReloadBeforeEntry => { // Counted before the reload, so an admin change committed @@ -562,36 +561,33 @@ impl Run<'_, I> { ClaimResult::Refused } Ok(BoundedClaim::Contended) => { - self.refuse_before_claim(not_entered("gateway.policy.count-unavailable")); + self.result = Some(self.stored_result().await); ClaimResult::Unavailable } - Err(GatewayAttemptError::Replay) => ClaimResult::Replay, + Err(GatewayAttemptError::Replay) => { + self.result = Some(self.stored_result().await); + ClaimResult::Replay + } Err(GatewayAttemptError::BindingConflict) => { self.refuse_before_claim(not_entered("gateway.effect.operation-conflict")); ClaimResult::Refused } Err(_) => { - self.refuse_before_claim(not_entered("gateway.attempt.unavailable")); + self.result = Some(self.stored_result().await); ClaimResult::Unavailable } } } - async fn resume(&mut self) -> bool { - let Some(verified) = self.verified.as_deref().map(ApprovedEffect::command) else { - return false; + /// A replay or unacknowledged grant only loads the exact bound journal. + /// It never leases credentials or acquires provider evidence. + async fn stored_result(&self) -> GatewaySubmitResult { + let Some(approved) = self.verified.as_deref() else { + return unavailable_state(); }; - match self - .cx - .attempts - .resume_observable(&verified.request, *self.cx.recipe.digest()) - .await - { - Ok(Some(attempt)) => { - self.observable = Some(attempt); - true - } - Ok(None) | Err(_) => false, + match self.cx.attempts.read_effect(approved).await { + Ok(Some(snapshot)) => crate::engine::stored_result(&snapshot), + Ok(None) | Err(_) => unavailable_state(), } } @@ -739,8 +735,13 @@ impl Run<'_, I> { .await { Ok(granted) => granted, - // An ambiguous acknowledgement may follow a committed grant. - Err(_) => return false, + // The grant may have committed without its acknowledgement. + // A fresh authoritative read may report reserved or unknown, never + // manufacture a permit. Unavailable state is indeterminate. + Err(_) => { + self.result = Some(self.stored_result().await); + return false; + } }; self.claim = Some(claim); self.permit = Some(permit); @@ -895,7 +896,9 @@ impl Run<'_, I> { Stop::Refused => self .result .unwrap_or_else(|| not_entered("gateway.attempt.unavailable")), - Stop::StoreUnavailable => not_entered("gateway.attempt.unavailable"), + Stop::StoreUnavailable | Stop::Stored | Stop::GrantUnavailable => { + self.result.unwrap_or_else(unavailable_state) + } Stop::ClaimRefused | Stop::Response | Stop::Observed => { self.result.unwrap_or(GatewaySubmitResult::Unknown) } @@ -903,11 +906,17 @@ impl Run<'_, I> { .refusal .map_or(GatewaySubmitResult::Unknown, not_entered), Stop::Unknown | Stop::Halted => GatewaySubmitResult::Unknown, - Stop::ReplayRefused => replay_refused(), + Stop::ReobservationUnrecorded => unavailable_state(), } } } +fn unavailable_state() -> GatewaySubmitResult { + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + } +} + /// The lease-time credential checks of a read outside a submission (an /// observation request): the prefix guard, the account read, and each /// denied read in declaration order, stopping at the first failure. diff --git a/qualification/reference/family_corpus.py b/qualification/reference/family_corpus.py index 7d94b24a4..af9946a8d 100644 --- a/qualification/reference/family_corpus.py +++ b/qualification/reference/family_corpus.py @@ -92,9 +92,6 @@ def observed(operation, label, leases=2, entries=1, confirmed=1): def unknown(operation, label, leases=0, entries=0): return step(operation, 'unknown', 'unknown', label, leases, entries) - def replay(): - return step('replay', 'refused', 'gateway.attempt.replay') - def add(phase, identifier, scenario, steps, capabilities=()): cases.append({'id': phase + '-' + identifier, 'scenario': scenario, 'capabilities': list(capabilities), 'phase': phase, 'steps': steps}) @@ -114,23 +111,19 @@ def add(phase, identifier, scenario, steps, capabilities=()): for phase in ['commissioning', 'live']: label = lambda index: phase + '-' + str(index).zfill(2) add(phase, 'fresh-replay', 'fresh-challenge-replay', - [observed('submit', label(0)), replay()]) - add(phase, 'proof-replay', 'proof-replay', [observed('submit', label(1)), replay()]) + [observed('submit', label(0)), step('replay', 'refused', 'gateway.effect.operation-conflict')]) + add(phase, 'proof-replay', 'proof-replay', [observed('submit', label(1)), observed('replay', label(1), 0, 0, 0)]) # The held owner response keeps an entered operation unresolved while - # the second actual process races its claim. Airtable can take one - # read-only recovery lease; its committed observation makes the - # owner response CAS lose, so that owner takes no observation lease. - # Stripe has no unrecorded response locator; its owner confirms later. + # the second actual process reads the granted journal. The follower + # takes no lease; the owner records its response and observation. add(phase, 'two-host-race', 'two-instance-race', [observed('race', label(2), leases=2)]) for index, operation in [(3, 'restart'), (4, 'crash')]: - ending = observed('replay', label(index), 1, 0, 1) if reference is airtable_record \ - else replay() + ending = unknown('replay', label(index)) add(phase, operation, operation, [unknown('submit', label(index), 1, 1), complete(operation, 'gateway-' + operation + '-completed'), ending]) add(phase, 'ambiguous', 'ambiguous-response', [unknown('drop-response', label(5), 1, 1), - observed('replay', label(5), 1, 0, 1) if reference is airtable_record - else replay()]) + unknown('replay', label(5))]) for index, identifier, operation, scenario in [ (6, 'response-loss', 'drop-response', 'response-loss'), (7, 'visibility', 'delay-visibility', 'delayed-visibility')]: diff --git a/qualification/reference/native_observation.py b/qualification/reference/native_observation.py index 3c2a64ce9..f5a708d65 100644 --- a/qualification/reference/native_observation.py +++ b/qualification/reference/native_observation.py @@ -144,13 +144,12 @@ def project_race(self, tuple_value, reviewed, resources, native_results, pairs, 'qualification.observation.race-hosts') decoded = [result(value) for value in native_results] linked = [value for value in decoded if value[2] is not None] - require(linked and all(value[0] in ['observed', 'unknown'] - or (value[0] == 'refused' and value[1] == 'gateway.attempt.replay') for value in decoded) + require(linked and all(value[0] in ['observed', 'unknown'] for value in decoded) and all(all(value[2][field] == linked[0][2][field] for field in ['channel', 'echo', 'evidence_digest']) for value in linked), 'qualification.observation.race-evidence') - # Both are actual host results; the survivor's read-only recovery can - # supply the link. Distinct native scopes are aggregated directly. + # Both are actual host results. The owner supplies the link; the + # follower only reads history. Distinct native scopes are aggregated. return self._project(tuple_value, reviewed, resources, linked[0], measure.aggregate(pairs), response, status=next(value['status'] for value in native_results if value['outcome'] == 'observed-by-provider')) diff --git a/qualification/simulation/live/airtable.py b/qualification/simulation/live/airtable.py index 8d96e7962..6e9ef94b8 100644 --- a/qualification/simulation/live/airtable.py +++ b/qualification/simulation/live/airtable.py @@ -270,14 +270,14 @@ def exercise(self): uid=self.app_uid) for index, sock in enumerate([first, second])] results = [json.loads(future.result()) for future in futures] require(any(value.get('outcome') == 'observed-by-provider' for value in results), 'live.write-not-observed') - require(all(value.get('outcome') in ['observed-by-provider', 'not-entered'] for value in results), + require(all(value.get('outcome') in ['observed-by-provider', 'unknown'] for value in results), 'live.race-unexpected-outcome') observed = next(value for value in results if value.get('outcome') == 'observed-by-provider') readback = self.api('GET', '/v0/' + self.args.base + '/' + self.args.table + '/' + self.record) require(readback['fields']['DemoStatus'] == 'Approved' and readback['fields']['auths_echo'] == observed['evidence']['echo'], 'live.fresh-read-back-mismatch') replay = json.loads(self.run('proof-replay', self.child('submit', first), uid=self.app_uid)) - require(replay.get('outcome') == 'not-entered' and replay.get('code') == 'gateway.attempt.replay', 'live.replay-not-refused') + require(replay == observed, 'live.replay-history-mismatch') altered = json.loads(self.run('altered-action', self.child('altered', first), uid=self.app_uid)) require(altered.get('outcome') in ['not-entered', 'denied', 'indeterminate'], 'live.altered-action-entered') support = self.run('support-bundle', [self.binary, 'support-bundle', '--state-dir', self.work / 'first']) @@ -286,7 +286,7 @@ def exercise(self): self.stop() restarted = self.start('first') replay_after = json.loads(self.run('restart-replay', self.child('submit', restarted), uid=self.app_uid)) - require(replay_after.get('outcome') == 'not-entered' and replay_after.get('code') == 'gateway.attempt.replay', + require(replay_after == observed, 'live.restart-replay-entered') self.stop() report = {'schema': 'auths.recipe-qualification-simulation/1', 'simulation': True, diff --git a/qualification/simulation/live/stripe.py b/qualification/simulation/live/stripe.py index 555a879e2..3ce9c8196 100644 --- a/qualification/simulation/live/stripe.py +++ b/qualification/simulation/live/stripe.py @@ -257,7 +257,7 @@ def exercise(self): require(len(refunds) == 1 and len(matched) == 1 and matched[0]['payment_intent'] == self.payment, 'live.fresh-refund-read-back-mismatch') results['proof-replay'] = json.loads(self.run('proof-replay', self.child('submit'), uid=self.app_uid)) - require(results['proof-replay'].get('code') == 'gateway.attempt.replay', 'live.replay-entered') + require(results['proof-replay'] == results['normal'], 'live.replay-entered') results['altered-action'] = json.loads(self.run('altered-action', self.child('altered'), uid=self.app_uid)) require(results['altered-action'].get('outcome') in ['denied', 'indeterminate', 'not-entered'], 'live.altered-action-entered') support = self.run('support-bundle', [self.binary, 'support-bundle', '--state-dir', self.work / 'state']) @@ -265,7 +265,7 @@ def exercise(self): (self.args.out / 'support-bundle.json').write_bytes(support) self.stop(); self.start() results['restart-replay'] = json.loads(self.run('restart-replay', self.child('submit'), uid=self.app_uid)) - require(results['restart-replay'].get('code') == 'gateway.attempt.replay', 'live.restart-replay-entered') + require(results['restart-replay'] == results['normal'], 'live.restart-replay-entered') self.stop() return {'schema': 'auths.recipe-qualification-simulation/1', 'simulation': True, 'stable_launch_ready': False, 'family': 'stripe-platform-refund-v1', 'provider': 'live Stripe test mode; platform account', From 31a825d099c7f933f4cd22ea498703a3359d894a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 05:14:15 +0000 Subject: [PATCH 022/136] chore(formal): regenerate qualification artifacts Source-SHA: eb3c31fb86a79ae16f02bf15c94453da6f7f99be Workflow-Run: 40636309645 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 4c292cfec..534df8e38 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "25cbca328f1e7d342069591491bf713c80cfad76f1887f89a47d6a2b88672147", + "digest": "7641cbe2873f3b33fba2772531267878c2eb1e907d74b379e3885559172dd8be", "files": [ { "path": ".cargo/config.toml", @@ -189,7 +189,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/order.rs", - "sha256": "407461608dd2509f06044d38371deb0315fb20a23254534152011eb18ebe2709" + "sha256": "0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07" }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", From 964764f228ecc89370f13ad1e208cdd5aef3d02e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 05:32:37 +0000 Subject: [PATCH 023/136] feat(gateway)!: compile independently authorized recovery reads --- bindings/fixtures/gateway/codes.json | 24 ++ .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 18 +- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/recovery-compilation.json | 175 ++++++++++ compliance.toml | 5 +- ...017-bound-effect-and-recovery-ownership.md | 33 ++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 25 +- docs/plans/0074-implementation-status.md | 40 ++- .../0009-bound-effect-and-recovery.md | 18 + ...ound-effects-and-recovery-state-machine.md | 20 ++ .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6463 -> 6435 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6346 -> 6318 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5621 -> 5600 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4923 -> 4909 bytes .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 49 ++- product/runtime/auths-gateway/src/bounds.rs | 15 + product/runtime/auths-gateway/src/effect.rs | 116 +++++-- .../auths-gateway/src/effect/acquisition.rs | 314 ++++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 293 +++++++++++++++- product/runtime/auths-gateway/src/engine.rs | 136 ++++++-- .../runtime/auths-gateway/src/entry_tests.rs | 31 +- product/runtime/auths-gateway/src/harness.rs | 38 ++- product/runtime/auths-gateway/src/lib.rs | 4 +- .../auths-gateway/src/observed_tests.rs | 55 ++- .../src/pending_vectors/codes.rs | 4 + product/runtime/auths-gateway/src/recipe.rs | 7 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 60 +++- product/runtime/auths-gateway/src/submit.rs | 15 +- .../runtime/auths-gateway/src/transport.rs | 2 +- 38 files changed, 1408 insertions(+), 115 deletions(-) create mode 100644 bindings/fixtures/gateway/recovery-compilation.json create mode 100644 product/runtime/auths-gateway/src/effect/acquisition.rs diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 98cb9ab50..324a3652d 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -104,6 +104,22 @@ "id": "account-scope-unbound" } }, + { + "code": "gateway.acquisition.binding", + "owner": "effect", + "stage": "compile", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.acquisition.unsupported-bounds", + "owner": "effect", + "stage": "compile", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.admin.credential-account", "owner": "admin", @@ -306,6 +322,14 @@ "epic": 6, "case": null }, + { + "code": "gateway.effect.protocol", + "owner": "effect", + "stage": "before-claim", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.idempotency.window-exceeds-retention", "owner": "engine", diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 6637a9ad4..138a91275 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 7b14a9f5c..8a389dfab 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"Uoj3JjEIvCgS6KgjJMH4AJUwriSj7OPkKaJe6YQcGO_oGRqebSbrNv3ZZby3lSA1FXDWFZ7vj73MYn4lIubxCg"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"Ov3dkHEuJbpcM0n6IVlpPnZxBh6Cumb9i5y6r9UrLWjI_T3WG9iNokAX1QgM9KqBIWOj9W5fsukIJ3gU9JTfBw"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 878474684..befddaaae 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -73,7 +73,7 @@ ], "kind": "exact" }, - "compiler": "auths.gateway-effect-compiler/3", + "compiler": "auths.gateway-effect-compiler/4", "configuration": [ 12, 12, @@ -254,13 +254,13 @@ 89 ], "reservations": [], - "schema": "auths.bound-effect/2", + "schema": "auths.bound-effect/3", "scope": { "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -393,17 +393,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/3\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/2\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/2\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/3\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 246,\n 40,\n 160,\n 130,\n 141,\n 190,\n 67,\n 73,\n 36,\n 122,\n 136,\n 120,\n 45,\n 200,\n 112,\n 63,\n 63,\n 208,\n 224,\n 162,\n 81,\n 191,\n 76,\n 102,\n 28,\n 45,\n 211,\n 67,\n 39,\n 95,\n 101,\n 222\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/4\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/4\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 246,\n 40,\n 160,\n 130,\n 141,\n 190,\n 67,\n 73,\n 36,\n 122,\n 136,\n 120,\n 45,\n 200,\n 112,\n 63,\n 63,\n 208,\n 224,\n 162,\n 81,\n 191,\n 76,\n 102,\n 28,\n 45,\n 211,\n 67,\n 39,\n 95,\n 101,\n 222\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "0dfdeb671c6e340d5c47edb4940d5b4a9d335efe2317f05b0b6f5bbc11a0a1f0", + "effect_id_hex": "11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[13,253,235,103,28,110,52,13,92,71,237,180,148,13,91,74,157,51,94,254,35,23,240,91,11,111,91,188,17,160,161,240],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Uoj3JjEIvCgS6KgjJMH4AJUwriSj7OPkKaJe6YQcGO_oGRqebSbrNv3ZZby3lSA1FXDWFZ7vj73MYn4lIubxCg\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Ov3dkHEuJbpcM0n6IVlpPnZxBh6Cumb9i5y6r9UrLWjI_T3WG9iNokAX1QgM9KqBIWOj9W5fsukIJ3gU9JTfBw\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMywyNTMsMjM1LDEwMywyOCwxMTAsNTIsMTMsOTIsNzEsMjM3LDE4MCwxNDgsMTMsOTEsNzQsMTU3LDUxLDk0LDI1NCwzNSwyMywyNDAsOTEsMTEsMTExLDkxLDE4OCwxNywxNjAsMTYxLDI0MF0sImV4cGlyZXNfYXQiOjE3OTAwMDAwMzAsIm5vdF9iZWZvcmUiOjE3OTAwMDAwMDAsInNjaGVtYSI6ImF1dGhzLmV4YWN0LWVmZmVjdC1hcHByb3ZhbC8xIn0sInNpZ25hdHVyZV9iNjQiOiJVb2ozSmpFSXZDZ1M2S2dqSk1INEFKVXdyaVNqN09Qa0thSmU2WVFjR09fb0dScWViU2JyTnYzWlpieTNsU0ExRlhEV0ZaN3ZqNzNNWW40bEl1YnhDZyJ9\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxNywyMjQsNTAsNDYsMTQ3LDEzOCwxMDgsNTAsMTg3LDE2NywyMDEsMTc3LDI0OCwxMjksMjMyLDEzMywxODMsMTI5LDkwLDcsMTI1LDczLDE3NCwxNjUsNjIsMTU1LDQxLDIwNCwxMCwxMzgsNzQsMTU1XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6Ik92M2RrSEV1SmJwY00wbjZJVmxwUG5aeEJoNkN1bWI5aTV5NnI5VXJMV2pJX1QzV0c5aU5va0FYMVFnTTlLcUJJV09qOVc1ZnN1a0lKM2dVOUpUZkJ3In0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index 3899d3308..dcae9958d 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[233,67,145,200,208,36,229,168,205,199,223,16,210,155,139,10,124,154,212,72,237,77,184,74,193,81,246,219,238,68,101,109],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"JK31EZbyaZbt41lSI61WQXgMhhM4xi7BNZdEuJy_dgwLAUVhMNUTyu9YKntacl6kxfCDiAebEg_s73ZiKkkSBw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[18,100,166,66,26,248,30,173,46,176,5,39,157,5,89,253,127,243,22,211,99,66,79,15,9,198,168,38,203,37,123,63],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"JjHflbiq4Kxv0DeawZJZp1Sp2q7ulJtdlzJEP7N6LXnB9TA1E_aFbXO7UTbO8Fz4HijeJahTnw5-kepLzO4-CQ\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "e94391c8d024e5a8cdc7df10d29b8b0a7c9ad448ed4db84ac151f6dbee44656d", + "effect_id": "1264a6421af81ead2eb005279d0559fd7ff316d363424f0f09c6a826cb257b3f", "dependencies": [] } }, @@ -36,11 +36,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248", + "effect_id": "358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json new file mode 100644 index 000000000..184dd5991 --- /dev/null +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -0,0 +1,175 @@ +{ + "schema": "auths.gateway-recovery-compilation-fixture/1", + "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", + "binding_canonical": "{\"action\":[121,145,68,173,211,138,135,161,28,134,183,154,153,10,252,104,92,101,98,60,145,47,130,115,176,30,123,208,183,194,10,4],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[173,193,92,249,69,68,138,168,193,17,66,18,30,227,144,128,57,121,239,156,64,222,81,15,206,162,84,185,69,169,225,163],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[169,149,105,204,149,124,180,181,69,188,18,143,231,47,30,167,20,105,162,250,164,21,156,63,221,152,205,87,62,103,136,40],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[18,197,59,131,150,29,95,219,1,244,51,180,248,206,101,147,201,223,115,150,108,32,39,190,19,184,1,97,1,162,51,236],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[211,194,13,23,52,192,145,185,115,193,195,151,106,137,100,45,79,251,92,184,78,178,191,58,156,157,204,253,139,222,205,122],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "eb552bb84c7d23789c0c93439bbaacdfc2f001835d6c35c08a83819b9754097b", + "authorization_call": { + "arguments": { + "maximum_response_bytes": 16384, + "operation_id": "read-1", + "operator_namespace": "observer-demo", + "read_contract": "a99569cc957cb4b545bc128fe72f1ea71469a2faa4159c3fdd98cd573e678828", + "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", + "source_effect": "c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b", + "source_operation": "source-1" + }, + "name": "auths_gateway_recovery_read_v1", + "profile": "auths.mcp", + "profile_version": 2, + "service": "gateway-observer-test" + }, + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"eb552bb84c7d23789c0c93439bbaacdfc2f001835d6c35c08a83819b9754097b\",\n \"binding_canonical\": \"{\\\"action\\\":[121,145,68,173,211,138,135,161,28,134,183,154,153,10,252,104,92,101,98,60,145,47,130,115,176,30,123,208,183,194,10,4],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/4\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[173,193,92,249,69,68,138,168,193,17,66,18,30,227,144,128,57,121,239,156,64,222,81,15,206,162,84,185,69,169,225,163],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[169,149,105,204,149,124,180,181,69,188,18,143,231,47,30,167,20,105,162,250,164,21,156,63,221,152,205,87,62,103,136,40],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[18,197,59,131,150,29,95,219,1,244,51,180,248,206,101,147,201,223,115,150,108,32,39,190,19,184,1,97,1,162,51,236],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[211,194,13,23,52,192,145,185,115,193,195,151,106,137,100,45,79,251,92,184,78,178,191,58,156,157,204,253,139,222,205,122],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 121,\n 145,\n 68,\n 173,\n 211,\n 138,\n 135,\n 161,\n 28,\n 134,\n 183,\n 154,\n 153,\n 10,\n 252,\n 104,\n 92,\n 101,\n 98,\n 60,\n 145,\n 47,\n 130,\n 115,\n 176,\n 30,\n 123,\n 208,\n 183,\n 194,\n 10,\n 4\n ],\n \"native_authority\": [\n 173,\n 193,\n 92,\n 249,\n 69,\n 68,\n 138,\n 168,\n 193,\n 17,\n 66,\n 18,\n 30,\n 227,\n 144,\n 128,\n 57,\n 121,\n 239,\n 156,\n 64,\n 222,\n 81,\n 15,\n 206,\n 162,\n 84,\n 185,\n 69,\n 169,\n 225,\n 163\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/4\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 18,\n 197,\n 59,\n 131,\n 150,\n 29,\n 95,\n 219,\n 1,\n 244,\n 51,\n 180,\n 248,\n 206,\n 101,\n 147,\n 201,\n 223,\n 115,\n 150,\n 108,\n 32,\n 39,\n 190,\n 19,\n 184,\n 1,\n 97,\n 1,\n 162,\n 51,\n 236\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 211,\n 194,\n 13,\n 23,\n 52,\n 192,\n 145,\n 185,\n 115,\n 193,\n 195,\n 151,\n 106,\n 137,\n 100,\n 45,\n 79,\n 251,\n 92,\n 184,\n 78,\n 178,\n 191,\n 58,\n 156,\n 157,\n 204,\n 253,\n 139,\n 222,\n 205,\n 122\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 169,\n 149,\n 105,\n 204,\n 149,\n 124,\n 180,\n 181,\n 69,\n 188,\n 18,\n 143,\n 231,\n 47,\n 30,\n 167,\n 20,\n 105,\n 162,\n 250,\n 164,\n 21,\n 156,\n 63,\n 221,\n 152,\n 205,\n 87,\n 62,\n 103,\n 136,\n 40\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"799144add38a87a11c86b79a990afc685c65623c912f8273b01e7bd0b7c20a04\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"a99569cc957cb4b545bc128fe72f1ea71469a2faa4159c3fdd98cd573e678828\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "refused_changed_fields": [ + "source_effect", + "source_operation", + "read_contract", + "maximum_response_bytes", + "recipe_digest", + "operator_namespace", + "operation_id", + "recipient" + ], + "original_writer_expired": true, + "separate_reader": true, + "mutation_admission_refused": true, + "source_journal_unchanged": true, + "reserved_mutation_recipe_refused": { + "source": { + "schema": "auths.gateway-recipe-source/3", + "profile_schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_recovery_read_v1", + "operator_namespace": "airtable-demo", + "credential": { + "kind": "bearer" + }, + "origin": "https://api.airtable.com", + "write": { + "method": "PATCH", + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appTEST0000000001" + }, + { + "kind": "fixed", + "value": "tblTEST0000000001" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "body": { + "kind": "json", + "value": { + "kind": "object", + "fields": { + "fields": { + "kind": "object", + "fields": { + "DemoStatus": { + "kind": "field", + "name": "replacement" + } + } + } + } + } + } + }, + "observation": { + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appTEST0000000001" + }, + { + "kind": "fixed", + "value": "tblTEST0000000001" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "json_pointer": "/fields/DemoStatus", + "expected_field": "replacement", + "maximum_response_bytes": 16384 + }, + "echo": { + "write": { + "kind": "json-pointer", + "pointer": "/fields/auths_echo" + }, + "observe": "/fields/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } + } + }, + "profile_lock": { + "command_schema": { + "fields": { + "operation_id": { + "kind": "string", + "maximum": 128, + "minimum": 1 + }, + "operator_namespace": { + "type": "enum", + "variants": [ + "airtable-demo" + ] + }, + "recipe_digest": { + "kind": "string", + "maximum": 64, + "minimum": 64 + }, + "record_id": { + "kind": "string", + "maximum": 43, + "minimum": 17 + }, + "replacement": { + "type": "enum", + "variants": [ + "Approved", + "Pending" + ] + } + }, + "kind": "object" + }, + "generator_format": 2, + "profile": "airtable-gateway-record-update", + "schema": "auths.self-hosted-profile-lock/1", + "schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_recovery_read_v1", + "version": 1 + } + } +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index bd56c8488..8f905a351 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/2", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +recovery-compilation = [ + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", +] effect-replay = [ "product/runtime/auths-gateway/src/scenario_tests.rs#native_replay_projection_fixture_is_current", "bindings/python/tests/test_gateway_client.py#test_native_replay_projection_corpus", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 20b726b66..3db79c24b 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -323,3 +323,36 @@ The old explicit operator observation mechanics remain temporarily reachable only on the operator surface. They are not the final AP074 recovery contract: that direct path, automatic post-write observations and all ancillary reads must be replaced by independently authorized bounded acquisitions before completion. + + +## Independently authorized recovery compilation + +Bound-effect `/3` and compiler `/4` retain one shared identity and exact approval +owner, with sealed mutation/acquisition compiler alternatives. The source +journal supplies protected request/locator provenance; the new native read proof +supplies current authority. The read contract pins the exact GET, source binding, +observation projection, echo and finite bounds. Mutation recipes cannot use the +reserved read tool name, and mutation admission refuses a sealed acquisition. +Neither decoded source data nor compilation can mint a transport permit. + +Source-lifetime reservations bind acquisition count and maximum response bytes +separately. Their keys include the immutable source effect and unit, excluding +the new read operation so new IDs cannot reset the declared capacity. The native +contract allows at most 16 attempts, at most 65,536 response bytes per attempt, +15 seconds per transport, and 30 seconds of evidence age. Entry accounting and +evidence freshness enforcement remain pending; a declaration is not evidence +that those boundaries have been executed. + +The first compiler requires the same source connection commitment and credential +generation. Rotation or a narrower replacement credential currently refuses +compilation; safe replacement recovery still needs its own reviewed contract. +Managed bounded-policy extensions also fail closed until acquisition accounting +can enforce them. These are incomplete implementation boundaries, not permission +to drop the full acquisition/recovery requirements of AP074. + +The installed operator can author the private native read call and compile it +for review using the same deployment clock, current configuration, and connection +checks as mutation compilation. The literal renderer and signing-request path +remain shared. No new provider endpoint or read execution is introduced by this +checkpoint; direct operator re-observation and ancillary reads still require +the acquisition admission/entry cutover before completion. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 07d5cac92..596e691e9 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -56,11 +56,26 @@ Keep review/request/approval files on the authorized private channel. The checks the installed signer, effect binding and validity interval. Missing, obsolete or invalid approvals are refused before credential leasing. -AP074 remains under implementation: versioned semantic review completeness, -transactional entry fencing, durable full-binding comparison and controlled -recovery are not established by these commands. The existing example journeys -still need the complete operator review round trip and updated integration -evidence before they demonstrate the revised contract. +For an independently authorized recovery read, first obtain the native private +call from an observable retained source, then authorize that exact call through +the native MCP authoring flow. Use a new logical operation ID for the read: + +```text +auths-gateway effect-recovery-call --state-dir \ + --source-operation --recovery-operation +auths-gateway effect-review --state-dir --recovery-of \ + --proof read-proof.cbor --action read-action.cbor --not-before \ + --expires-at --request-out +``` + +These are private authoring/review operations. They perform no credential lease, +provider call or admission. The writer's proof or exact approval cannot serve as +the read's authority. Source and current connection/generation must match in this +compiler; changed credentials and managed read-policy bounds currently refuse. +A compiled read cannot be sent through mutation `submit`. Recovery execution and +accounting remain under implementation, so these commands are not a completed +recovery journey. Installed authenticated review, frontend, and full concurrency/ +fault evidence also remain open AP074 requirements. A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 44f5acc61..6ae90a48a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -375,6 +375,42 @@ closure regeneration passed after that correction (one artifact-generation test) translated formal artifacts and hosted CI are not yet executed. No AP073 work or delegation occurred. +## Independent recovery compilation checkpoint + +- Bound-effect `/3` and compiler `/4` use one sealed mutation/acquisition sum, + one native verifier, one exact approval and one complete private renderer. + Fixed-window mutation reservations remain fixed; source-lifetime read + reservations declare separate attempt-count and response-byte obligations. +- A protected observable journal record supplies the source identity, exact GET, + response-derived locator when available, projection and echo. The new native + read call binds that contract and a distinct read operation. Fresh reader + authority is independent of the source writer. Mutation recipes cannot claim + the reserved native recovery-read tool, and mutation admission rejects reads. +- Installed `effect-recovery-call` authors the private native call; + `effect-review --recovery-of` compiles its independently signed proof using + current installed configuration, connection and deployment time. Both are + effect-free: no credential lease, provider read, reservation or journal update. +- Required `native_recovery_acquisition_fixture_is_current` generation passed: + real signed native proofs and file-derived source target; expired writer, + distinct reader, exact read review/approval, approval expiry/substitution, + changed source/contract/limit/namespace/operation refusal, reserved mutation + tool refusal, mutation-admission refusal and unchanged source journal. The + source grant uses a synthetic oracle and performs no provider send. This is + compilation evidence, not installed recovery execution or A15 closure. +- Mutation binding, entry, attempt-scenario and stable-code native artifact + generators passed. Native CLI approval-envelope construction passed and + matched the regenerated signed corpus exactly. These runs used `eb3c31fb` + plus this compiler source; remote artifact commit `31a825d0` was inspected and + preserved by fast-forward. After the final boxed protocol representation, + recovery compilation and `semantic_closure::tests::semantic_closure_is_current` + generation both passed on `31a825d0` plus this source (one generator each). +- Acquisition admission, conserved charging, fenced entry, evidence freshness + and transport remain unwired. The compiler currently refuses changed source + connection/generation and managed bounded-policy extensions; safe credential + replacement and enforcement of read-policy bounds are still required work. + Existing direct operator re-observation and all ancillary reads still need + replacement. No full acceptance gate, broad local suite or hosted CI is claimed. + ## Phase gates | Phase | State | Outstanding gate | @@ -382,7 +418,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Mutation grant and reservation restart wired | Public projections, independent recovery, installed fault/race evidence and formal links | -| P3 | Pending | Native acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery compilation started | Acquisition admission/entry, disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -407,7 +443,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | | A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | -| A15 | Recovery actor differs; original authority revoked | Pending / no / no | Separate recovery authority | +| A15 | Recovery actor differs; original authority revoked | Partial / native compiler fixture / compilation only | Bounded recovery entry, revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index cdfc6bcd4..6502818af 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -178,3 +178,21 @@ reread, exact external counters and malformed reservation projections. It is narrow mechanism evidence; installed authority and PostgreSQL fault evidence remain open. Existing explicit operator observation tests retain their original scope and are not evidence of independent AP074 recovery authorization. + + +## Recovery compiler checkpoint + +The native recovery compiler reuses the verified-action, canonical binding, +exact approval and complete literal-review owners. It does not reuse mutation +authority or its request type. A protected journal target supplies the source +identity and closed observation GET; a distinct native reader authorizes that +exact target and its count/byte/time limits. The reserved native read tool cannot +be installed as a mutation recipe. + +`recovery-compilation.json` is generated from signed native proofs and an actual +file-backed source record. It covers an expired original writer, a different +reader, exact read approval, source/contract/limit substitution refusal and no +source mutation. Its source entry uses a test oracle and sends no provider +request. It proves compilation only: conserved acquisition charging, fresh +transactional read entry, credential replacement, installed review channels and +bounded observation execution remain open evidence gates. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index ee7cfa248..c74c28926 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -142,6 +142,15 @@ Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. +The concrete native encoding is `auths.bound-effect/3`, with effect compiler +`auths.gateway-effect-compiler/4`. Reservations use a closed window alternative: +fixed epoch-aligned windows or the retained source effect's lifetime. Mutation +count/sum reservations retain fixed windows; recovery acquisitions declare +separate acquisition-count and response-byte charges against one source. A +source-lifetime bound must survive operation-ID changes, replay and restart. +An encoded bound declares an obligation; only the journal's atomic admission +and entry transitions can discharge it. Decoding never grants authority. + The replay key MUST NOT include the action/effect digest as its only differentiator: the same logical operation ID with changed binding is a conflict, not a fresh operation. Exact replays return existing state; they never mint another capability. A newly chosen operation ID cannot evade a signed approval's binding or the shared budget. ### 4.2 Compilation and approval without circular commitments @@ -204,6 +213,17 @@ the approved recipe. Account for their entry and limits explicitly; they must no be invisible I/O outside the model. Acquiring those bytes does not authorize disclosing them to the agent. +Independent recovery compilation uses the reserved native MCP tool +`auths_gateway_recovery_read_v1`; a mutation recipe cannot claim that name. +Its `auths.gateway-recovery-read/1` contract binds the retained source effect +and operation, exact GET and response limit, observation projection/expected +value and echo, count/time/freshness limits, and the absence of content +release. The read requires its own current native proof and exact approval; +the source writer's proof and historical approval are provenance only. The +same native binding, review renderer and approval machinery serve both types. +This compilation contract does not itself implement read admission, an entry +permit, observation evidence or disclosure. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index c87a6df54..e1ba42735 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 47f07248a..cacf47688 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 02a128e1c..b69ead6cc 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index eba346a31..3a5d7bfea 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index b121d4b8c..2380f476c 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/3\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/2\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[132,251,192,91,22,185,251,234,149,221,81,44,241,230,33,70,100,200,193,79,2,252,187,108,174,249,184,143,206,119,114,72],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Mjt3bsOclvr1ktolGW3UlJKWUTCwCHk2VWnrXN5bQ475qPJPXpG6YTrZ57UjLuSzwLCYNdUZGoEr8yRxWCY7CA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"84fbc05b16b9fbea95dd512cf1e6214664c8c14f02fcbb6caef9b88fce777248","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 3e125bb77c7ab60229c72502ae855e6d4cdacf35..925fa2558178a04071289be3404f92183595c893 100644 GIT binary patch delta 1009 zcmeH^u}T9$5QcLm5C~eR5Ibv&DRy>tZ+8*IghUBSE(bYCLD~bJ6#+^6I9`HGUu^KM)z0Iym#Gc51xXXZhw}smdTRv(T<0%pS6Z9 z;VvFh-V4LF6+vdrr6WHvcafTQisQpmFaN6lY>lJ*rFnZ!QWHt!BH@bSn3eeQHw)3C%-?Z~pqgf1&KD}S+jR$7{ delta 1078 zcmeH_KTZNs5XN0VO^7zcNJn8|HO0=nxBK2|W3nm+5m8zB6D)YkZXyuC6$Nd)fz6hd zo`CEDyoQNK@De^efCo^EDZX!h-z1ZKuk=QlrKPoSo_RJ5mVBo^!w<&HpWG}S&Leh@OtIDi^pl%ZC1Kot2jD{AP0#EVef8p5M#tb$Wz!{=R*jR zx3IGJF|4fglF~;A7Q_57^9}s-zvC-5YPJ3GTjMzhc>R6QtOryEho4JDfP}DV26PBy zL0P~`p;CYnP=p{65Cur$s&u6_NUla~K?>SnXu&e*iqHfy1hZX6X|~r516K%f86T~Z z>0~({jPpF|ba9wWQOB$4LZ+OJ@2`?Y@46EWp9VMG{=5)vTV(O0n~Z$FXph?LFCKE) zi{r@gpm6rmQ<&MiM9(_wljF0X{A&K}jH8lUx96k`kwVFt)Rd;erXmX+s?dAqbFF65 ms;qh)lJcCo9Gx)U8DU7VoO!qYXr0z~HgVqjPy0{WFTpSDhy@@3 delta 1078 zcmeH_KTZNc6vkO4+F)ad_SUc1H-C0!wJ}*0gNUfC3j_;h*hvHexT2tqH?Y}G?_fgq z7GA+4cmg{IFJP}0ulTG!^u&NkY+k{P94uFzAy zQE|uT-7ZI>4aOcp=6Os@jm)^jXr(;eiH)zMG&&YS5GJ$Y=ChNv3xBB;J5IV+{QNJ* H&&Bux--9By diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 6f9809e0cc38c2631c76f6cb62e0e20acd4b7abc..176c47a9e7af52211061c145fd5a95a0322f5e32 100644 GIT binary patch delta 781 zcmd^-ze)o^5XN(ODqt#`s?$l{VHk*XdJ8 z8ap4v#+R@Ybd$%>V)#Co`3-!`d{sUxeyOzb`077-9-nTmE-!ejc=10T1OsFUGf^M| zU>bx5bPk08q<|y*;qBb$Jlhjv>VPN<9dk1sV@n-VOC3WX z%h1$R$IwW}(7;T`$WX`7&_Kt?*aV2pfoyXfBNL#MiKUK_fiXy%p{0(ciH, #[arg(long)] proof: PathBuf, #[arg(long)] @@ -199,6 +202,16 @@ mod unix { #[arg(long)] request_out: PathBuf, }, + /// Author the exact private call for an independently authorized + /// recovery read. No proof, approval, reservation or entry is created. + EffectRecoveryCall { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + source_operation: String, + #[arg(long)] + recovery_operation: String, + }, /// Attach an external reviewer's Ed25519 signature to native signing /// data. Submission still verifies installed trust, binding and time. EffectApproval { @@ -2975,6 +2988,7 @@ mod unix { #[allow(clippy::too_many_arguments)] async fn effect_review( state_dir: PathBuf, + recovery_of: Option, proof: PathBuf, action: PathBuf, not_before: u64, @@ -2990,10 +3004,15 @@ mod unix { .map_err(|_| "gateway.effect.unavailable")??; let proof = read_bounded(&proof, 4 * 1024 * 1024)?; let action = read_bounded(&action, 64 * 1024)?; - let effect = engine - .compile_effect(&proof, &action) - .await - .map_err(|_| "gateway.effect.review-refused")?; + let effect = match recovery_of { + Some(source) => { + engine + .compile_recovery_effect(&source, &proof, &action) + .await + } + None => engine.compile_effect(&proof, &action).await, + } + .map_err(|_| "gateway.effect.review-refused")?; let request = effect .approval_request(not_before, expires_at) .map_err(|_| "gateway.effect.approval")?; @@ -3758,6 +3777,7 @@ mod unix { } Command::EffectReview { state_dir, + recovery_of, proof, action, not_before, @@ -3766,6 +3786,7 @@ mod unix { } => { effect_review( state_dir, + recovery_of, proof, action, not_before, @@ -3774,6 +3795,26 @@ mod unix { ) .await } + Command::EffectRecoveryCall { + state_dir, + source_operation, + recovery_operation, + } => { + private_root(&state_dir)?; + let engine = tokio::task::spawn_blocking(move || load_engine(&state_dir)) + .await + .map_err(|_| "gateway.effect.unavailable")??; + let call = engine + .recovery_authorization_call(&source_operation, &recovery_operation) + .await + .map_err(|_| "gateway.acquisition.binding")?; + let bytes = Zeroizing::new(call.canonical_bytes().map_err(|_| "gateway.output")?); + std::io::stdout() + .write_all(&bytes) + .and_then(|()| std::io::stdout().flush()) + .map_err(|_| "gateway.output")?; + Ok(()) + } Command::EffectApproval { request, signature_hex, diff --git a/product/runtime/auths-gateway/src/bounds.rs b/product/runtime/auths-gateway/src/bounds.rs index 2f4a4feba..6c8e49e2e 100644 --- a/product/runtime/auths-gateway/src/bounds.rs +++ b/product/runtime/auths-gateway/src/bounds.rs @@ -694,6 +694,21 @@ pub(crate) fn link_policy( } } +/// Until acquisition counters consume bounded-policy commitments, reject them +/// explicitly. Native authorization must never silently drop a managed charge. +pub(crate) fn refuse_unaccounted_acquisition_bounds( + proof_cbor: &[u8], + verified: &VerifiedAction, +) -> Result<(), &'static str> { + if authorized_chains(proof_cbor, verified)? + .iter() + .any(|branch| branch.chain.iter().any(carries_bound)) + { + return Err("gateway.acquisition.unsupported-bounds"); + } + Ok(()) +} + /// Admits the verified action under every link of its bounded branch and /// derives the counters to reserve, or refuses it before any claim. An /// empty chain is unbounded, which a recipe that declares `bounds.sum` diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 7cd664314..8f7f4462a 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -18,13 +18,17 @@ use serde::{Deserialize, Serialize}; use std::fmt; use zeroize::Zeroizing; +mod acquisition; +pub(crate) use acquisition::RECOVERY_READ_TOOL; +pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; + /// Only accepted effect binding schema. Old disposable state is rejected. -pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/2"; +pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/3"; /// Maximum private canonical binding or compiler projection bytes. pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/3"; +const COMPILER: &str = "auths.gateway-effect-compiler/4"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -219,7 +223,7 @@ pub(crate) fn approve_driver_fixture( let effect = BoundEffect { review: serde_json::json!({"scope": "synthetic post-verification oracle; no human review claim"}), binding, - command, + command: CompiledEffect::Mutation(Box::new(command)), connection, proof: Zeroizing::new(Vec::new()), action: Zeroizing::new(Vec::new()), @@ -358,8 +362,14 @@ struct Reservation { unit: Unit, amount: u64, ceiling: u64, - window_index: u64, - window_seconds: u64, + window: ReservationWindow, +} + +#[derive(Clone, Copy, Deserialize, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum ReservationWindow { + Fixed { index: u64, seconds: u64 }, + SourceLifetime, } #[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] @@ -541,8 +551,14 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { || reservation.ceiling == 0 || reservation.amount > reservation.ceiling || reservation.ceiling > MAX_SAFE_INTEGER - || reservation.window_index > MAX_SAFE_INTEGER - || !(1..=crate::MAX_WINDOW_SECONDS).contains(&reservation.window_seconds) + || match reservation.window { + ReservationWindow::Fixed { index, seconds } => { + index > MAX_SAFE_INTEGER || !(1..=crate::MAX_WINDOW_SECONDS).contains(&seconds) + } + ReservationWindow::SourceLifetime => { + matches!(wire.protocol, Protocol::Mutation { .. }) + } + } { return Err(EffectBindingError::Invalid); } @@ -589,13 +605,20 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { Ok(()) } +/// Closed protocol-specific compiler output. Neither alternative is transport +/// authority, and a mutation-only admission path must refuse an acquisition. +enum CompiledEffect { + Mutation(Box), + Acquisition(Box), +} + /// Sealed native compilation result. It owns both the private binding and the /// exact immutable compiler output. There is no public constructor, clone or /// deserializer. Compiling this value does not approve it or grant entry. pub struct BoundEffect { review: serde_json::Value, binding: EffectBinding, - command: VerifiedCommand, + command: CompiledEffect, connection: ConnectionRecord, proof: Zeroizing>, action: Zeroizing>, @@ -612,7 +635,7 @@ pub struct PrivateEffectReview { binding_canonical: String, binding: BindingWire, installation: serde_json::Value, - native: crate::GatewaySubmissionReview, + native: serde_json::Value, semantic: serde_json::Value, renderer: &'static str, } @@ -687,11 +710,15 @@ impl BoundEffect { &self.binding } - /// Returns the exact noncredential request for an authorized private - /// review. This can contain private content and must not be logged. + /// Returns the exact noncredential mutation request for private review, + /// or `None` for acquisition. This may contain private content; do not log it. + /// Use the shared private review to render either protocol completely. #[must_use] - pub const fn private_request(&self) -> &ClosedProviderRequest { - &self.command.request + pub fn private_request(&self) -> Option<&ClosedProviderRequest> { + match &self.command { + CompiledEffect::Mutation(command) => Some(&command.request), + CompiledEffect::Acquisition(_) => None, + } } /// Renders the exact immutable effect reviewed before human approval. @@ -722,7 +749,13 @@ impl BoundEffect { semantic: self.review.clone(), effect_id_hex: hex::encode(self.binding.id().as_bytes()), binding_canonical, - native: crate::engine::review_command(&self.command)?, + native: match &self.command { + CompiledEffect::Mutation(command) => { + serde_json::to_value(crate::engine::review_command(command)?) + .map_err(|_| not_entered("gateway.effect.invalid-binding"))? + } + CompiledEffect::Acquisition(command) => command.private_review(), + }, }) } @@ -948,8 +981,11 @@ impl ApprovedEffect { pub(crate) fn approval(&self) -> &ExactEffectApproval { &self.approval } - pub(crate) fn command(&self) -> &VerifiedCommand { - &self.effect.command + pub(crate) fn command(&self) -> Option<&VerifiedCommand> { + match &self.effect.command { + CompiledEffect::Mutation(command) => Some(command), + CompiledEffect::Acquisition(_) => None, + } } pub(crate) fn connection(&self) -> &ConnectionRecord { @@ -991,8 +1027,18 @@ impl ApprovedEffect { ) -> Result<(), GatewaySubmitResult> { self.validate_approval(&installed.approver, now) .map_err(|_| not_entered("gateway.effect.approval"))?; - let fresh = - compile_mutation_effect(installed, now, &self.effect.proof, &self.effect.action)?; + let fresh = match &self.effect.command { + CompiledEffect::Mutation(_) => { + compile_mutation_effect(installed, now, &self.effect.proof, &self.effect.action)? + } + CompiledEffect::Acquisition(command) => compile_recovery_acquisition( + installed, + &command.target, + now, + &self.effect.proof, + &self.effect.action, + )?, + }; if fresh.binding != self.effect.binding { return Err(not_entered("gateway.effect.binding-changed")); } @@ -1056,8 +1102,10 @@ fn bind_mutation( unit: Unit::MutationCount, amount: 1, ceiling: count.capacity, - window_index: bound.window_index, - window_seconds: bound.window_seconds, + window: ReservationWindow::Fixed { + index: bound.window_index, + seconds: bound.window_seconds, + }, }); } for sum in &bound.sums { @@ -1066,8 +1114,10 @@ fn bind_mutation( unit: Unit::MutationSum, amount: bound.argument, ceiling: sum.capacity, - window_index: bound.window_index, - window_seconds: bound.window_seconds, + window: ReservationWindow::Fixed { + index: bound.window_index, + seconds: bound.window_seconds, + }, }); } } @@ -1109,7 +1159,7 @@ fn bind_mutation( let effect = BoundEffect { review, binding, - command, + command: CompiledEffect::Mutation(Box::new(command)), connection: installed.connection.clone(), proof: Zeroizing::new(proof.to_vec()), action: Zeroizing::new(action.to_vec()), @@ -1283,8 +1333,10 @@ mod tests { unit: Unit::MutationCount, amount: 1, ceiling: 2, - window_index: 0, - window_seconds: 60, + window: ReservationWindow::Fixed { + index: 0, + seconds: 60, + }, }], protocol: Protocol::Mutation { request: [6; 32] }, } @@ -1356,8 +1408,18 @@ mod tests { 6 => changed.qualification_policy = "optional".to_owned(), 7 => changed.reservations[0].key[0] ^= 1, 8 => changed.reservations[0].ceiling += 1, - 9 => changed.reservations[0].window_index += 1, - 10 => changed.reservations[0].window_seconds += 1, + 9 => { + changed.reservations[0].window = ReservationWindow::Fixed { + index: 1, + seconds: 60, + } + } + 10 => { + changed.reservations[0].window = ReservationWindow::Fixed { + index: 0, + seconds: 61, + } + } 11 => changed.protocol = Protocol::Mutation { request: [8; 32] }, 12 => changed.configuration[0] ^= 1, _ => { diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs new file mode 100644 index 000000000..3b8f4a868 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -0,0 +1,314 @@ +//! Independently verified compilation of a bounded recovery acquisition. +//! This constructs the shared bound effect, not an entry permit. The journal +//! must later account and fence the acquisition separately from its source. + +use super::*; +use auths_profile_api::ActionProfile as _; +use auths_profile_mcp::{McpProfile, McpToolCall}; +#[cfg(unix)] +use serde_json::Map; +use serde_json::{Value, json}; + +/// Reserved native read-only operation; a mutation tool is never accepted here. +pub const RECOVERY_READ_TOOL: &str = "auths_gateway_recovery_read_v1"; +/// Total observation entries permitted for one retained source effect. +pub const MAX_RECOVERY_ATTEMPTS: u64 = 16; +/// The bound evidence freshness contract; signed times are not refreshed. +pub const MAX_RECOVERY_EVIDENCE_AGE_SECONDS: u64 = 30; + +/// Protected, closed target loaded from a validated original journal record. +/// There is no public constructor or deserializer. This is provenance data, +/// not the writer's authority and not permission to lease or contact a provider. +#[derive(Clone)] +pub struct RecoveryReadTarget { + source: EffectBinding, + request: crate::ClosedObservationRequest, + echo: Option, +} + +impl fmt::Debug for RecoveryReadTarget { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("RecoveryReadTarget { private: [redacted] }") + } +} + +impl RecoveryReadTarget { + pub(crate) fn from_journal( + source: EffectBinding, + request: crate::ClosedObservationRequest, + echo: Option, + ) -> Result { + if !matches!(source.wire.protocol, Protocol::Mutation { .. }) + || source.wire.scope != Scope::Unscoped + || !(1..=65_536).contains(&request.maximum_response_bytes()) + { + return Err(EffectBindingError::Invalid); + } + let target = Self { + source, + request, + echo, + }; + canonical(&target.contract())?; + Ok(target) + } + + fn read_wire(&self) -> ReadWire<'_> { + ReadWire { + url: self.request.url(), + headers: self + .request + .headers() + .iter() + .map(|header| (header.name(), header.value())) + .collect(), + maximum_response_bytes: self.request.maximum_response_bytes(), + } + } + + fn contract(&self) -> Value { + json!({ + "schema": "auths.gateway-recovery-read/1", + "source_effect": hex::encode(self.source.id().as_bytes()), + "source_operation": self.source.wire.operation, + "request": self.read_wire(), + "json_pointer": self.request.json_pointer(), + "expected": self.request.expected(), + "echo_pointer": self.request.echo_pointer(), + "echo": self.echo, + "maximum_attempts": MAX_RECOVERY_ATTEMPTS, + "maximum_transport_seconds": 15, + "maximum_evidence_age_seconds": MAX_RECOVERY_EVIDENCE_AGE_SECONDS, + "disclosure": "none", + }) + } + + fn binding( + &self, + installed: &EffectInstallation<'_>, + operation: &LogicalOperationId, + action_commitment: [u8; 32], + native_authority: [u8; 32], + ) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + let connection = Zeroizing::new( + installed + .connection + .to_canonical_cbor() + .map_err(|_| invalid())?, + ); + let connection_commitment = + commitment("auths.effect-installation/1", &connection).map_err(|_| invalid())?; + if self.source.wire.connection != connection_commitment + || self.source.wire.credential_generation + != installed.connection.credential_generation().get() + { + return Err(invalid()); + } + let maximum = + u64::try_from(self.request.maximum_response_bytes()).map_err(|_| invalid())?; + let reservations = [ + (Unit::AcquisitionCount, 1, MAX_RECOVERY_ATTEMPTS), + ( + Unit::ResponseBytes, + maximum, + MAX_RECOVERY_ATTEMPTS * maximum, + ), + ] + .into_iter() + .map(|(unit, amount, ceiling)| { + Ok(Reservation { + key: commitment( + "auths.recovery-capacity/1", + &canonical(&(self.source.id().as_bytes(), unit))?, + )?, + unit, + amount, + ceiling, + window: ReservationWindow::SourceLifetime, + }) + }) + .collect::, EffectBindingError>>() + .map_err(|_| invalid())?; + let mut reservations = reservations; + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + let contract = self.contract(); + EffectBinding::new(BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: installed.recipe.namespace().as_str().to_owned(), + partition: installed.partition.to_owned(), + epoch: installed.epoch, + operation: operation.as_str().to_owned(), + action: action_commitment, + native_authority, + scope: Scope::Unscoped, + recipe: *installed.recipe.digest(), + compiler: COMPILER.to_owned(), + connection: connection_commitment, + credential_generation: installed.connection.credential_generation().get(), + qualification_policy: installed.qualification.as_str().to_owned(), + configuration: installed.configuration, + approval_policy: ApprovalPolicy::Exact { + approver: installed.approver, + }, + reservations, + protocol: Protocol::Acquisition { + request: commitment( + "auths.effect-acquisition-request/1", + &canonical(&self.read_wire()).map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?, + projection: commitment( + "auths.gateway-recovery-read/1", + &canonical(&contract).map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?, + maximum_response_bytes: maximum, + }, + }) + .map_err(|_| invalid()) + } + + /// Exact private MCP call for separate read authority. It binds the source, + /// closed request and response limits; callers must authorize it natively. + /// The output must stay on the private authoring/review channel. + /// + /// # Errors + /// Refuses a different recipe, reused source operation, or invalid encoding. + pub fn authorization_call( + &self, + recipe: &CompiledRecipe, + operation: &LogicalOperationId, + ) -> Result { + if self.source.wire.recipe != *recipe.digest() + || self.source.wire.namespace != recipe.namespace().as_str() + || operation.as_str() == self.source.wire.operation + { + return Err(EffectBindingError::Invalid); + } + let contract = commitment( + "auths.gateway-recovery-read/1", + &canonical(&self.contract())?, + )?; + let arguments = json!({ + "operation_id": operation.as_str(), + "operator_namespace": recipe.namespace().as_str(), + "recipe_digest": recipe.digest_hex(), + "source_effect": hex::encode(self.source.id().as_bytes()), + "source_operation": self.source.wire.operation, + "read_contract": hex::encode(contract), + "maximum_response_bytes": self.request.maximum_response_bytes(), + }) + .as_object() + .cloned() + .ok_or(EffectBindingError::Invalid)?; + McpToolCall::new(recipe.service(), RECOVERY_READ_TOOL, arguments) + .map_err(|_| EffectBindingError::Invalid) + } +} + +pub(super) struct VerifiedAcquisition { + pub(super) target: RecoveryReadTarget, + #[cfg(unix)] + actors: Vec, + #[cfg(unix)] + action_commitment: [u8; 32], + #[cfg(unix)] + arguments: Map, +} + +impl VerifiedAcquisition { + #[cfg(unix)] + pub(super) fn private_review(&self) -> Value { + json!({ + "protocol": "acquisition", + "actors": self.actors.iter().map(auths_model::PrincipalId::as_str).collect::>(), + "action_commitment": hex::encode(self.action_commitment), + "arguments": self.arguments, + "method": "GET", + "recovery": self.target.contract(), + }) + } +} + +/// Verifies fresh read-only native authority independently of the source writer +/// and produces the same bound-effect/approval model used for mutations. +/// Performs no custody, admission or provider I/O. Acquisition grant wiring is +/// separate; a mutation claim explicitly refuses this protocol. +/// +/// # Errors +/// Refuses invalid native proof, another tool/source/limit, unaccounted managed +/// bounds, observer overlap, unsupported scope, or changed installation. +pub fn compile_recovery_acquisition( + installed: &EffectInstallation<'_>, + target: &RecoveryReadTarget, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) + .map_err(|_| invalid())?; + if target.source.wire.partition != installed.partition + || target.source.wire.epoch != installed.epoch + { + return Err(invalid()); + } + let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; + let verified = sealed.action().ok_or_else(invalid)?; + let command = McpProfile + .decode_verified(verified) + .map_err(|_| invalid())?; + let operation = command + .arguments() + .get("operation_id") + .and_then(Value::as_str) + .and_then(|value| LogicalOperationId::parse(value).ok()) + .ok_or_else(invalid)?; + let expected = target + .authorization_call(installed.recipe, &operation) + .map_err(|_| invalid())?; + // Comparing the canonical call also rejects extra fields and channel-binding + // representations this unscoped protocol does not yet support. + if command.call() != &expected { + return Err(invalid()); + } + crate::bounds::refuse_unaccounted_acquisition_bounds(proof, verified).map_err(not_entered)?; + crate::separation::check_proof_observers(proof, verified).map_err(not_entered)?; + #[cfg(unix)] + let branches = crate::bounds::authorized_branches(proof, verified).map_err(not_entered)?; + let canonical_action = + auths_codec::encode_canonical_action(verified.canonical_action()).map_err(|_| invalid())?; + let action_commitment = + commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; + let binding = target.binding( + installed, + &operation, + action_commitment, + native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?, + )?; + let contract = target.contract(); + let effect = BoundEffect { + review: json!({"contract": "auths.gateway-recovery-read/1", "recovery": contract, + "consequences": "Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor."}), + binding, + command: CompiledEffect::Acquisition(Box::new(VerifiedAcquisition { + target: target.clone(), + #[cfg(unix)] + actors: branches.actors, + #[cfg(unix)] + action_commitment, + #[cfg(unix)] + arguments: command.arguments().clone(), + })), + connection: installed.connection.clone(), + proof: Zeroizing::new(proof.to_vec()), + action: Zeroizing::new(action.to_vec()), + }; + #[cfg(unix)] + effect + .private_review()? + .to_private_bytes() + .map_err(|_| invalid())?; + Ok(effect) +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index f4aeeba7b..3591a44ca 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -9,6 +9,272 @@ use auths_connections::{ }; use ed25519_dalek::{Signer as _, SigningKey}; +/// Native read authority is independent of an expired source writer. File +/// provenance is real; the source entry is a test grant with no provider send. +#[tokio::test] +#[allow( + clippy::too_many_lines, + reason = "one native compilation corpus and its negative cases" +)] +async fn native_recovery_acquisition_fixture_is_current() { + use crate::effect::compile_recovery_acquisition; + use std::sync::Arc; + // A recipe with the native read name could otherwise turn a read proof + // into a mutation. Both source and profile lock must be refused together. + let mut reserved_source: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/airtable/recipe.json" + )) + .expect("recipe source"); + let mut reserved_lock: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/airtable/profile.lock.json" + )) + .expect("profile lock"); + reserved_source["tool"] = json!(crate::effect::RECOVERY_READ_TOOL); + reserved_lock["tool"] = json!(crate::effect::RECOVERY_READ_TOOL); + assert_eq!( + CompiledRecipe::compile( + &serde_json::to_vec(&reserved_source).expect("recipe"), + &serde_json::to_vec(&reserved_lock).expect("lock"), + ) + .expect_err("reserved acquisition tool") + .code(), + "gateway.recipe.invalid-source", + ); + let root = signer(h::ROOT_SEED); + let writer = signer(0x22); + let reader = signer(0x33); + let observer = signer(h::OBSERVER_SEED); + let recipe = recipe(&json!({}), &Value::Null); + let writer_context = context(&root, &observer.principal, None); + let connection = connection(&recipe); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = EffectPolicy::new("recovery-fixture".to_owned(), 1, public).expect("policy"); + let installed = policy.installation( + &recipe, + &writer_context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let args = json!({"operation_id": "source-1", "operator_namespace": NAMESPACE, + "recipe_digest": recipe.digest_hex(), "record_id": RECORD, "replacement": "Approved"}); + let writer_grant = + h::grant_within(&root, &writer.principal, None, window(NOW - 10, NOW + 1)).expect("grant"); + let original = submission_for_call_during( + &root, + &writer, + &writer_grant, + &call(args.as_object().expect("args")), + &[], + window(NOW, NOW + 1), + ); + let source = compile_mutation_effect(&installed, NOW, &original.proof, &original.action) + .expect("source"); + let request = source.approval_request(NOW, NOW + 30).expect("approval"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let original_approval = request.with_signature(signature); + let source = Arc::new( + source + .approve(original_approval.clone(), &public, NOW) + .expect("approved source"), + ); + let directory = tempfile::tempdir().expect("directory"); + let root_path = std::fs::canonicalize(directory.path()) + .expect("canonical") + .join("journal"); + let store = Arc::new(crate::FileGatewayAttemptStore::open(&root_path).expect("file journal")); + let attempts = crate::GatewayAttempts::new(store, policy.clone()).expect("attempts"); + let crate::store::BoundedClaim::Claimed(claim) = + attempts.claim_bounded(&source, NOW).await.expect("claim") + else { + panic!("expected source claim"); + }; + let (_, permit) = claim + .grant_entry( + source.clone(), + crate::entry::EntryValidation::Oracle { now: NOW }, + NOW, + &crate::GatewayPreEntry::default(), + ) + .await + .expect("source grant fixture"); + drop(permit); + let operation = LogicalOperationId::parse("source-1").expect("operation"); + let target = attempts + .resume_observable_operation(recipe.namespace(), &operation, *recipe.digest()) + .await + .expect("lookup") + .expect("source") + .recovery_target() + .expect("native target"); + let before = attempts + .read(recipe.namespace(), &operation) + .await + .expect("read") + .expect("source"); + let read_call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse("read-1").expect("read operation"), + ) + .expect("read authorization call"); + let read_context = + h::context_for_tool(&root, &observer.principal, NOW, &read_call).expect("read trust"); + let read_grant = h::grant_for_tool( + &root, + &reader.principal, + None, + window(NOW - 3_600, NOW + 3_600), + &read_call, + ) + .expect("read grant"); + let read = submission_for_call(&root, &reader, &read_grant, &read_call, &[]); + let read_installation = policy.installation( + &recipe, + &read_context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + assert!( + compile_mutation_effect(&installed, NOW + 2, &original.proof, &original.action).is_err(), + "the original writer is expired" + ); + assert!( + compile_recovery_acquisition(&installed, &target, NOW, &original.proof, &original.action) + .is_err(), + "a valid mutation is not a recovery read" + ); + let effect = compile_recovery_acquisition( + &read_installation, + &target, + NOW + 2, + &read.proof, + &read.action, + ) + .expect("separate native read authority"); + assert!( + effect.private_request().is_none(), + "acquisition has no mutation request" + ); + let binding = effect + .binding() + .to_private_bytes() + .expect("canonical binding"); + assert_eq!( + &EffectBinding::from_private_bytes(&binding).expect("binding"), + effect.binding() + ); + let review = effect.private_review().expect("review"); + let literal = review + .render_literal(crate::effect::LITERAL_REVIEW_RENDERER) + .expect("literal"); + let review_json: Value = serde_json::from_str(&literal).expect("review JSON"); + assert_eq!( + review_json["native"]["actors"], + json!([reader.principal.as_str()]) + ); + assert_eq!( + review_json["native"]["recovery"]["source_effect"], + hex::encode(source.effect().binding().id().as_bytes()) + ); + assert_eq!(review_json["native"]["method"], "GET"); + let request = effect + .approval_request(NOW + 2, NOW + 100) + .expect("read approval request"); + let signature = key + .sign(&request.signing_message().expect("read message")) + .to_bytes(); + let approved = effect + .approve(request.with_signature(signature), &public, NOW + 2) + .expect("read approval"); + approved + .validate_for_entry(&read_installation, NOW + 3) + .expect("fresh read validation"); + assert!( + approved + .validate_for_entry(&read_installation, NOW + 101) + .is_err(), + "approval is not refreshed" + ); + assert!( + matches!( + attempts.claim_bounded(&approved, NOW + 3).await, + Err(crate::GatewayAttemptError::InvalidTransition) + ), + "mutation admission rejects acquisition" + ); + let other = compile_recovery_acquisition( + &read_installation, + &target, + NOW + 2, + &read.proof, + &read.action, + ) + .expect("same read"); + assert!( + other.approve(original_approval, &public, NOW + 2).is_err(), + "write approval cannot authorize the read" + ); + let mut refused = Vec::new(); + for (field, value) in [ + ("source_effect", json!("00".repeat(32))), + ("source_operation", json!("other-source")), + ("read_contract", json!("00".repeat(32))), + ("maximum_response_bytes", json!(65_536)), + ("recipe_digest", json!("00".repeat(32))), + ("operator_namespace", json!("other-namespace")), + ("operation_id", json!("source-1")), + ("recipient", json!("unsupported-agent")), + ] { + let mut changed = read_call.arguments().clone(); + changed.insert(field.to_owned(), value); + let call = + McpToolCall::new(read_call.service(), read_call.name(), changed).expect("changed call"); + let proof = submission_for_call(&root, &reader, &read_grant, &call, &[]); + assert!( + compile_recovery_acquisition( + &read_installation, + &target, + NOW + 2, + &proof.proof, + &proof.action + ) + .is_err(), + "{field}" + ); + refused.push(field); + } + assert_eq!( + attempts + .read(recipe.namespace(), &operation) + .await + .expect("read"), + Some(before) + ); + let fixture = json!({ + "schema": "auths.gateway-recovery-compilation-fixture/1", + "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", + "binding_canonical": std::str::from_utf8(&binding).expect("UTF-8"), + "effect_id": hex::encode(approved.effect().binding().id().as_bytes()), + "authorization_call": serde_json::from_slice::(&read_call.canonical_bytes().expect("call")).expect("call JSON"), + "literal_review": literal.as_str(), "refused_changed_fields": refused, + "original_writer_expired": true, "separate_reader": true, + "mutation_admission_refused": true, "source_journal_unchanged": true, + "reserved_mutation_recipe_refused": {"source": reserved_source, "profile_lock": reserved_lock}, + }); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/recovery-compilation.json"); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} + fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { ConnectionRecord::new( ProviderKind::parse("airtable").expect("provider"), @@ -87,9 +353,21 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { let expected = recipe .closed_request_from_arguments(&arguments, submission.commitment) .expect("compiler output"); - assert_eq!(effect.private_request().body(), expected.body()); - assert_eq!(effect.private_request().url(), expected.url()); - assert_eq!(effect.private_request().headers(), expected.headers()); + assert_eq!( + effect.private_request().expect("mutation request").body(), + expected.body() + ); + assert_eq!( + effect.private_request().expect("mutation request").url(), + expected.url() + ); + assert_eq!( + effect + .private_request() + .expect("mutation request") + .headers(), + expected.headers() + ); let bytes = effect.binding().to_private_bytes().expect("binding bytes"); let private_review = effect.private_review().expect("native private review"); let review_bytes = private_review.to_private_bytes().expect("review JSON"); @@ -198,7 +476,14 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { let approved = effect .approve(approval.clone(), &public, NOW) .expect("exact approval"); - assert_eq!(approved.effect().private_request().body(), expected.body()); + assert_eq!( + approved + .effect() + .private_request() + .expect("mutation request") + .body(), + expected.body() + ); assert!(approved.validate_approval(&public, NOW + 29).is_ok()); assert!(approved.validate_approval(&public, NOW + 30).is_err()); assert!(approved.validate_for_entry(&installed, NOW + 29).is_ok()); diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 644a54dc0..039d9e82a 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1285,6 +1285,91 @@ impl GatewayEngine { proof: &[u8], action: &[u8], ) -> Result { + let (loaded, now) = self.effect_compilation_inputs().await?; + crate::effect::compile_mutation_effect( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + now, + proof, + action, + ) + } + + /// Builds the exact private call requiring independent native recovery + /// authority. Source lookup reads only the protected journal. The returned + /// call grants no custody, acquisition, disclosure or mutation capability. + /// + /// # Errors + /// Refuses an unavailable, mismatched or non-observable source, invalid + /// operation IDs, and a recovery operation that reuses its source ID. + pub async fn recovery_authorization_call( + &self, + source_operation: &str, + recovery_operation: &str, + ) -> Result { + let target = self.recovery_compilation_target(source_operation).await?; + let operation = crate::LogicalOperationId::parse(recovery_operation) + .map_err(|_| not_entered("gateway.acquisition.binding"))?; + target + .authorization_call(&self.recipe, &operation) + .map_err(|_| not_entered("gateway.acquisition.binding")) + } + + /// Compiles independently authorized recovery through the same installed + /// binding and exact approval machinery as a mutation. The source writer's + /// authority is provenance, not current read permission. No provider I/O, + /// credential lease or journal update occurs here. + /// + /// # Errors + /// Refuses unavailable/non-observable source state, invalid independent + /// native read authority, changed installation, or unsupported read bounds. + pub async fn compile_recovery_effect( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + ) -> Result { + let target = self.recovery_compilation_target(source_operation).await?; + let (loaded, now) = self.effect_compilation_inputs().await?; + crate::effect::compile_recovery_acquisition( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + &target, + now, + proof, + action, + ) + } + + async fn recovery_compilation_target( + &self, + source_operation: &str, + ) -> Result { + let unavailable = || not_entered("gateway.reobserve.not-observable"); + let operation = + crate::LogicalOperationId::parse(source_operation).map_err(|_| unavailable())?; + self.attempts + .resume_observable_operation(self.recipe.namespace(), &operation, *self.recipe.digest()) + .await + .map_err(|_| unavailable())? + .ok_or_else(unavailable)? + .recovery_target() + .map_err(|_| unavailable()) + } + + async fn effect_compilation_inputs( + &self, + ) -> Result<(LoadedConnection, u64), GatewaySubmitResult> { self.check_effect_configuration() .await .map_err(not_entered)?; @@ -1302,25 +1387,14 @@ impl GatewayEngine { .qualification .effect_time() .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - crate::effect::compile_mutation_effect( - &self.effect_policy.installation( - &self.recipe, - &self.trusted_context, - loaded.record(), - self.qualification.policy(), - self.effect_configuration_candidate().map_err(not_entered)?, - ), - now, - proof, - action, - ) + Ok((loaded, now)) } /// Verifies and attempts one exactly approved action. Proof, action and /// exact approval are accepted from the application; trust, recipe, connection, and credential /// come from the operator's installation. The admission-order step machine - /// directs every step: a replay never writes again, and for a linked - /// recipe it may perform one more read-only observation. + /// directs every step: replay returns stored facts without credential + /// custody or provider I/O. Recovery requires its own explicit operation. pub async fn submit( &self, proof_cbor: &[u8], @@ -1627,7 +1701,11 @@ impl SubmitIo for EngineIo<'_> { #[cfg(unix)] if let Some(session) = self.commissioning { let action = session - .bind_verified(approved.command()) + .bind_verified( + approved + .command() + .ok_or_else(|| not_entered("gateway.effect.protocol"))?, + ) .map_err(not_entered)?; self.commissioned_action .set(action) @@ -1910,14 +1988,15 @@ pub(crate) struct VerifiedCommand { pub(crate) observer_refusal: Option<&'static str>, } -/// [`verify_command`] that also reports what admission and an auditor need. -pub(crate) fn verify_detailed( - recipe: &CompiledRecipe, +/// The shared native authority boundary. This runs full core verification and +/// preserves the exact sealed action and branch/evidence selection. Protocol +/// compilers must still check their own service, tool, fields and accounting. +pub(crate) fn verify_native( context: &TrustedContext, now: u64, proof_cbor: &[u8], action_cbor: &[u8], -) -> Result { +) -> Result { if proof_cbor.is_empty() || proof_cbor.len() > MAX_PROOF_BYTES || action_cbor.is_empty() @@ -1945,7 +2024,7 @@ pub(crate) fn verify_detailed( .map_err(|_| GatewaySubmitResult::Indeterminate { code: "gateway.verify.invalid-input".to_owned(), })?; - let Some(action) = sealed.action() else { + if sealed.action().is_none() { let code = sealed.portable().code().code().to_owned(); return Err(match sealed.portable().decision() { VerificationDecision::Denied => GatewaySubmitResult::Denied { code }, @@ -1953,7 +2032,22 @@ pub(crate) fn verify_detailed( GatewaySubmitResult::Indeterminate { code } } }); - }; + } + Ok(sealed) +} + +/// [`verify_command`] that also reports what admission and an auditor need. +pub(crate) fn verify_detailed( + recipe: &CompiledRecipe, + context: &TrustedContext, + now: u64, + proof_cbor: &[u8], + action_cbor: &[u8], +) -> Result { + let sealed = verify_native(context, now, proof_cbor, action_cbor)?; + let action = sealed + .action() + .ok_or_else(|| not_entered("gateway.action.projection"))?; let bound = admit_bounds(proof_cbor, action, recipe, now)?; let command = McpProfile .decode_verified(action) diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index 8fb5d077e..c03280205 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -164,7 +164,7 @@ async fn reservation_restart(backend: Backend) -> serde_json::Value { let restarted = store.reopen(); let renewed = Arc::new( crate::effect::approve_driver_fixture( - approved.command().clone(), + approved.command().expect("mutation command").clone(), recipe_digest, RESUMED_AT, None, @@ -358,7 +358,10 @@ async fn native_entry_fixture_is_current() { granted.attempt.record.stage, GatewayAttemptStage::EntryGranted ); - assert_eq!(permit.request().body(), approved.command().request.body()); + assert_eq!( + permit.request().body(), + approved.command().expect("mutation command").request.body() + ); let audit = serde_json::to_value(granted.attempt.record.entry.as_ref().expect("audit")) .expect("audit JSON"); drop(permit); // A crash before send still consumes the one grant. @@ -376,8 +379,16 @@ async fn native_entry_fixture_is_current() { let read = store .reopen() .read( - approved.command().request.namespace(), - approved.command().request.operation_id(), + approved + .command() + .expect("mutation command") + .request + .namespace(), + approved + .command() + .expect("mutation command") + .request + .operation_id(), ) .await .expect("read") @@ -499,8 +510,16 @@ async fn grant_conformance(backend: Backend) { let snapshot = store .reopen() .read( - approved.command().request.namespace(), - approved.command().request.operation_id(), + approved + .command() + .expect("mutation command") + .request + .namespace(), + approved + .command() + .expect("mutation command") + .request + .operation_id(), ) .await .expect("reopen") diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 170a2f4e1..3654aae2b 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -370,6 +370,7 @@ pub(crate) fn context_with_roots( depth, composition, &[RAW_KEY_V1], + &call(&Map::new())?, ) } @@ -390,9 +391,33 @@ pub(crate) fn context_accepting( 1, fixture(CompositionRequirement::new(None, 1, 1, 1), "composition")?, methods, + &call(&Map::new())?, ) } +#[cfg(test)] +pub(crate) fn context_for_tool( + root: &Signer, + observer: &PrincipalId, + now: u64, + tool: &McpToolCall, +) -> Result { + context_for( + &[root], + observer, + None, + now, + 1, + fixture(CompositionRequirement::new(None, 1, 1, 1), "composition")?, + &[RAW_KEY_V1], + tool, + ) +} + +#[allow( + clippy::too_many_arguments, + reason = "test trust fixture keeps each explicit bound visible" +)] fn context_for( roots: &[&Signer], observer: &PrincipalId, @@ -401,13 +426,13 @@ fn context_for( depth: u16, composition: CompositionRequirement, methods: &[&str], + unbound: &McpToolCall, ) -> Result { let configuration = match configuration { Some(value) => auths_model::VerifierConfigurationId::new(value), None => fixture(gateway_verifier_configuration(), "configuration")?, }; let assurance = fixture(AssurancePolicyId::parse(ASSURANCE), "assurance")?; - let unbound = call(&Map::new())?; let mut anchors = Vec::with_capacity(roots.len()); for (index, root) in roots.iter().enumerate() { let id = if roots.len() == 1 { @@ -524,6 +549,16 @@ pub(crate) fn grant_within( subject: &PrincipalId, requirement: Option, validity: ValidityWindow, +) -> Result { + grant_for_tool(root, subject, requirement, validity, &call(&Map::new())?) +} + +pub(crate) fn grant_for_tool( + root: &Signer, + subject: &PrincipalId, + requirement: Option, + validity: ValidityWindow, + unbound: &McpToolCall, ) -> Result { let extensions = match requirement { None => CriticalExtensions::empty(), @@ -550,7 +585,6 @@ pub(crate) fn grant_within( )? } }; - let unbound = call(&Map::new())?; let statement = GrantStatement::new( root.principal.clone(), subject.clone(), diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index bd75c50ef..7cbef1155 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -20,13 +20,13 @@ pub use engine::{ CommissioningSession, CommissioningSessionInputs, GatewayRequestReview, GatewaySubmissionReview, commissioning_principal_sha256, review_submission, }; -mod connection; mod configuration; +mod connection; mod credential_journal; mod echo_verify; pub mod effect; -mod entry; mod engine; +mod entry; mod execution_witness; pub use execution_witness::GatewayExecutionWitness; #[cfg(feature = "fuzzing")] diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index d56b2e98c..ed3aa565e 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -198,6 +198,26 @@ fn envelope( plan: &AuthorizationPlan, proof_ref: ProofRef, descriptors: Vec, +) -> ActionEnvelope { + envelope_during( + agent, + canonical, + grant, + plan, + proof_ref, + descriptors, + window(NOW - 3_600, NOW + 3_600), + ) +} + +fn envelope_during( + agent: &Signer, + canonical: &CanonicalAction, + grant: &SignedGrant, + plan: &AuthorizationPlan, + proof_ref: ProofRef, + descriptors: Vec, + validity: ValidityWindow, ) -> ActionEnvelope { ActionEnvelope::new( canonical.profile().clone(), @@ -207,7 +227,7 @@ fn envelope( None, audience(), Challenge::new([0; 32]), - window(NOW - 3_600, NOW + 3_600), + validity, agent.principal.clone(), Some(grant_id(grant.statement()).expect("grant ID")), plan_id(plan).expect("plan ID"), @@ -225,7 +245,35 @@ pub(crate) fn submission( arguments: &Map, observations: &[Vec], ) -> Submission { - let bytes = call(arguments).canonical_bytes().expect("canonical call"); + submission_for_call(root, agent, grant, &call(arguments), observations) +} + +fn submission_for_call( + root: &Signer, + agent: &Signer, + grant: &SignedGrant, + call: &McpToolCall, + observations: &[Vec], +) -> Submission { + submission_for_call_during( + root, + agent, + grant, + call, + observations, + window(NOW - 3_600, NOW + 3_600), + ) +} + +fn submission_for_call_during( + root: &Signer, + agent: &Signer, + grant: &SignedGrant, + call: &McpToolCall, + observations: &[Vec], + validity: ValidityWindow, +) -> Submission { + let bytes = call.canonical_bytes().expect("canonical call"); let (descriptors, detached) = attachments(observations); let canonical: CanonicalAction = McpProfile .canonicalize(&bytes) @@ -236,13 +284,14 @@ pub(crate) fn submission( let plan = AuthorizationPlan::proof(proof_ref); let action = sign_action( agent, - envelope( + envelope_during( agent, &canonical, grant, &plan, proof_ref, descriptors.clone(), + validity, ), ); let bindings = vec![ diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index befd670db..a1a75b364 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,9 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.acquisition.binding effect compile new 74 -", + "gateway.acquisition.unsupported-bounds effect compile new 74 -", + "gateway.effect.protocol effect before-claim new 74 -", "gateway.recipe.echo-conflict GatewayRecipeError compile existing - R:form-echo-existing-field", "gateway.recipe.invalid-account-scope GatewayRecipeError compile new 2 R:account-scope-unregistered-header", "gateway.recipe.invalid-bounds GatewayRecipeError compile new 2 R:bounds-sum-argument-string", @@ -164,6 +167,7 @@ fn expected_codes(value: &Value, found: &mut BTreeSet) { /// Code families the revision introduced whole: every code under one of /// these prefixes that the crate defines must be in the inventory. const REVISION_FAMILIES: &[&str] = &[ + "gateway.acquisition.", "gateway.account-scope.", "gateway.echo-verify.", "gateway.pre-entry.", diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 64d34c77b..47f9d138f 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -534,7 +534,8 @@ impl CompiledRecipe { serde_json::from_slice(source_bytes).map_err(|_| GatewayRecipeError::InvalidSource)?; let lock: ProfileLockFile = serde_json::from_slice(lock_bytes) .map_err(|_| GatewayRecipeError::InvalidProfileLock)?; - if source.schema != RECIPE_SOURCE_SCHEMA { + if source.schema != RECIPE_SOURCE_SCHEMA || source.tool == crate::effect::RECOVERY_READ_TOOL + { return Err(GatewayRecipeError::InvalidSource); } validate_lock(&lock)?; @@ -575,6 +576,10 @@ impl CompiledRecipe { self.source.review.project(arguments) } + pub(crate) fn service(&self) -> &str { + &self.source.service + } + /// Returns the domain-separated compiled-recipe digest. #[must_use] pub const fn digest(&self) -> &[u8; 32] { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 397c52d54..a8f1fbfd2 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "ef769b2899436075fec0257e16dcc04eff7bac8fcf60a991b06f0de1b7c510db"; + "565d22f8d7174a44c6c877f0f47971349692b357b30495f01ecad1ad2da667c7"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index e78c57483..60c75380e 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2063,7 +2063,10 @@ impl GatewayAttempts { &self, approved: &ApprovedEffect, ) -> Result, GatewayAttemptError> { - let request = &approved.command().request; + let request = &approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)? + .request; let Some((_, record)) = self .load(request.namespace(), request.operation_id()) .await? @@ -2212,6 +2215,11 @@ impl ClaimedGatewayAttempt { pre_entry: &GatewayPreEntry, ) -> Result<(Self, ProviderEntryPermit), GatewayAttemptError> { let pre_entry = PreEntryWire::encode(pre_entry)?; + let request = approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)? + .request + .clone(); blocking(move || { let mut attempt = self.attempt; let dependencies = validation.dependencies(); @@ -2264,7 +2272,11 @@ impl ClaimedGatewayAttempt { .map_err(|_| GatewayAttemptError::InvalidTransition)?; current.validate_reservations( attempt.key, - approved.command().bound.as_ref(), + approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)? + .bound + .as_ref(), &snapshots[dependency_end..], now, )?; @@ -2314,7 +2326,13 @@ impl ClaimedGatewayAttempt { let (record, stored) = committed.ok_or(GatewayAttemptError::Unavailable)?; attempt.record = record; attempt.stored = stored; - Ok((Self { attempt }, ProviderEntryPermit { approved })) + Ok(( + Self { attempt }, + ProviderEntryPermit { + _approved: approved, + request, + }, + )) }) .await } @@ -2401,15 +2419,17 @@ impl ClaimedGatewayAttempt { } /// One-use native transport capability, constructed only after a new durable -/// entry acknowledgement. The shared reference retains the one sealed command; +/// entry acknowledgement. The shared reference retains the approved effect; /// the permit itself is neither cloneable nor deserializable. pub(crate) struct ProviderEntryPermit { - approved: Arc, + _approved: Arc, + // Immutable clone of the exact sealed mutation request checked at grant. + request: ClosedProviderRequest, } impl ProviderEntryPermit { pub(crate) fn request(&self) -> &ClosedProviderRequest { - &self.approved.command().request + &self.request } } @@ -2435,6 +2455,25 @@ impl ObservableGatewayAttempt { self.attempt.record.observation_request() } + /// Native private compilation target from this validated journal's plan. + /// It contains private data but grants no read or write authority. + /// + /// # Errors + /// Refuses corrupt binding data or a missing closed observation request. + pub fn recovery_target( + &self, + ) -> Result { + let binding = crate::effect::EffectBinding::from_private_bytes( + self.attempt.record.binding_canonical.as_bytes(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let request = self + .observation_request() + .ok_or(GatewayAttemptError::InvalidTransition)?; + crate::effect::RecoveryReadTarget::from_journal(binding, request, self.echo_token()) + .map_err(|_| GatewayAttemptError::Corrupt) + } + /// Returns this attempt's echo token, derived from the stored verified /// commitment, when the recipe declared an echo field. #[must_use] @@ -2915,7 +2954,10 @@ impl GatewayAttempts { ) -> Result { match self.claim_new_bounded(approved, evaluated_at).await { Err(GatewayAttemptError::Replay) => { - let request = &approved.command().request; + let request = &approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)? + .request; let (stored, record) = self .load(request.namespace(), request.operation_id()) .await? @@ -2953,7 +2995,9 @@ impl GatewayAttempts { approved: &ApprovedEffect, evaluated_at: u64, ) -> Result { - let command = approved.command(); + let command = approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)?; let request = &command.request; let binding = approved.effect().binding(); if !self.policy.contains(binding) { diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 21891b8e5..c7ee569d8 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -355,7 +355,7 @@ impl Run<'_, I> { SubmitAction::Verify => SubmitEvent::Verification(self.verify()), SubmitAction::Admit => SubmitEvent::Admission(self.admit()), SubmitAction::BindScope => { - let bound = match self.verified.as_deref().map(ApprovedEffect::command) { + let bound = match self.verified.as_deref().and_then(ApprovedEffect::command) { Some(verified) => self.io.bind_scope(verified), None => Err("gateway.attempt.unavailable"), }; @@ -470,7 +470,10 @@ impl Run<'_, I> { return Verification::Refused; } }; - let verified = approved.command(); + let Some(verified) = approved.command() else { + self.refuse_before_claim(not_entered("gateway.effect.protocol")); + return Verification::Refused; + }; let argument = match &self.ceiling { None => 0, Some(ceiling) => { @@ -489,7 +492,7 @@ impl Run<'_, I> { /// observer check; nothing is stored. The first failing check's code is /// the one reported. fn admit(&mut self) -> bool { - let Some(verified) = self.verified.as_deref().map(ApprovedEffect::command) else { + let Some(verified) = self.verified.as_deref().and_then(ApprovedEffect::command) else { return false; }; if let Some(retention) = self.cx.recipe.idempotency_retention() @@ -632,7 +635,7 @@ impl Run<'_, I> { async fn pre_entry_read(&mut self) -> PreEntryResult { let (Some(lease), Some(verified), Some(observer), Some(pointers)) = ( &self.lease, - self.verified.as_deref().map(ApprovedEffect::command), + self.verified.as_deref().and_then(ApprovedEffect::command), self.cx.observer, self.cx.recipe.pre_entry_pointers(), ) else { @@ -678,7 +681,7 @@ impl Run<'_, I> { async fn ceiling_read(&mut self) -> CeilingRead { let (Some(lease), Some(verified), Some(ceiling)) = ( &self.lease, - self.verified.as_deref().map(ApprovedEffect::command), + self.verified.as_deref().and_then(ApprovedEffect::command), &self.ceiling, ) else { return CeilingRead::Unavailable; @@ -770,7 +773,7 @@ impl Run<'_, I> { let (Some(claim), Some((status, digest, body, version_ok)), Some(verified)) = ( self.claim.take(), self.written.take(), - self.verified.as_deref().map(ApprovedEffect::command), + self.verified.as_deref().and_then(ApprovedEffect::command), ) else { return ResponseRecord::Failed; }; diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index d76e5bf99..31a07e28e 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -665,7 +665,7 @@ mod tests { ) .await .expect("durable grant"); - let request = &approved.command().request; + let request = &approved.command().expect("mutation command").request; let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)) .await .expect("bind"); From 3ca2c36488b54fbfc3b0a86c9544896e7c8ee0ab Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 06:13:14 +0000 Subject: [PATCH 024/136] feat(gateway)!: journal and fence bounded recovery acquisitions --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 16 + bindings/fixtures/gateway/recovery-entry.json | 37 + .../qualification/schema-vectors.json | 24 +- .../qualification/verification-vectors.json | 94 +-- compliance.toml | 11 +- ...017-bound-effect-and-recovery-ownership.md | 30 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 20 +- docs/plans/0074-implementation-status.md | 46 +- .../0009-bound-effect-and-recovery.md | 20 + .../src/vectors/mod.rs | 2 +- .../auths-gateway-kernel/src/transition.rs | 106 ++- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6435 -> 6519 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6318 -> 6402 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5600 -> 5684 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4909 -> 4993 bytes .../fuzz_targets/target_gateway_attempt.rs | 8 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 13 +- .../auths-gateway/src/effect/acquisition.rs | 162 +++-- .../auths-gateway/src/effect_native_tests.rs | 221 +++++- product/runtime/auths-gateway/src/engine.rs | 132 ++++ .../runtime/auths-gateway/src/entry_tests.rs | 26 +- product/runtime/auths-gateway/src/lib.rs | 13 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 2 + .../auths-gateway/src/qualification.rs | 4 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 6 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 666 ++++++++++++------ .../auths-gateway/src/store/acquisition.rs | 620 ++++++++++++++++ product/runtime/auths-gateway/src/submit.rs | 12 +- product/runtime/auths-gateway/src/support.rs | 75 +- .../runtime/auths-gateway/src/transport.rs | 19 + .../auths-gateway/tests/support_bundle.rs | 2 +- ...cycle_v7.sql => postgres_lifecycle_v8.sql} | 6 +- .../auths-stores/src/gateway_attempt.rs | 9 +- product/stores/auths-stores/src/lifecycle.rs | 6 +- xtask/src/semantic_freeze.rs | 2 +- 45 files changed, 2021 insertions(+), 409 deletions(-) create mode 100644 bindings/fixtures/gateway/recovery-entry.json create mode 100644 product/runtime/auths-gateway/src/store/acquisition.rs rename product/stores/auths-stores/migrations/{postgres_lifecycle_v7.sql => postgres_lifecycle_v8.sql} (92%) diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index d91b1c308..63fec0a43 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/6", + "attempt_schema": "auths.gateway-attempt/7", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 324a3652d..6642a83ed 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -104,6 +104,14 @@ "id": "account-scope-unbound" } }, + { + "code": "gateway.acquisition.ancillary-required", + "owner": "effect", + "stage": "before-claim", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.acquisition.binding", "owner": "effect", @@ -112,6 +120,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.acquisition.exhausted", + "owner": "effect", + "stage": "admission", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.acquisition.unsupported-bounds", "owner": "effect", diff --git a/bindings/fixtures/gateway/recovery-entry.json b/bindings/fixtures/gateway/recovery-entry.json new file mode 100644 index 000000000..38622d753 --- /dev/null +++ b/bindings/fixtures/gateway/recovery-entry.json @@ -0,0 +1,37 @@ +{ + "schema": "auths.recovery-entry-fixture/1", + "scope": "native read proofs and file journal; synthetic entry validation and response; no provider or installed-authority claim", + "admission": { + "calls": 1, + "bytes": 16384, + "reopen_does_not_charge": true + }, + "permit_loss": { + "stage": "unknown", + "revision": 2, + "stale_grant_refused": true + }, + "race": { + "remaining_capacity": 15, + "contenders": 16, + "winners": 15, + "exhausted": 1 + }, + "retention": { + "calls": 16, + "bytes": 262144, + "sweep_removed": 0 + }, + "response": { + "stage": "response-recorded", + "revision": 3, + "received_bytes": 2, + "replay_preserves_facts": true + }, + "source_journal_unchanged": true, + "mixed_projection": { + "mutations": 1, + "acquisitions": 17, + "grants_project_unknown": true + } +} \ No newline at end of file diff --git a/bindings/fixtures/qualification/schema-vectors.json b/bindings/fixtures/qualification/schema-vectors.json index 4f9b614e4..86cdd4682 100644 --- a/bindings/fixtures/qualification/schema-vectors.json +++ b/bindings/fixtures/qualification/schema-vectors.json @@ -23,9 +23,9 @@ "trust_root": "{\"public_key_b64\":\"0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzc\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-trust-root/1\",\"signature_suite\":\"ed25519-v1\"}", "signer_certificate": "{\"root_signature_b64\":\"obGs_sPHvOXfTu8emdHu3odSbdq3PEW0XwoKhrOSb1LQTgq9LOvFPrRcuhE6Tis01Ac9ndvtGQiey6UWh0MmBg\",\"statement\":{\"issued_at\":1789913600,\"not_after\":1805465600,\"not_before\":1789913600,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}", "revocation_list": "{\"root_signature_b64\":\"nVaEVMHFGD_kiB0SIdz3uK3Xh0YlYrUJY-PRkV7_sCAc6mGs39yQxxGsiShFyuVrE_NxGHNnX40Lg6mi_w_hAw\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}", - "release_index": "{\"signature_b64\":\"F7krnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", - "record": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}", - "attestation": "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"KqZBZCp6N240Pjm_GBsw2WQqLXJQjvxKY6eQ9qUawzqtWEHA2qZXZftwZ4dq1c1KfG9uaWqnpYxKfwTAF5j7AA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "record": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}", + "attestation": "{\"signature_b64\":\"8Wqp3Eew7a-UtQmwvcDJo9UgtP7YZ21f6MmCkJ2Ui8wbViHV9BEW-gWMtGizN9qmxFyroaQE1g-hLm3W8bKnDQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "provider_contract": "{\"api_release\":\"2026-09-01.fixture\",\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"declarations\":{\"idempotency_sha256\":\"d6ee51b4b1b7adbf404892f9326dd33a8d42047c0d7592aa8366ad4fcf99a300\",\"observation_sha256\":\"41eecb260924ac4b305313888b59325a24161b0c9d60ecda92ab26bc10e3fbf5\",\"recovery_sha256\":\"871f9dded4942ff0262f147ca7fd4992b38da2741bac401abf3cd8dc43d4d2d3\",\"retention_sha256\":\"5e783fc5c0cf8950b44fd3095ff0679df34660600d0e7a59cedb2084e850aec7\"},\"environment_class\":\"provider-test-mode\",\"manual_assumptions\":[\"a refund of a refunded payment is rejected, not repeated\",\"the idempotency key is honored for at least 24 hours\"],\"openapi_slice_sha256\":\"b11c8865e81ede17d33a255a677549fa87ba045c67077495b8749fc5455c0b2f\",\"oracle_version\":\"oracle-1\",\"provider\":\"example-payments\",\"schema\":\"auths.provider-contract/1\"}" }, "provider_contract_id": "f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d", @@ -511,21 +511,21 @@ "artifact": "record", "class": "non-canonical", "reason": "non-canonical", - "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}\n" + "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}\n" }, { "id": "record-exponent-time", "artifact": "record", "class": "non-canonical", "reason": "malformed", - "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1.7899928e9,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" + "text": "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1.7899928e9,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}" }, { "id": "record-repeated-member", "artifact": "record", "class": "non-canonical", "reason": "malformed", - "text": "{\"schema\":\"auths.recipe-qualification/1\",\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" + "text": "{\"schema\":\"auths.recipe-qualification/1\",\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}" }, { "id": "certificate-hardware-signer-kind", @@ -833,14 +833,14 @@ "pointer": "/statement/entries", "value": [ { - "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", + "attestation_sha256": "0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d", "qualification_id": "qlf_01010101010101010101010101010101", - "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" + "record_sha256": "3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585" }, { - "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", + "attestation_sha256": "0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d", "qualification_id": "qlf_01010101010101010101010101010101", - "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" + "record_sha256": "3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585" } ] } @@ -858,9 +858,9 @@ "count": 257, "width": 32, "template": { - "attestation_sha256": "8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b", + "attestation_sha256": "0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d", "qualification_id": "qlf_{}", - "record_sha256": "3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd" + "record_sha256": "3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585" } } ] diff --git a/bindings/fixtures/qualification/verification-vectors.json b/bindings/fixtures/qualification/verification-vectors.json index fd62da145..173e81268 100644 --- a/bindings/fixtures/qualification/verification-vectors.json +++ b/bindings/fixtures/qualification/verification-vectors.json @@ -50,12 +50,12 @@ "trust_root": "{\"public_key_b64\":\"0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzc\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-trust-root/1\",\"signature_suite\":\"ed25519-v1\"}", "signer_certificate": "{\"root_signature_b64\":\"obGs_sPHvOXfTu8emdHu3odSbdq3PEW0XwoKhrOSb1LQTgq9LOvFPrRcuhE6Tis01Ac9ndvtGQiey6UWh0MmBg\",\"statement\":{\"issued_at\":1789913600,\"not_after\":1805465600,\"not_before\":1789913600,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}", "revocation_list": "{\"root_signature_b64\":\"nVaEVMHFGD_kiB0SIdz3uK3Xh0YlYrUJY-PRkV7_sCAc6mGs39yQxxGsiShFyuVrE_NxGHNnX40Lg6mi_w_hAw\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}", - "release_index": "{\"signature_b64\":\"F7krnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"KqZBZCp6N240Pjm_GBsw2WQqLXJQjvxKY6eQ9qUawzqtWEHA2qZXZftwZ4dq1c1KfG9uaWqnpYxKfwTAF5j7AA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}" ], "attestations": [ - "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"8Wqp3Eew7a-UtQmwvcDJo9UgtP7YZ21f6MmCkJ2Ui8wbViHV9BEW-gWMtGizN9qmxFyroaQE1g-hLm3W8bKnDQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], "deployment": { "recipe_family": "example-refund-v1", @@ -70,7 +70,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -91,14 +91,14 @@ "class": "valid", "replace": { "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}", - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"aarch64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}", + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1797768800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"aarch64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}" ], "attestations": [ - "{\"signature_b64\":\"WpEYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", - "{\"signature_b64\":\"_E6upIbPHumyWVjZBeAs3wF_pwjiokZy0gMFD8PkPzJypu_4mbEdMlBlO2fhQ5vpOEh_JrgBQUKmSWrERb08Aw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"154c748f1fda0e7d97cc79bb64ce126daa879c33993b0afa67f88af382682e3b\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"8Wqp3Eew7a-UtQmwvcDJo9UgtP7YZ21f6MmCkJ2Ui8wbViHV9BEW-gWMtGizN9qmxFyroaQE1g-hLm3W8bKnDQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "{\"signature_b64\":\"-Y5r_AeP45QGBIjJg7wKzmgmRdqLRIem8WvxUNR55v4PEjJ-8xQ8KUFZRnHObDkLreCIbNHX1fibgtR9ixB4BA\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"6076ea0b393af10e16113a0ec127adbf7e5f05a9711757a39b717f6c30c73a3c\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"PpwJSY7n732459aPXuQE0nhAEoE831x4ObEy3UJYc91PISSJkno4S2dK9Sc2mSKnAj_ZIcqDMV48pwAa0hFUDQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"},{\"attestation_sha256\":\"0347ca6cfd561c9e1cf190937b658e3db4391e4dec0594362b5665e0d3c48415\",\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"154c748f1fda0e7d97cc79bb64ce126daa879c33993b0afa67f88af382682e3b\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"OyCJKeXI18gCrdLUrVIGXlFDnxiQhXEUgPBw0XsK6QcH_1c1U79p1Mg3aTTlEsOIcPrY5j4JXrHpEV6ImZb2Bg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"},{\"attestation_sha256\":\"3090742d79546a4f402eb7786b2f5b2e34a396256b7638145ca6d3a3ee860e2f\",\"qualification_id\":\"qlf_02020202020202020202020202020202\",\"record_sha256\":\"6076ea0b393af10e16113a0ec127adbf7e5f05a9711757a39b717f6c30c73a3c\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "deployment": { "recipe_family": "example-refund-v1", "compiled_recipe_sha256": "262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef", @@ -112,7 +112,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -154,9 +154,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"W5EYcoyaUemj_FqmxTAi3TcdOE6gYEzBn4SF5UAT9cRxGvjngon9UxxryrSY8_9Y2KKosaERfQynLeTKGiprCw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"8Gqp3Eew7a-UtQmwvcDJo9UgtP7YZ21f6MmCkJ2Ui8wbViHV9BEW-gWMtGizN9qmxFyroaQE1g-hLm3W8bKnDQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"gstQKaN_329H-IM1AIC81bbINma6jddesBZu3KBjyOmIZuGj9fHYl9ngobgj1YUYLPJMK2x6arDLnTRH8VhUCA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"f58b5ce0a7a3c471535e557d7d6bd5cc4adf97dc307dc4a0ed7f9a181f50dac4\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"FQYQAhdO8AFJWHjGs0snXNimvT2M_TwPA6zi9ohxqunhLct2h_x37sthd8WHgBBmnrptGghexL2vIAOVkl9ZBg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"96e60b80364fc8815ea221b4316d6e76928bc26cf574b82c48ac1a86d02c4965\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -169,7 +169,7 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"lgFGj1nFFiSRkZu2Jq5bHK9WVYsO-GZ4ba2IVU0R02XE9qn3LkAOKLFOeH9Ra41I7myx082uZ239YxauJFQVBw\",\"statement\":{\"issued_at\":1789992801,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"PQIUEMhVuP3I4s922iMKikFCykGlmathy5rZuX0RhdbxNsDU5yvAHdndWLYWFb4hq7R173sQA4mjcWBzugIVAA\",\"statement\":{\"issued_at\":1789992801,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ] }, "expect": { @@ -183,9 +183,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"P3kE1Ubznbtmo5VHewkUU-tsY4niWNS8uqOLXCvlylKA3uMonaIOhAEVpAJ8llyY_H6laxrT8IS-RAXzsbtJBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"IFxG8Wf6v2W2juoF4zoxlx-1UXauJ0kZWT_me8zhtTMU5RxuRmf4PRr58KTcDaYRS9YOkOfbb9zRKSwh7suKCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"c357279477033a8a7942083810f5145f64694806568c6bbe64c60bf409a59a8a\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -197,7 +197,7 @@ "id": "index-signature-forged", "class": "forged", "replace": { - "release_index": "{\"signature_b64\":\"FrkrnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"K6ZBZCp6N240Pjm_GBsw2WQqLXJQjvxKY6eQ9qUawzqtWEHA2qZXZftwZ4dq1c1KfG9uaWqnpYxKfwTAF5j7AA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "unqualified", @@ -209,7 +209,7 @@ "id": "index-signed-by-outsider", "class": "forged", "replace": { - "release_index": "{\"signature_b64\":\"pXqrlE-c_QkMVuKxDEFkaZ5xPkXCgNH2GCN5afzIeejtOcBP4vMNdyBwdMLsr3zUV1QnSJvsrrSeH_Lk3WxABA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"XbFBKwjaV9LIdmMX7eIiBuaPB-nbVKUs81A_XtT8LMEJ97A6iXxAr2IT6Bna0663VivZyCk8KWy4sgRNNp8UDw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "unqualified", @@ -294,9 +294,9 @@ "class": "forged", "replace": { "attestations": [ - "{\"signature_b64\":\"Rv7jMneOVEPB2DC5PsuJh9-UAID4nFlI1Y3S705lWuOVdHPG8ZKyvbcAobd-e53HWRvrQroy4eYYYvT7yr_SAg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"another-signer\"}}" + "{\"signature_b64\":\"MIcPdzJICWtlZmYas1ISsowVWtaTfAB_dZgxbyrtwUDKDUuIc48IVf1WZFz40EMyfhfJpua4JhiSpYjz-iy8Cw\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"another-signer\"}}" ], - "release_index": "{\"signature_b64\":\"ksefSEsRRKU8M6176xy8cZm6gtLbTD0ShjT-wG_Tegm0PTxkcRG02YmW6wlbjSNf98BuLnQoCv9K22gmKodoDg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"7080a1a1cff7aa99fb84757ce9083e66f6e5947220e1890ded8c43a06b87da14\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"lT8jZ9uriafM5ec1ZBzS90S4GeCfMkmebfA3qQEt-WM65qYLEUZEZtwqHYbsG9lluSYyM92MHAxdOSC1t3jBCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9fd2d9c505246f8787b52117b2dcaa453ca853fa3fb2a5458b47dbb08998de5f\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -311,7 +311,7 @@ "attestations": [ "{\"signature_b64\":\"dU8UPdRvQ6Xr6xCtRvpnj5HT5oD_oPcTI1sc3fnHTzNL-eenyjjdJOq0-0wBZicAH4uVvsJV2LmcnPmcRaXXBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"1bc3a22a5bba0537b35bcb4db6ec7a29fafb9deae8f5f964919628c38654c42d\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"SvgpIJYiHz8-HdRFw4Cy0ETIbiQt4R_T4Orc_BYB_D0qnvMMn4WnmVqHc30HfalrVaHuUlEdUC4VvHwI6zBbAA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"b349ee3d88adb475afa1ffabc89b76c010c1d890cc3ccf8ebe282f0e7cdece3f\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"GlAPrbS3oYRHlxpDHTAIP4c6kddB9mKnq6L6Q3ItbjY6BFAo3qVIaDq2PEBlZoPlRmqMQ1QoW2KWPEYE7HeIDg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"b349ee3d88adb475afa1ffabc89b76c010c1d890cc3ccf8ebe282f0e7cdece3f\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -324,12 +324,12 @@ "class": "widened-time-bound", "replace": { "records": [ - "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1795176800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/7\"}}}" + "{\"capabilities\":[{\"capability\":\"credential-guard\",\"result\":\"exercised\"},{\"capability\":\"version-pin\",\"result\":\"exercised\"},{\"capability\":\"account-binding\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"},{\"capability\":\"denied-reads\",\"result\":\"exercised\"},{\"capability\":\"ceiling\",\"result\":\"exercised\"},{\"capability\":\"budget\",\"result\":\"exercised\"},{\"capability\":\"idempotency\",\"result\":\"exercised\"},{\"capability\":\"response-locator\",\"result\":\"exercised\"},{\"capability\":\"echo\",\"result\":\"exercised\"},{\"capability\":\"observation\",\"result\":\"exercised\"},{\"capability\":\"recovery\",\"result\":\"exercised\"},{\"capability\":\"observer-rotation\",\"reason\":\"the qualified recipe and target declare none\",\"result\":\"not-applicable\"}],\"corpus_manifest_sha256\":\"d6c1cad9a6b0fe0fc27d1f8107c2381e8b9ab1bbfc04a47aa8234140de74a23f\",\"custody_descriptor\":\"aws-secrets-manager-v1 with workload identity\",\"evidence\":[{\"cases\":12,\"evidence_sha256\":\"c3a2a799eb04b1ee53a22495e0d95171a9f42f2ad557b639f3fe5440bbed90e7\",\"member\":\"conformance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"dfd5b5dccc73cae91abec7a76c332dae145eb37eddb18f56dca2e68f2dbc81ab\",\"member\":\"differential\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"a05d5182b4f20eb67c0d95622a70f1e4ac87d1d1b8b7fab219a2276b6da41256\",\"member\":\"hostile\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"00beb3d9e44f8d20d5da8861818ecd7b430714f959a6613dbd2d870997eb90f8\",\"member\":\"live\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"3a4e01d7b8d11480e334d0d2fffc2efeeaf2363d21f9107094c3cfc3c063b362\",\"member\":\"recovery\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"6b428d653e06c75268e2e33f234f30f9cc24616c42faf551699f7a7ac2376011\",\"member\":\"rotation\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"e8713a54bfb187836d4db2f34f181129f2e03f7221bc2d3247134470adcacee8\",\"member\":\"restart\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8824a7669543ecf652b651fa2d370c548e09b73c1babac841cd689389a1fdcbe\",\"member\":\"multi-instance\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"f31f29dc30a4e8ccd3aea69c012656c2811ac194881147b2cced5dd7dc1a7d9b\",\"member\":\"redaction\",\"result\":\"passed\",\"unauthorized_provider_entries\":0},{\"cases\":12,\"evidence_sha256\":\"8e91fde286bdbb80e6d6245e7ab9dab68f92e790922170195fc80aab2eeb227b\",\"member\":\"installed-consumer\",\"result\":\"passed\",\"unauthorized_provider_entries\":0}],\"excluded_claims\":[\"the provider performed or settled the business effect\"],\"generated_artifacts_sha256\":\"fff3ece48e4f5271825e80b355a1243a4c30619329bbbc70bc4e5c1b242973e2\",\"installed_packages\":[{\"name\":\"auths-gateway\",\"sha256\":\"8a58d99c69c098e53c2197df2c6a6a16b131c69798f728db134c978f77e95360\",\"version\":\"1.0.0-rc.1\"},{\"name\":\"auths-python\",\"sha256\":\"59b028e3e66e681bfa195fb6afee775b91f30fc418f05f86353bc71cd021d2f9\",\"version\":\"1.0.0rc1\"}],\"live_effects\":{\"confirmed_by_read_back\":4,\"entered\":4},\"not_after\":1795176800,\"not_before\":1789992800,\"provenance\":{\"commit\":\"0123456789abcdef0123456789abcdef01234567\",\"environment\":\"recipe-qualification\",\"repository\":\"github.com/auths-dev/auths-proof\",\"workflow\":\".github/workflows/recipe-qualification.yml\"},\"provider_kind\":\"example-payments\",\"provider_resources\":[\"refund:fixture-0001\",\"refund:fixture-0002\"],\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"recipe_decision_record_sha256\":\"0c2328dfcdc21fcd917fd242dd16f9adf1354395a472e589e2778dee99527081\",\"residual_assumptions\":[\"the provider keeps its test mode separate from live data\"],\"schema\":\"auths.recipe-qualification/1\",\"source_closure_sha256\":\"00023b3a6fbf90b531085365646cda2ffcac182f6eaedf453eb680b63ae33106\",\"store_descriptor\":\"postgresql 16 with TLS\",\"tuple\":{\"compiled_recipe_sha256\":\"262f5ef11b349645f2421c533220fc6bbfd70c4a5395f5d65c601406eba7d4ef\",\"gateway_semantic_closure_sha256\":\"01ec13346b098e4f5e1c64a995a50ce15ef339dc1f304966a45c94e80638203b\",\"profile_lock_sha256\":\"4dd8982feedb83403f985de3e1a952a90060e44035ab797e5313ff93957a22d5\",\"provider_contract_id\":\"f15f154a38de58de1b27c70c61a6b20fe532746e2e4462576dbd3d27d76cce3d\",\"recipe_family\":\"example-refund-v1\",\"target\":{\"arch\":\"x86_64\",\"credential_store_kind\":\"aws-secrets-manager-v1\",\"gateway_build_sha256\":\"42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3\",\"gateway_package\":\"auths-gateway\",\"gateway_version\":\"1.0.0-rc.1\",\"os\":\"linux\",\"store_kind\":\"postgresql-v1\",\"store_schema\":\"auths.lifecycle.postgresql/8\"}}}" ], "attestations": [ - "{\"signature_b64\":\"AwFLFc3BWQwkgabGaOOZ_Pl1I7kK2Vt0Fir3ngrKO-j3N_UnX61XoP7lxm26zdHuZVyUdH-CwTkQcFST2TZjBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"8c6d91168743e4833127e8121752d634bc99a5b50917c4fd91e14a751e2b1ab0\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"nYRyp7KE1YBzapdMM8G0F03U83VEqq4jfh2tR64MPdrVpj4kgRB1rPcjWVVVHXDP16Nrdik7uuWqdPeN_Zn4BQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"d622678907b15830aab88b8195702eb205614bd696dab303ce42885be4e781c5\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"AkvZARmRLyWHdBZDfe9h4C_RM6zKMy6Y_7ZAylwtfN7-WR6iNn_nwRmx4hn1AL8hJPueq1uLmCsFxjkgVcS6CQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"dccc035572444236f079312739837944911c39180153f2bbae76c009c4423e0e\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"8c6d91168743e4833127e8121752d634bc99a5b50917c4fd91e14a751e2b1ab0\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"12FZxWNrVo5K0q-HoAgRfkTaBHIxR2n_D6Jzq6Or_QxELjr_OpBIKnbv5WbSnDiS_BbhttgAICg0mwhrQtYOAA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"a680c205da5cadd83ace2c8403bbb038328c7d40f94e8d9469babbb1a3681d91\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"d622678907b15830aab88b8195702eb205614bd696dab303ce42885be4e781c5\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -342,9 +342,9 @@ "class": "not-yet-valid", "replace": { "attestations": [ - "{\"signature_b64\":\"kdf21QMMuwNrnjH5blOc06QCr2mywsSLpic0dOcTbvOM0FBFG4L8wy55-VjRTJceoY36e1vXY-Meu-g-40SgBg\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1792595600,\"not_before\":1790003600,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"W_pORm_N7CS68D3bJSXF-yrfHg66S9ee1cGm0pahyV1uxoMPavwn3ForQxebP6yxe8xoyd1nHpID8HjTM0tGCA\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1792595600,\"not_before\":1790003600,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"FuutnsAO-NZvt8t4WXhw7E1U5QR-Ipp2QhxmIx64hcKBT5JEEugRnhCmuYMstSJeXKqD1chrsqImeSxx16hwCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"57fa5d84840f2c5e1b2de90041e2af75b10e234d2862d8802ee9cac9f680eb62\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"YOcH0IjAXeqVpDPdBpPoFJvcgdzKsnHJ_BSreh_5RK8Wx89MfVbt98Kl4rAsOrOcLkkShHYB5gianGEHAJzaAw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"a01a1e3e6541a5948f79d83f3d2c2dc368e60cd447966c28fbd1984e282f54c8\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "candidate", @@ -368,7 +368,7 @@ "id": "unusable-index-before-revocation", "class": "precedence", "replace": { - "release_index": "{\"signature_b64\":\"FrkrnKivn9TcWHofcVVSdWU9Z2aOnXMk6el8gB2gzYNCTICqwWJR264PBZ1AHlb5H89iS_SCG5BXDy4voHKtDA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"K6ZBZCp6N240Pjm_GBsw2WQqLXJQjvxKY6eQ9qUawzqtWEHA2qZXZftwZ4dq1c1KfG9uaWqnpYxKfwTAF5j7AA\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "revocation_list": "{\"root_signature_b64\":\"Oe8aY9Lt91XEvAJ86JGwNpAUwVl5WGvXfP3xvBIraeDWf8B0m0OPMVVmAp5WqglK8RDodbQ9g8CfDgAJI3coBg\",\"statement\":{\"issued_at\":1789996400,\"next_update\":1790255600,\"revoked_qualifications\":[\"qlf_01010101010101010101010101010101\"],\"revoked_signers\":[],\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-revocation-list/1\",\"sequence\":7}}" }, "expect": { @@ -426,9 +426,9 @@ "class": "precedence", "replace": { "attestations": [ - "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"P3kE1Ubznbtmo5VHewkUU-tsY4niWNS8uqOLXCvlylKA3uMonaIOhAEVpAJ8llyY_H6laxrT8IS-RAXzsbtJBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"IFxG8Wf6v2W2juoF4zoxlx-1UXauJ0kZWT_me8zhtTMU5RxuRmf4PRr58KTcDaYRS9YOkOfbb9zRKSwh7suKCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"c357279477033a8a7942083810f5145f64694806568c6bbe64c60bf409a59a8a\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "now": 1790255601 }, "expect": { @@ -442,9 +442,9 @@ "class": "precedence", "replace": { "attestations": [ - "{\"signature_b64\":\"GUWYceUqDw8p20stIwTOXc_wuGgxT29imAD4Sco_t5IUFceKorukRSdPv4MQVKW-vGJtnsXLUyM1aU5PFw1NBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"P3kE1Ubznbtmo5VHewkUU-tsY4niWNS8uqOLXCvlylKA3uMonaIOhAEVpAJ8llyY_H6laxrT8IS-RAXzsbtJBQ\",\"statement\":{\"issued_at\":1789992800,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"gMWeTFL0z6YX4Ewwzu1OQ-kE93EmeqkygiwI7vMDZ1HB-hIXW-EwZbU1rfjMpQciv8ArxonRF9nDUDxhPTiKAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"9a266282eafd7311de55ee73c3a9d61d97686eaee3d365dd092e94ce5a6f8ac7\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", + "release_index": "{\"signature_b64\":\"IFxG8Wf6v2W2juoF4zoxlx-1UXauJ0kZWT_me8zhtTMU5RxuRmf4PRr58KTcDaYRS9YOkOfbb9zRKSwh7suKCw\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"c357279477033a8a7942083810f5145f64694806568c6bbe64c60bf409a59a8a\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}", "signer_certificate": "{\"root_signature_b64\":\"AzUQnJwFYUZzLtBZTs8b0R2kt6nvkhJoBbMttBXnyAP7dSk7rVfe7sZQxD4Laerbyc7jgH4yzz1dUWdEOfscDA\",\"statement\":{\"issued_at\":1787408000,\"not_after\":1789999999,\"not_before\":1787408000,\"permitted_artifact_kinds\":[\"qualification-release-index\",\"recipe-qualification-attestation\"],\"public_key_b64\":\"oJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPA\",\"root_id\":\"auths-qualification-root-1\",\"schema\":\"auths.qualification-signer-certificate/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\",\"signer_kind\":\"protected-software-release-key-v1\"}}" }, "expect": { @@ -472,7 +472,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -548,7 +548,7 @@ "id": "index-issued-ahead", "class": "future-issued-at", "replace": { - "release_index": "{\"signature_b64\":\"1uq26boBL0UHQZSn9lBnT3R61ZIfpbQ2RQ-nrtC5HM0PBbIkKbrkIcZzDll6OTRI9vjfV_apf8PoWD7hOCW0Ag\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"8f6949c5cdd736620e884c1d61939231657355fa170f25d835d0cb325fd6066b\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1790000060,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"96c-h_1fMGHnYZmc0kISP3hlzDZcj1SMck9TbsOUCKLCEGr8UgXAuh68q7KpW1-wVdqLEf8dNMKDUHd8DZ1MAQ\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"0733b3f3ca1d89c90c8e0711b988428f45b7efc99e4e95a336e93d8b5572682d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1790000060,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "stale", @@ -561,9 +561,9 @@ "class": "future-issued-at", "replace": { "attestations": [ - "{\"signature_b64\":\"K_tNB3s_ibY38Q26cK8RIoG7SrYv58vSesGEZfDntKb7YvO7CI9M7QT5RJnQDbZ8cFsw4D9V5ohkxhCQsKJLDA\",\"statement\":{\"issued_at\":1790000060,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "{\"signature_b64\":\"Q2Sbo357mBskW9A2x9yUtRsZnzuRuPbyYiRUUq38L-Eyvwt0axyNZv0vnxj3sxFFh3S6vXf01iheT0VgyDAqCw\",\"statement\":{\"issued_at\":1790000060,\"not_after\":1797768800,\"not_before\":1789992800,\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\",\"schema\":\"auths.recipe-qualification-attestation/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" ], - "release_index": "{\"signature_b64\":\"JV3P-5Gtwgl_ldQ4NZ_VpNIh2U38g4zLpuc2GcA42pbFiE7-Fwo2sNzRzOLX9ljtPoQZCz7pAiL0cQfSU1mdBg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"495d11bbb7b5ee3bc7d795db990df7828ec06dfb337031dd66e68232fbd42bb3\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3f787335aae239aa07f8d799d8e2ff83758a1d299f1dd3a92308dd73ebafc5fd\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" + "release_index": "{\"signature_b64\":\"tEZfVtLTOkWwOrGe4xeyQXtajOS5cvYR0LDoy90QbCae_Qn9Z416VrlgTX_GSGsPlmlLHy0Hj8_UXEJBy2ZdDg\",\"statement\":{\"entries\":[{\"attestation_sha256\":\"ffda9b9ea9b2c465f12a62f3a6614688eace0c757bcc8c8bdc1e03a88173c60d\",\"qualification_id\":\"qlf_01010101010101010101010101010101\",\"record_sha256\":\"3ad7c9d5db64114b8ce2ec16b4f002d5fd3dc2797ce1df64ff26fdd24338b585\"}],\"issued_at\":1789996400,\"schema\":\"auths.qualification-release-index/1\",\"signature_suite\":\"ed25519-v1\",\"signer_id\":\"release-signer-2026-10\"}}" }, "expect": { "state": "stale", @@ -637,7 +637,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } }, @@ -740,7 +740,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -768,7 +768,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -796,7 +796,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -824,7 +824,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -852,7 +852,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -880,7 +880,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -908,7 +908,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -936,7 +936,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -964,7 +964,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "245f158f0e08031548685ae415e98194feb1831db12f4563ecd7ab15b2630651", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -992,7 +992,7 @@ "gateway_version": "1.0.0-rc.2", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -1020,7 +1020,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "shared-file-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "aws-secrets-manager-v1" } } @@ -1076,7 +1076,7 @@ "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "42194bc83fbd821aaede008519091b4516baf914f8c2e27f3f2ac7a25f7485c3", "store_kind": "postgresql-v1", - "store_schema": "auths.lifecycle.postgresql/7", + "store_schema": "auths.lifecycle.postgresql/8", "credential_store_kind": "local-file-v1" } } diff --git a/compliance.toml b/compliance.toml index 8f905a351..877e84ca9 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/6", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/7", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/1", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/6", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/7", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/7", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1608,9 +1608,12 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +recovery-entry = [ + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", +] recovery-compilation = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] @@ -1960,7 +1963,7 @@ kind = "cargo" layer = "product" path = "product/stores/auths-stores" core_apis = ["auths-model"] -protocol_versions = ["auths-proof/v1", "auths.lifecycle.postgresql/7"] +protocol_versions = ["auths-proof/v1", "auths.lifecycle.postgresql/8"] wire_objects = ["AttestedDecisionReceipt", "AttestedExecutionReceipt", "LifecycleRecordV1", "GatewayRecordEntry"] fixture_suites = ["product/fixtures/v1/lifecycle"] principal_families = [] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 3db79c24b..4dbc4f5a4 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -356,3 +356,33 @@ checks as mutation compilation. The literal renderer and signing-request path remain shared. No new provider endpoint or read execution is introduced by this checkpoint; direct operator re-observation and ancillary reads still require the acquisition admission/entry cutover before completion. + + +## Recovery acquisition journal and entry + +The next cutover uses attempt journal `/7`: a common immutable header and entry +history with a closed typed mutation/acquisition payload. It uses the same +transition predicate, record codec and durable transaction ports. Acquisition +responses cannot become mutation observations through a protocol or stage tag. +Support bundle `/2` distinguishes the protocol in both counts and retained stages. + +One atomic admission stores the read claim and a permanent allocation holding +one invocation and the maximum response bytes. The allocation binds distinct +count and byte keys to the source effect; new read IDs share its fixed 16 slots. +The existing file batch and PostgreSQL transaction implement this insert. +PostgreSQL source schema `/8` adds the non-expiring allocation kind directly; +there is no migration/legacy reader. Sweeping does not refund allocations. + +The final read grant uses the existing writer fence over the read attempt, +source attempt, allocation and current installed dependencies. It rechecks the +exact source-derived target and fresh read authority. A durable acknowledgement +returns a one-use permit that the bounded transport consumes; a persisted grant +alone returns unknown history. Response bytes stay in the private journal and +do not themselves refine the mutation or authorize content disclosure. + +The runtime path refuses recipes requiring additional credential reads until +those have their own accounted acquisition paths. Source-evidence freshness, +credential replacement, managed bounds, public execution routes and removal of +existing raw observation/ancillary paths remain required work. The native file +corpus uses synthetic entry validation and response bytes; it is narrow durable +mechanism evidence, not an installed authority or transport claim. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 596e691e9..ef1f9f368 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -72,10 +72,13 @@ These are private authoring/review operations. They perform no credential lease, provider call or admission. The writer's proof or exact approval cannot serve as the read's authority. Source and current connection/generation must match in this compiler; changed credentials and managed read-policy bounds currently refuse. -A compiled read cannot be sent through mutation `submit`. Recovery execution and -accounting remain under implementation, so these commands are not a completed -recovery journey. Installed authenticated review, frontend, and full concurrency/ -fault evidence also remain open AP074 requirements. +A compiled read cannot be sent through mutation `submit`. The native runtime now +has a separate recovery acquisition entry point with permanent count/byte +allocation and a durable one-use grant. It refuses recipes needing additional +credential reads until those reads are accounted for. The commands above still +perform authoring/review only. Source-evidence refinement, public execution +routes, installed authenticated review, frontend, and full concurrency/fault +evidence remain open AP074 requirements. A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints @@ -149,11 +152,14 @@ held which key, is operator evidence and is not produced by this code. `AUTHS_POSTGRES_URL`, `AUTHS_POSTGRES_CA_PEM`, and `AUTHS_POSTGRES_SERVER_NAME`. Connections are TLS-only with certificate and server-name verification. The schema is - `auths.lifecycle.postgresql/7`; it installs only into an empty database. + `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/6`; a store holding obsolete records is refused as - corrupt, so the file store's attempts directory is recreated too. + `auths.gateway-attempt/7`; a store holding obsolete records is refused as + corrupt, so the file store's attempts directory is recreated too. The journal + keeps typed mutation/acquisition facts under one header. Recovery allocations + are permanent source-lifetime count/byte reservations and are never swept. + Support bundle `/2` reports protocol and stage separately. - **Several gateway processes** may serve from the same database. Each logical operation is claimed once, by an insert-once row; stage changes are compare-and-swap on the exact stored record. A second process that loses a diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 6ae90a48a..61a2a20ed 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -411,6 +411,48 @@ closure regeneration passed after that correction (one artifact-generation test) Existing direct operator re-observation and all ancillary reads still need replacement. No full acceptance gate, broad local suite or hosted CI is claimed. +## Recovery acquisition journal checkpoint + +- Attempt journal `/7` has one common immutable header, approval history, entry + audit and codec with closed mutation/acquisition state alternatives. Both + protocols use the existing kernel transition predicate and adapter fence. + Acquisition cannot acquire mutation observation facts or change protocol. + Support bundle `/2` projects protocol and stage separately. +- Recovery admission atomically inserts the read claim and one permanent + `auths.effect-allocation/1` slot charging one invocation and the bound maximum + response bytes. All read IDs share the source's 16-slot capacity. Equal replay + retains the original allocation; exhaustion records an uncharged refusal; + sweeping never refunds source-lifetime allocation. PostgreSQL source schema + `/8` admits this non-expiring kind; obsolete disposable schemas are rejected. +- A read grant fences the read record, exact observable source, allocation and + installed authority/configuration/connection dependencies. Only acknowledged + persistence returns a one-use read permit. Lost permits project unknown and + cannot be reconstructed. Bounded response bytes remain private; public facts + distinguish acquisition response from mutation observation and disclosure ACK. +- `GatewayEngine::acquire_recovery` now connects native read approval, admission, + custody, final grant, permit-consuming transport and response recording. + Recipes needing additional credential reads fail closed until those reads + have their own acquisition accounting. No application/operator execution route + or source-evidence refinement has been cut over by this checkpoint. +- The native recovery artifact generator passed on `964764f2` plus this source: + real signed reader proofs, file journal, repeated reservation without charging, + single grant and stale contender refusal, reopen after permit loss, concurrent + competition for the last 15 of 16 slots, no sweep refund, bounded private + response/replay and mixed-protocol support projection. Entry validation and + provider response are synthetic. This is not installed authority, actual + provider transport, independent-process or PostgreSQL execution evidence. +- Mutation entry/replay, attempt scenarios, stable/production codes, custody and + qualification schema/verification artifact generators also passed on this + source. Native mutation binding and final semantic-closure construction passed; + CLI approval-envelope construction matched the signed corpus exactly. The new + kernel protocol negative tests and revised Kani oracle are + authored, not executed. Translated formal artifacts and hosted CI remain open. +- Still required: admission/current-configuration ordering, safe replacement + credentials and managed read-policy bounds, freshness-bound refinement of the + source, all ancillary read cutovers, typed disclosure/ACK, authenticated UI and + bindings, installed fault/race evidence and final formal/CI gates. No A01–A22 + acceptance criterion is closed by this checkpoint. + ## Phase gates | Phase | State | Outstanding gate | @@ -418,7 +460,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Mutation grant and reservation restart wired | Public projections, independent recovery, installed fault/race evidence and formal links | -| P3 | Recovery compilation started | Acquisition admission/entry, disclosure/ACK; remove Python semantic owner | +| P3 | Recovery acquisition journal and runtime entry wired | Ancillary read/source-evidence cutover, disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -443,7 +485,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | | A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | -| A15 | Recovery actor differs; original authority revoked | Partial / native compiler fixture / compilation only | Bounded recovery entry, revocation and installed execution | +| A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file journal / synthetic entry only | Source refinement, revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 6502818af..f80afc3db 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -196,3 +196,23 @@ source mutation. Its source entry uses a test oracle and sends no provider request. It proves compilation only: conserved acquisition charging, fresh transactional read entry, credential replacement, installed review channels and bounded observation execution remain open evidence gates. + + +## Recovery acquisition mechanism checkpoint + +The shared journal now encodes typed mutation/acquisition payloads under one +header, codec and transition predicate. The concrete recovery-read payload +binds the full source, request and capacity plan. It does not reuse mutation +observation facts or introduce a second transition reducer. Permanent allocation +slots conserve one call and its maximum bytes together; the source effect, not +the read operation ID, owns capacity. The final existing adapter fence compares +the exact source/claim/allocation and fresh authority before granting a permit. + +`bindings/fixtures/gateway/recovery-entry.json` is constructed by the native +recovery fixture using signed proofs and the real file adapter. Its entry check +and provider response are synthetic. It exercises same-reservation replay, +stale grant refusal, permit loss/reopen, 16 concurrent contenders for 15 remaining +slots, permanent retention, private response history and mixed-protocol stage +projection. It establishes neither provider execution nor installed revocation, +PostgreSQL parity, process crash behavior, source-evidence freshness or disclosure. +Those remain required independent evidence and cutover gates. diff --git a/product/qualification/auths-recipe-qualification/src/vectors/mod.rs b/product/qualification/auths-recipe-qualification/src/vectors/mod.rs index d37c09620..c2d1e5a55 100644 --- a/product/qualification/auths-recipe-qualification/src/vectors/mod.rs +++ b/product/qualification/auths-recipe-qualification/src/vectors/mod.rs @@ -280,7 +280,7 @@ pub(super) fn target() -> QualificationTarget { gateway_version: bounded("1.0.0-rc.1"), gateway_build_sha256: digest_of("gateway build"), store_kind: LifecycleStoreKind::PostgresqlV1, - store_schema: bounded("auths.lifecycle.postgresql/7"), + store_schema: bounded("auths.lifecycle.postgresql/8"), credential_store_kind: CredentialStoreKind::AwsSecretsManagerV1, } } diff --git a/product/runtime/auths-gateway-kernel/src/transition.rs b/product/runtime/auths-gateway-kernel/src/transition.rs index 768fa5d7c..e6070d792 100644 --- a/product/runtime/auths-gateway-kernel/src/transition.rs +++ b/product/runtime/auths-gateway-kernel/src/transition.rs @@ -14,6 +14,15 @@ use alloc::vec::Vec; +/// Closed external boundary whose facts a journal record may carry. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Protocol { + /// A provider mutation may be refined by separate observation evidence. + Mutation, + /// A bounded acquisition records a response, never mutation success. + Acquisition, +} + /// The stage of an attempt record. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum Stage { @@ -60,6 +69,8 @@ pub enum Link { /// The fields of one stored attempt record the transition rule inspects. #[derive(Clone, Debug, Eq, PartialEq)] pub struct AttemptView { + /// Typed protocol; transitions cannot change it. + pub protocol: Protocol, /// Monotonic journal revision, bounded to exact JSON integers. pub revision: u64, /// Canonical bytes of the fields no transition may change. @@ -229,7 +240,8 @@ pub const fn has_reading(reading: Reading) -> bool { #[must_use] pub fn consistent(view: &AttemptView) -> bool { let has_response = !absent(&view.response); - view.revision > 0 + protocol_consistent(view) + && view.revision > 0 && view.revision <= 9_007_199_254_740_991 && requires_entry(view.stage) == !absent(&view.entry) && refusal_stage(view.stage) == view.refusal @@ -243,6 +255,38 @@ pub fn consistent(view: &AttemptView) -> bool { && (!view.evidence || has_response || resolves_unknown(view.link)) } +/// Acquisition cannot carry mutation observations, locators or pre-entry reads. +#[must_use] +pub fn protocol_consistent(view: &AttemptView) -> bool { + match view.protocol { + Protocol::Mutation => true, + Protocol::Acquisition => { + matches!( + view.stage, + Stage::Reserved + | Stage::EntryGranted + | Stage::NotEntered + | Stage::Unknown + | Stage::ResponseRecorded + ) && absent(&view.pre_entry) + && absent(&view.locator) + && !view.observation + && !view.evidence + && matches!(view.reading, Reading::None) + && matches!(view.link, Link::None) + } + } +} + +/// Protocol identity is immutable independently of the encoded fixed fields. +#[must_use] +pub const fn same_protocol(left: Protocol, right: Protocol) -> bool { + matches!( + (left, right), + (Protocol::Mutation, Protocol::Mutation) | (Protocol::Acquisition, Protocol::Acquisition) + ) +} + /// Whether the state requires an immutable entry grant. #[must_use] pub const fn requires_entry(stage: Stage) -> bool { @@ -363,7 +407,8 @@ pub const fn link_equal(left: Link, right: Link) -> bool { /// consistent with its stage. #[must_use] pub fn valid_transition(old: &AttemptView, new: &AttemptView) -> bool { - old.revision < 9_007_199_254_740_991 + same_protocol(old.protocol, new.protocol) + && old.revision < 9_007_199_254_740_991 && new.revision == old.revision + 1 && consistent(old) && entry_kept(old, new) @@ -398,6 +443,7 @@ mod tests { Vec::new() }; AttemptView { + protocol: Protocol::Mutation, revision: 1, entry: if requires_entry(stage) { alloc::vec![7] @@ -427,6 +473,43 @@ mod tests { valid_transition(old, &next) } + #[test] + fn acquisition_cannot_gain_mutation_facts_or_change_protocol() { + let acquisition = |stage| { + let mut value = view(stage, Link::None); + value.protocol = Protocol::Acquisition; + value.observation = false; + value + }; + let reserved = acquisition(Stage::Reserved); + let granted = acquisition(Stage::EntryGranted); + let response = acquisition(Stage::ResponseRecorded); + assert!(transition(&reserved, &granted)); + assert!(transition(&granted, &response)); + assert!(!transition( + &reserved, + &view(Stage::EntryGranted, Link::None) + )); + assert!(!transition(&view(Stage::Reserved, Link::None), &granted)); + for stage in [Stage::Observed, Stage::ObservedByProvider] { + assert!(!consistent(&acquisition(stage))); + assert!(!transition(&response, &acquisition(stage))); + } + let mut checkpoint = reserved.clone(); + checkpoint.pre_entry = vec![9]; + assert!(!consistent(&checkpoint)); + assert!(!transition(&reserved, &checkpoint)); + let mut changed = response.clone(); + changed.locator = vec![1]; + assert!(!transition(&granted, &changed)); + changed = response.clone(); + changed.observation = true; + assert!(!consistent(&changed)); + changed = response.clone(); + changed.link = Link::Verified; + assert!(!consistent(&changed)); + } + #[test] fn revisions_advance_once_and_never_wrap() { let old = view(Stage::Reserved, Link::None); @@ -568,6 +651,11 @@ mod proofs { fn any_view() -> AttemptView { AttemptView { + protocol: if kani::any() { + Protocol::Mutation + } else { + Protocol::Acquisition + }, revision: kani::any(), entry: any_bytes(), fixed: any_bytes(), @@ -628,7 +716,20 @@ mod proofs { && (response || view.link == Link::Verified) } }; + let protocol = match view.protocol { + Protocol::Mutation => true, + Protocol::Acquisition => { + !matches!(view.stage, Stage::Observed | Stage::ObservedByProvider) + && view.pre_entry.is_empty() + && view.locator.is_empty() + && view.reading == Reading::None + && !view.evidence + && !view.observation + && view.link == Link::None + } + }; shape + && protocol && view.revision > 0 && view.revision <= 9_007_199_254_740_991 && (view.locator.is_empty() || response) @@ -687,6 +788,7 @@ mod proofs { let expected = old.revision < 9_007_199_254_740_991 && new.revision == old.revision + 1 && old.fixed == new.fixed + && old.protocol == new.protocol && entry && fields_match_stage(&old) && old.observation == new.observation diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index e1ba42735..72fc68290 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"entry-granted","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index cacf47688..cf1137e70 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"not-entered","entry":null,"refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index b69ead6cc..0bbd09fe7 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"reserved","entry":null,"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 3a5d7bfea..6bd61f32c 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"response-recorded","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 2380f476c..192705591 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/6","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"stage":"unknown","entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 925fa2558178a04071289be3404f92183595c893..7cf858e1dd3d651e41bb68a20d22343285b3c953 100644 GIT binary patch delta 159 zcmZ2%^xcSsfq|!KB8wiQ`Q~n(jqIEMu-{>_EiOqcNma6{Rw^jUFUe2N&rz~c$}I&7 zX6EN9=_sWoCYKb0q=D+vf$Ee}^Gb>;b<>Ly^GZ@vHqQ}nXPg|xV}NX=I*~?Bwic1y MY$E=ik*T&80CZqC@&Et; delta 77 zcmexvwAhG+fq^GtB8wiQ+2*Z08`;H*OA^ylm8_If^Gb>;b<>Ly^GZ@vls2b`++*7O cQM`q5avKj!?c^+Rnayb;cbGP}iN9wA0P8~=7XSbN diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 8aecce6d3e5a4ee97410f5d2273c28c695c97a4d..25f6f5435ba3efb62da06bacdfe06823263c5a20 100644 GIT binary patch delta 173 zcmZ2y*kr`Qz`)ZqkwuTud~-L?M)u8qB6pbVic1npQkAT#l?saTOY)QRbCj%?^Y(!A`v M{PH}AX-u`X0HYH+b^rhX delta 88 zcmZoNT4%_@z`zqRkwuTuZ1Yy0jqGB@C5h>&N>)m#c_l@ay6HuUc_pbSN}E$e?lEoR YZeg6<#sgC-08?6;mz|eio`+Bb0ODdDQ~&?~ diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 176c47a9e7af52211061c145fd5a95a0322f5e32..6fd46e6b827db33fce9ed07481c8bb703cc270a2 100644 GIT binary patch delta 182 zcmaE$y+wzGfq`?~L>4_p^Ud2iH?q5>=9LsxDp}=~=H%!o6_+HIq$*ieD-{&wm*gks z=O|ez<(2{kGxPJ5bd=H(lS_(0(m-|TKy^w*sl};9WvMAjo1;Y97$>)J8bFQR+#q;| W$&OUxz;4k^FG|cSftkrvTMGbH@;?Cp delta 99 zcmdm@^FW)0fq}DSB8wiQ+2)6w8`;m8|kgb8>W)ic1npQkAT#l?saTOY)QR zbCj%&N>)lmsl};9WvMAjI!dW|B}J7=R(Yj4 hIh(aO+88Hq;)E$zgelL bool { ) } -const FIXED: [&str; 10] = [ +const FIXED: [&str; 9] = [ "schema", "binding_canonical", "approval_canonical", @@ -48,7 +48,6 @@ const FIXED: [&str; 10] = [ "recipe_digest", "nonce", "evaluated_at", - "counters", ]; fuzz_target!(|data: &[u8]| { @@ -77,6 +76,11 @@ fuzz_target!(|data: &[u8]| { if from != Stage::Reserved || to != Stage::EntryGranted { assert_eq!(old.get("entry"), new.get("entry"), "entry grant changed"); } + assert_eq!(old["state"]["protocol"], new["state"]["protocol"]); + assert_eq!( + old["state"]["facts"]["counters"], + new["state"]["facts"]["counters"] + ); for field in FIXED { assert_eq!(old.get(field), new.get(field), "{field} changed"); } diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 55e42604f..86d26e812 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"6b17592e0e2fdf17b6ed8f59d2bf3e2753b53f5936846f3c53f604178fcde034"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0bc408ce7a8a6e52426be04e79bc0b89e143fc43c76aab1cd6a757f462a90061"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"71755a8f82c58a38368e4b24a9cb9b522b8d8c584f02539019b73261c34300b1"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"38e73f84dd9f9adeea0b80d7d3e6216b27fb19dfc2e3af6cd23daebd014df8ae"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"9a12ec3ab75ce6c66176411cff4580d8803e8de9f0bcb60ac3a81ebdaaf970b1"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"6300b64c4302486e79d0fce6ed7b3516eafd1636a289c6371213a2577abb177d"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"378156793dfe62e11e8f6c9b0d79be4124ef9a057b9496d011d9a6bc1ca6f050"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"53ec5be090cc83a44b2d82e64fc6c3ffe557a7c14a3b2a97f51274fe98e28658"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"326ad8806fec2fd01379c7d89dedfbee5ee33766b8a2a2374dc8e1f8af90c05b"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"3e629b1b0da30802cc5dc1167e80c09381a88ada236f9c2d24b2fb819bfb09c5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"8afb57388a036f872522d81e291f09beed45417ae66a6d4a327749781b69792f"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"046fdc1d06ac1658856cf13a01db18aeb1ea3f78a6fa7c395833c15e0a461964"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"61bd6ad144cf064806d72342882b67192d669ac5cb4b5d1de6af5a8b09249946"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"ead73266efa205dc8c7761899dd91e0e9b388945cd20761b017f338179ff62f3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"21298dc8c5bcfdee81d31e714f11b79d664501d1db6dfdd5593d07639819d13d"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"fa9fa6768e38179de46dc7f9539865b23ea7ddaedbf36b75f1c2dd3527ac1959"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"a8c57727feb8eadb2a30a10ad133bfb71317b4f6ad3c5f9a83f4bd935ce24325"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"9ff268d06706d3232da1ccf43b3f160c17c455721f16167fe1ca7b1dfd8b7fb5"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"454d4ae223b96e970e8cad8775bfa71201d14435aa8d3a22f98fdbfd147ce05a"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"c3f1afeb2c7b8a4a4a667c32bda5fc1e976271c85fa7d616d5a9db425ab95653"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0bc408ce7a8a6e52426be04e79bc0b89e143fc43c76aab1cd6a757f462a90061"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"210880c01803c7f7ef7acef5886a05c347db66af709b1316885f3b23ca32e4ff"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"d2f34174f9111240f054e8e959a3ce861f84187ddb735b210483f07f9a434bc2"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4ac0e694b8152698b946d29c78d667a814e2ae960eccd47ec99792bf26b595a7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"5fe809d9e07c2b73bbadc9ddd51e627e34df2c413771e5c62e91d89329bdf9b0"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"07e37424f7c7487a5cd600aa58cbd2bad2f3e714cd22916097180049d173c8e2"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"d202c236a634379634fcbdf6803736bb63e50c839502bfe6ba3bfea0219ae516"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"11442e9254c29f6eb09e862b599e21a761093a629ea3d559c96507ab56e0289e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b85bae6de739ff345dd97583009c58c3b22af92e3c06a4c81426eeeea4cb7dcf"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"61bd6ad144cf064806d72342882b67192d669ac5cb4b5d1de6af5a8b09249946"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"eada49a01083d7869d256e1831e56c0a4507b4e2170ff5bbbc0baeb780fd08c5"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"49b7f36a682a746b5023d6361e07453348f9962505d21a90a7e18cc5c0783591"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"a41b864c32929dd2c7895cb354319a6fc8d89d80366bc54edff06253e2f20566"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"72138d516eabe700ac516d4a6b13654a1eaae9c9fa33e0269187005bfb0d1bbf"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 8f7f4462a..2fe5f85d1 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -19,7 +19,7 @@ use std::fmt; use zeroize::Zeroizing; mod acquisition; -pub(crate) use acquisition::RECOVERY_READ_TOOL; +pub(crate) use acquisition::{RECOVERY_READ_TOOL, RecoveryCapacity, RecoveryPlan}; pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; /// Only accepted effect binding schema. Old disposable state is rejected. @@ -454,6 +454,10 @@ fn canonical(value: &T) -> Result>, EffectBindin } impl EffectBinding { + pub(crate) fn is_mutation(&self) -> bool { + matches!(self.wire.protocol, Protocol::Mutation { .. }) + } + pub(crate) fn journal_identity(&self) -> (&str, &str, &[u8; 32], &[u8; 32]) { ( &self.wire.namespace, @@ -988,6 +992,13 @@ impl ApprovedEffect { } } + pub(crate) fn recovery_target(&self) -> Option<&RecoveryReadTarget> { + match &self.effect.command { + CompiledEffect::Mutation(_) => None, + CompiledEffect::Acquisition(command) => Some(&command.target), + } + } + pub(crate) fn connection(&self) -> &ConnectionRecord { &self.effect.connection } diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 3b8f4a868..a67b0600e 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -83,6 +83,27 @@ impl RecoveryReadTarget { }) } + pub(crate) fn closed_request(&self) -> &crate::ClosedObservationRequest { + &self.request + } + + pub(crate) fn journal_plan(&self) -> Result { + Ok(RecoveryPlan { + source_binding: String::from_utf8(self.source.to_private_bytes()?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + request: commitment( + "auths.effect-acquisition-request/1", + &canonical(&self.read_wire())?, + )?, + contract: commitment( + "auths.gateway-recovery-read/1", + &canonical(&self.contract())?, + )?, + maximum_response_bytes: u64::try_from(self.request.maximum_response_bytes()) + .map_err(|_| EffectBindingError::Invalid)?, + }) + } + fn binding( &self, installed: &EffectInstallation<'_>, @@ -105,34 +126,8 @@ impl RecoveryReadTarget { { return Err(invalid()); } - let maximum = - u64::try_from(self.request.maximum_response_bytes()).map_err(|_| invalid())?; - let reservations = [ - (Unit::AcquisitionCount, 1, MAX_RECOVERY_ATTEMPTS), - ( - Unit::ResponseBytes, - maximum, - MAX_RECOVERY_ATTEMPTS * maximum, - ), - ] - .into_iter() - .map(|(unit, amount, ceiling)| { - Ok(Reservation { - key: commitment( - "auths.recovery-capacity/1", - &canonical(&(self.source.id().as_bytes(), unit))?, - )?, - unit, - amount, - ceiling, - window: ReservationWindow::SourceLifetime, - }) - }) - .collect::, EffectBindingError>>() - .map_err(|_| invalid())?; - let mut reservations = reservations; - reservations.sort_by_key(|entry| (entry.key, entry.unit)); - let contract = self.contract(); + let plan = self.journal_plan().map_err(|_| invalid())?; + let capacity = plan.capacity().map_err(|_| invalid())?; EffectBinding::new(BindingWire { schema: EFFECT_BINDING_SCHEMA.to_owned(), namespace: installed.recipe.namespace().as_str().to_owned(), @@ -151,19 +146,11 @@ impl RecoveryReadTarget { approval_policy: ApprovalPolicy::Exact { approver: installed.approver, }, - reservations, + reservations: capacity.reservations(), protocol: Protocol::Acquisition { - request: commitment( - "auths.effect-acquisition-request/1", - &canonical(&self.read_wire()).map_err(|_| invalid())?, - ) - .map_err(|_| invalid())?, - projection: commitment( - "auths.gateway-recovery-read/1", - &canonical(&contract).map_err(|_| invalid())?, - ) - .map_err(|_| invalid())?, - maximum_response_bytes: maximum, + request: plan.request, + projection: plan.contract, + maximum_response_bytes: plan.maximum_response_bytes, }, }) .map_err(|_| invalid()) @@ -207,6 +194,101 @@ impl RecoveryReadTarget { } } +/// Private immutable journal projection of the native recovery compiler. It +/// carries no proof or transport capability and is checked against the binding. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct RecoveryPlan { + pub(crate) source_binding: String, + request: [u8; 32], + contract: [u8; 32], + maximum_response_bytes: u64, +} + +pub(crate) struct RecoveryCapacity { + pub(crate) count_key: [u8; 32], + pub(crate) bytes_key: [u8; 32], + pub(crate) maximum_bytes: u64, + pub(crate) attempts: u64, +} + +impl RecoveryPlan { + pub(crate) fn source(&self) -> Result { + EffectBinding::from_private_bytes(self.source_binding.as_bytes()) + } + + pub(crate) fn capacity(&self) -> Result { + let source = self.source()?; + if !(1..=65_536).contains(&self.maximum_response_bytes) + || !matches!(source.wire.protocol, Protocol::Mutation { .. }) + { + return Err(EffectBindingError::Invalid); + } + let key = |unit| { + commitment( + "auths.recovery-capacity/1", + &canonical(&(source.id().as_bytes(), unit))?, + ) + }; + Ok(RecoveryCapacity { + count_key: key(Unit::AcquisitionCount)?, + bytes_key: key(Unit::ResponseBytes)?, + maximum_bytes: self.maximum_response_bytes, + attempts: MAX_RECOVERY_ATTEMPTS, + }) + } + + pub(crate) fn validate( + &self, + effect: &EffectBinding, + ) -> Result { + let source = self.source()?; + let capacity = self.capacity()?; + if source.wire.namespace != effect.wire.namespace + || source.wire.partition != effect.wire.partition + || source.wire.epoch != effect.wire.epoch + || source.wire.recipe != effect.wire.recipe + || source.wire.credential_generation != effect.wire.credential_generation + || source.wire.scope != effect.wire.scope + || source.wire.connection != effect.wire.connection + || source.wire.operation == effect.wire.operation + || effect.wire.protocol + != (Protocol::Acquisition { + request: self.request, + projection: self.contract, + maximum_response_bytes: self.maximum_response_bytes, + }) + || effect.wire.reservations != capacity.reservations() + { + return Err(EffectBindingError::Invalid); + } + Ok(capacity) + } +} + +impl RecoveryCapacity { + fn reservations(&self) -> Vec { + let mut reservations = vec![ + Reservation { + key: self.count_key, + unit: Unit::AcquisitionCount, + amount: 1, + ceiling: self.attempts, + window: ReservationWindow::SourceLifetime, + }, + Reservation { + key: self.bytes_key, + unit: Unit::ResponseBytes, + amount: self.maximum_bytes, + ceiling: self.attempts * self.maximum_bytes, + window: ReservationWindow::SourceLifetime, + }, + ]; + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + reservations + } +} + pub(super) struct VerifiedAcquisition { pub(super) target: RecoveryReadTarget, #[cfg(unix)] diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 3591a44ca..0c960edec 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -253,7 +253,7 @@ async fn native_recovery_acquisition_fixture_is_current() { .read(recipe.namespace(), &operation) .await .expect("read"), - Some(before) + Some(before.clone()) ); let fixture = json!({ "schema": "auths.gateway-recovery-compilation-fixture/1", @@ -273,6 +273,225 @@ async fn native_recovery_acquisition_fixture_is_current() { std::fs::write(&path, &bytes).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), bytes); + let mut reads = vec![Arc::new(approved)]; + for index in 2..=17 { + let call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse(&format!("read-{index}")).expect("read operation"), + ) + .expect("native read call"); + let read = submission_for_call(&root, &reader, &read_grant, &call, &[]); + let effect = compile_recovery_acquisition( + &read_installation, + &target, + NOW + 2, + &read.proof, + &read.action, + ) + .expect("native read effect"); + let request = effect + .approval_request(NOW + 2, NOW + 100) + .expect("read request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + reads.push(Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW + 2) + .expect("exact read approval"), + )); + } + let corpus = exercise_recovery_journal(&attempts, &root_path, policy.clone(), reads).await; + assert_eq!( + attempts + .read(recipe.namespace(), &operation) + .await + .expect("source read"), + Some(before) + ); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/recovery-entry.json"); + let bytes = serde_json::to_vec_pretty(&corpus).expect("recovery entry corpus"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write recovery entry corpus"); + } + assert_eq!(std::fs::read(path).expect("recovery entry corpus"), bytes); +} + +/// Real file-journal race and restart evidence. Both source and read entry use +/// a test validation oracle, and the response is synthetic; no installed +/// credential, real provider call or source observation is claimed. +#[allow( + clippy::too_many_lines, + reason = "one bounded native journal history produces the corpus" +)] +async fn exercise_recovery_journal( + attempts: &crate::GatewayAttempts, + path: &std::path::Path, + policy: EffectPolicy, + reads: Vec>, +) -> Value { + use crate::{AcquisitionClaim, AcquisitionStage}; + use std::sync::Arc; + let first = Arc::clone(&reads[0]); + let AcquisitionClaim::Reserved(reserved) = attempts + .claim_recovery(&first, NOW + 2) + .await + .expect("reserve read") + else { + panic!("reserved read"); + }; + let reserved_view = reserved.snapshot().expect("snapshot"); + assert_eq!(reserved_view.stage, AcquisitionStage::Reserved); + assert_eq!(reserved_view.reserved_calls, 1); + let AcquisitionClaim::Reserved(stale) = attempts + .claim_recovery(&first, NOW + 2) + .await + .expect("reopen equal read") + else { + panic!("reopened read"); + }; + assert_eq!(stale.snapshot().expect("snapshot"), reserved_view); + let (granted, permit) = reserved + .grant_entry( + Arc::clone(&first), + crate::entry::EntryValidation::Oracle { now: NOW + 3 }, + NOW + 2, + ) + .await + .expect("unique read grant"); + assert!(permit.request().url().starts_with("https://")); + drop(permit); + drop(granted); + assert!( + stale + .grant_entry( + Arc::clone(&first), + crate::entry::EntryValidation::Oracle { now: NOW + 3 }, + NOW + 2 + ) + .await + .is_err() + ); + let reopened = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(path).expect("reopened file store")), + policy, + ) + .expect("attempt owner"); + let AcquisitionClaim::Existing(replay) = reopened + .claim_recovery(&first, NOW + 3) + .await + .expect("replay after permit loss") + else { + panic!("history only"); + }; + assert_eq!(replay.stage, AcquisitionStage::Unknown); + assert_eq!(replay.revision, 2); + assert_eq!(replay.reserved_calls, 1); + assert_eq!(replay.reserved_bytes, reserved_view.reserved_bytes); + assert_eq!( + reopened + .sweep_expired(NOW + 864_000, 1024) + .await + .expect("sweep"), + 0 + ); + let mut tasks = tokio::task::JoinSet::new(); + for (index, approved) in reads.iter().enumerate().skip(1) { + let approved = Arc::clone(approved); + let attempts = reopened.clone(); + tasks.spawn(async move { + ( + index, + attempts + .claim_recovery(&approved, NOW + 2) + .await + .expect("race admission"), + ) + }); + } + let mut winners = Vec::new(); + let mut exhausted = 0; + while let Some(result) = tasks.join_next().await { + let (index, claim) = result.expect("joined race"); + match claim { + AcquisitionClaim::Reserved(reserved) => winners.push((index, reserved)), + AcquisitionClaim::Existing(snapshot) => { + assert_eq!(snapshot.stage, AcquisitionStage::NotEntered); + assert_eq!(snapshot.reserved_calls, 0); + assert_eq!(snapshot.reserved_bytes, 0); + exhausted += 1; + } + } + } + assert_eq!(winners.len(), 15); + assert_eq!(exhausted, 1); + winners.sort_by_key(|(index, _)| *index); + let (index, reserved) = winners.remove(0); + let (granted, permit) = reserved + .grant_entry( + Arc::clone(&reads[index]), + crate::entry::EntryValidation::Oracle { now: NOW + 3 }, + NOW + 2, + ) + .await + .expect("response case grant"); + drop(permit); + let response = granted + .record_response(200, true, b"{}", NOW + 4) + .await + .expect("synthetic response record"); + assert_eq!(response.stage, AcquisitionStage::ResponseRecorded); + assert_eq!(response.response_bytes, Some(2)); + assert_eq!(response.reserved_calls, 1); + assert_eq!(response.reserved_bytes, reserved_view.reserved_bytes); + let AcquisitionClaim::Existing(history) = reopened + .claim_recovery(&reads[index], NOW + 4) + .await + .expect("response replay") + else { + panic!("response history only"); + }; + assert_eq!(history, response); + let mut retained_calls = 0; + let mut retained_bytes = 0; + for approved in &reads { + let snapshot = reopened + .read_recovery(approved) + .await + .expect("read history") + .expect("record"); + retained_calls += snapshot.reserved_calls; + retained_bytes += snapshot.reserved_bytes; + } + assert_eq!(retained_calls, 16); + assert_eq!(retained_bytes, 16 * reserved_view.reserved_bytes); + let stages = reopened.stages(64).await.expect("mixed journal projection"); + let mutation_count = stages + .iter() + .filter(|(_, stage)| matches!(stage, crate::GatewayOperationStage::Mutation(_))) + .count(); + let acquisition_count = stages + .iter() + .filter(|(_, stage)| matches!(stage, crate::GatewayOperationStage::Acquisition(_))) + .count(); + assert_eq!((mutation_count, acquisition_count), (1, 17)); + assert!(!stages.iter().any(|(_, stage)| matches!( + stage, + crate::GatewayOperationStage::Acquisition(AcquisitionStage::EntryGranted) + ))); + json!({ + "schema": "auths.recovery-entry-fixture/1", + "scope": "native read proofs and file journal; synthetic entry validation and response; no provider or installed-authority claim", + "admission": {"calls": 1, "bytes": reserved_view.reserved_bytes, "reopen_does_not_charge": true}, + "permit_loss": {"stage": "unknown", "revision": replay.revision, "stale_grant_refused": true}, + "race": {"remaining_capacity": 15, "contenders": 16, "winners": 15, "exhausted": exhausted}, + "retention": {"calls": retained_calls, "bytes": retained_bytes, "sweep_removed": 0}, + "response": {"stage": "response-recorded", "revision": response.revision, "received_bytes": 2, "replay_preserves_facts": true}, + "source_journal_unchanged": true, + "mixed_projection": {"mutations": mutation_count, "acquisitions": acquisition_count, "grants_project_unknown": true}, + }) } fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 039d9e82a..295a2068a 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1351,6 +1351,138 @@ impl GatewayEngine { ) } + /// Acquires one separately authorized bounded recovery response. The result + /// describes acquisition only; it does not disclose content or record a + /// mutation observation. Replay reads only the existing journal. + /// + /// # Errors + /// Refuses native/approval/configuration failures before admission. Missing + /// or unavailable state after uncertain persistence is indeterminate. + /// Recipes requiring additional credential reads currently fail closed; + /// those reads require their own acquisition admission before this path can + /// support them. + pub async fn acquire_recovery( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self + .compile_recovery_effect(source_operation, proof, action) + .await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + let reads = self + .recipe + .credential_reads() + .map_err(|_| not_entered("gateway.acquisition.binding"))?; + if reads.probe().is_some() || reads.account().is_some() || !reads.denied().is_empty() { + return match self.attempts.read_recovery(&approved).await { + Ok(Some(snapshot)) => Ok(snapshot), + Ok(None) => Err(not_entered("gateway.acquisition.ancillary-required")), + Err(_) => Err(GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }), + }; + } + let reserved = match self.attempts.claim_recovery(&approved, now).await { + Ok(crate::AcquisitionClaim::Existing(snapshot)) => return Ok(snapshot), + Ok(crate::AcquisitionClaim::Reserved(reserved)) => reserved, + Err(crate::GatewayAttemptError::BindingConflict) => { + return Err(not_entered("gateway.effect.operation-conflict")); + } + Err(_) => return self.recovery_projection(&approved).await, + }; + match self + .run_recovery_reservation(*reserved, Arc::clone(&approved), now, started) + .await + { + Ok(snapshot) => Ok(snapshot), + Err(_) => self.recovery_projection(&approved).await, + } + } + + async fn recovery_projection( + &self, + approved: &ApprovedEffect, + ) -> Result { + self.attempts + .read_recovery(approved) + .await + .ok() + .flatten() + .ok_or_else(|| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }) + } + + async fn run_recovery_reservation( + &self, + reserved: crate::ReservedAcquisition, + approved: Arc, + now: u64, + started: Instant, + ) -> Result { + let io = EngineIo { + engine: self, + pending: std::sync::Mutex::new(None), + started, + prepared: OnceLock::new(), + #[cfg(unix)] + commissioning: None, + #[cfg(unix)] + commissioned_action: OnceLock::new(), + #[cfg(unix)] + commissioning_refusal: OnceLock::new(), + }; + io.prepare().await?; + let fresh = io.clock().ok_or("gateway.verify.clock-unavailable")?; + io.revalidate(&approved, fresh) + .map_err(|_| "gateway.effect.authority-unavailable")?; + let _flight = submit::InFlight::enter(&io); + let lease = io.lease().await.ok_or("gateway.credential.unavailable")?; + if self + .recipe + .guard_checks() + .as_ref() + .is_some_and(|guard| !io.secret_admitted(&lease, guard)) + { + return Err("gateway.credential.mode-guard"); + } + let validation = io.entry_validation()?; + let (granted, permit) = reserved + .grant_entry(approved, validation, now) + .await + .map_err(|_| "gateway.entry.unavailable")?; + let prepared = io.prepared.get().ok_or("gateway.entry.unprepared")?; + match prepared.transport.recovery_read(permit, &lease).await { + Some(response) => match io.clock() { + Some(received_at) => { + granted + .record_response( + response.status, + response.version_ok, + &response.body, + received_at, + ) + .await + } + None => granted.record_unknown().await, + }, + None => granted.record_unknown().await, + } + .map_err(|_| "gateway.attempt.state-unavailable") + } + async fn recovery_compilation_target( &self, source_operation: &str, diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index c03280205..83fc30b49 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -228,6 +228,7 @@ async fn reservation_restart(backend: Backend) -> serde_json::Value { granted .attempt .record + .state .pre_entry .as_ref() .expect("initial evidence") @@ -342,7 +343,10 @@ async fn native_entry_fixture_is_current() { let store = TestAttempts::open(Backend::File); let approved = approved(); let claim = reserved(store.attempts(), &approved).await; - assert_eq!(claim.attempt.record.stage, GatewayAttemptStage::Reserved); + assert_eq!( + claim.attempt.record.state.stage, + GatewayAttemptStage::Reserved + ); assert!(claim.attempt.record.entry.is_none()); let stale = stale_copy(&claim); let (granted, permit) = claim @@ -355,7 +359,7 @@ async fn native_entry_fixture_is_current() { .await .expect("grant"); assert_eq!( - granted.attempt.record.stage, + granted.attempt.record.state.stage, GatewayAttemptStage::EntryGranted ); assert_eq!( @@ -396,8 +400,8 @@ async fn native_entry_fixture_is_current() { assert_eq!(read.stage(), GatewayAttemptStage::Unknown); let mut next = granted.attempt.record.clone(); next.revision += 1; - next.stage = GatewayAttemptStage::NotEntered; - next.refusal = Some("test.no-send".to_owned()); + next.state.stage = GatewayAttemptStage::NotEntered; + next.state.refusal = Some("test.no-send".to_owned()); assert!(!valid_transition(&granted.attempt.record, &next).expect("transition")); // Canonical native records also seed the shipping decoder/transition fuzzer. // The nonce is private replay evidence, independent of signed effect bytes; @@ -406,20 +410,20 @@ async fn native_entry_fixture_is_current() { entry.nonce = "00112233445566778899aabbccddeeff".to_owned(); let mut reserved = entry.clone(); reserved.revision = 1; - reserved.stage = GatewayAttemptStage::Reserved; + reserved.state.stage = GatewayAttemptStage::Reserved; reserved.entry = None; let mut refused = reserved.clone(); refused.revision = 2; - refused.stage = GatewayAttemptStage::NotEntered; - refused.refusal = Some("test.before-grant".to_owned()); + refused.state.stage = GatewayAttemptStage::NotEntered; + refused.state.refusal = Some("test.before-grant".to_owned()); let mut unknown = entry.clone(); unknown.revision = entry.revision + 1; - unknown.stage = GatewayAttemptStage::Unknown; + unknown.state.stage = GatewayAttemptStage::Unknown; let mut response = entry.clone(); response.revision = entry.revision + 1; - response.stage = GatewayAttemptStage::ResponseRecorded; - response.response_status = Some(200); - response.response_digest = Some(hex::encode([9; 32])); + response.state.stage = GatewayAttemptStage::ResponseRecorded; + response.state.response_status = Some(200); + response.state.response_digest = Some(hex::encode([9; 32])); let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/target_gateway_attempt"); let write_seed = |name: &str, bytes: &[u8]| { diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 7cbef1155..6ae25ee27 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -138,13 +138,14 @@ pub use separation::{ principals_overlap, }; pub use store::{ - ClaimedGatewayAttempt, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, - GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, - GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, - GatewayInsert, GatewayObservationFact, GatewayPreEntry, GatewayProviderEvidence, + AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, ClaimedGatewayAttempt, + FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptSnapshot, + GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, GatewayCounterEntry, + GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, GatewayInsert, + GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRelativeBasis, ObservableGatewayAttempt, - PostgresGatewayAttemptStore, PrivateDirectoryError, check_private_directory, - check_private_directory_owned_by, pre_entry_digest, + PostgresGatewayAttemptStore, PrivateDirectoryError, ReservedAcquisition, + check_private_directory, check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 79ff31ce1..21bc4419a 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -18,7 +18,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/6"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/7"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index a1a75b364..3450f991a 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -28,6 +28,8 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ "gateway.acquisition.binding effect compile new 74 -", + "gateway.acquisition.exhausted effect admission new 74 -", + "gateway.acquisition.ancillary-required effect before-claim new 74 -", "gateway.acquisition.unsupported-bounds effect compile new 74 -", "gateway.effect.protocol effect before-claim new 74 -", "gateway.recipe.echo-conflict GatewayRecipeError compile existing - R:form-echo-existing-field", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 82b978732..e250ecc94 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -23,9 +23,9 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-policy"; /// The schema identifier of the production lifecycle store. -pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/7"; +pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/6"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/7"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 210423290..5012611d2 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/6", + "store_schema": "auths.gateway-attempt/7", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index e53d7dc2c..3450f32e5 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -88,7 +88,7 @@ impl RecordingStore { fn stage_of(bytes: &[u8]) -> Option { serde_json::from_slice::(bytes) .ok()? - .get("stage")? + .pointer("/state/facts/stage")? .as_str() .map(str::to_owned) } @@ -1416,7 +1416,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/6"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/7"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1545,7 +1545,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/6", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/7", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index a8f1fbfd2..1b487668f 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "565d22f8d7174a44c6c877f0f47971349692b357b30495f01ecad1ad2da667c7"; + "74f8b9cf036f5797b8f5fcd513617f111b9f98717c1a9f787c81feff1c2e3f79"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 60c75380e..53741d08c 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/6`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/7`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/6"; +const SCHEMA: &str = "auths.gateway-attempt/7"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -172,6 +172,24 @@ impl std::fmt::Debug for GatewayProviderEvidence { } } +/// Typed conservative projection of one operation in the shared journal. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum GatewayOperationStage { + /// Provider mutation facts, including supported independent observations. + Mutation(GatewayAttemptStage), + /// Provider acquisition facts; never mutation success or recipient delivery. + Acquisition(AcquisitionStage), +} + +impl GatewayOperationStage { + pub(crate) const fn protocol(self) -> &'static str { + match self { + Self::Mutation(_) => "mutation", + Self::Acquisition(_) => "acquisition", + } + } +} + /// The kind of a reserved counter. #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] @@ -484,7 +502,7 @@ impl PreEntryWire { #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] -struct Record { +struct Record { revision: u64, schema: String, binding_canonical: String, @@ -495,12 +513,218 @@ struct Record { recipe_digest: String, nonce: String, evaluated_at: u64, - stage: GatewayAttemptStage, entry: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - refusal: Option, + state: S, +} + +impl Record { + fn new( + binding: &EffectBinding, + approval: &ExactEffectApproval, + evaluated_at: u64, + state: S, + ) -> Result { + let mut nonce = [0_u8; 16]; + getrandom::fill(&mut nonce).map_err(|_| GatewayAttemptError::Unavailable)?; + Ok(Record { + revision: 1, + schema: SCHEMA.to_owned(), + binding_canonical: String::from_utf8( + binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, + approval_canonical: String::from_utf8( + approval + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, + namespace: binding.journal_identity().0.to_owned(), + operation_id: binding.journal_identity().1.to_owned(), + action_commitment: hex::encode(binding.journal_identity().2), + recipe_digest: hex::encode(binding.journal_identity().3), + nonce: hex::encode(nonce), + evaluated_at, + entry: None, + state, + }) + } + + fn validate_header(&self) -> Result { + let binding = EffectBinding::from_private_bytes(self.binding_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let approval = ExactEffectApproval::from_private_bytes(self.approval_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + binding + .validate_recorded_approval(&approval, self.evaluated_at) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let (namespace, operation, action, recipe) = binding.journal_identity(); + if namespace != self.namespace + || operation != self.operation_id + || hex::encode(action) != self.action_commitment + || hex::encode(recipe) != self.recipe_digest + { + return Err(GatewayAttemptError::Corrupt); + } + if self.entry.as_ref().is_some_and(|entry| { + entry.schema != "auths.effect-entry/2" + || entry.revision < 2 + || entry.revision > self.revision + || entry.authorization_started_at < self.evaluated_at + || entry.granted_at < entry.authorization_started_at + || entry.granted_at < self.evaluated_at + || entry.granted_at > MAX_JSON_INTEGER + || entry.effect_id != hex::encode(binding.id().as_bytes()) + || entry.dependencies.len() >= auths_stores::MAX_GATEWAY_FENCE_RECORDS + || entry + .dependencies + .iter() + .any(|value| digest_bytes(value).is_err()) + }) { + return Err(GatewayAttemptError::Corrupt); + } + if let Some(entry) = &self.entry { + let approval = + ExactEffectApproval::from_private_bytes(entry.approval_canonical.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + binding + .validate_recorded_approval(&approval, entry.granted_at) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if let Some(pre_entry) = &entry.pre_entry { + pre_entry.decode()?; + } + } + if self.schema != SCHEMA + || self.nonce.len() != 32 + || !self + .nonce + .bytes() + .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) + { + return Err(GatewayAttemptError::Corrupt); + } + Ok(binding) + } + + fn record_grant( + &mut self, + approved: &ApprovedEffect, + authorization_started_at: u64, + now: u64, + pre_entry: Option, + dependencies: &[Option>], + ) -> Result<(), GatewayAttemptError> { + if self.entry.is_some() || authorization_started_at < self.evaluated_at { + return Err(GatewayAttemptError::InvalidTransition); + } + self.revision = self + .revision + .checked_add(1) + .ok_or(GatewayAttemptError::InvalidTransition)?; + self.entry = Some(EntryAudit { + revision: self.revision, + authorization_started_at, + pre_entry, + approval_canonical: String::from_utf8( + approved + .approval() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?, + schema: "auths.effect-entry/2".to_owned(), + granted_at: now, + effect_id: hex::encode(approved.effect().binding().id().as_bytes()), + dependencies: dependencies + .iter() + .map(|bytes| { + let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; + auths_codec::domain_commitment("auths.effect-entry-dependency/1", bytes) + .map(|digest| hex::encode(digest.as_bytes())) + .map_err(|_| GatewayAttemptError::Corrupt) + }) + .collect::, _>>()?, + }); + Ok(()) + } + + fn map_state( + self, + map: impl FnOnce(S) -> Result, + ) -> Result, GatewayAttemptError> { + Ok(Record { + revision: self.revision, + schema: self.schema, + binding_canonical: self.binding_canonical, + approval_canonical: self.approval_canonical, + namespace: self.namespace, + operation_id: self.operation_id, + action_commitment: self.action_commitment, + recipe_digest: self.recipe_digest, + nonce: self.nonce, + evaluated_at: self.evaluated_at, + entry: self.entry, + state: map(self.state)?, + }) + } +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde( + tag = "protocol", + content = "facts", + rename_all = "kebab-case", + deny_unknown_fields +)] +enum ProtocolState { + Mutation(MutationState), + Acquisition(acquisition::AcquisitionState), +} + +mod acquisition; +pub(crate) use acquisition::AcquisitionEntryPermit; +pub use acquisition::{ + AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, ReservedAcquisition, +}; + +trait JournalProtocol: Clone + Sized { + fn wrap(self) -> ProtocolState; + fn extract(state: ProtocolState) -> Result; + fn view(record: &Record) -> Result; + fn validate(record: &Record) -> Result<(), GatewayAttemptError>; +} + +impl JournalProtocol for MutationState { + fn wrap(self) -> ProtocolState { + ProtocolState::Mutation(self) + } + fn extract(state: ProtocolState) -> Result { + match state { + ProtocolState::Mutation(state) => Ok(state), + ProtocolState::Acquisition(_) => Err(GatewayAttemptError::BindingConflict), + } + } + fn view(record: &Record) -> Result { + record.view() + } + fn validate(record: &Record) -> Result<(), GatewayAttemptError> { + record.snapshot(false).map(|_| ()) + } +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct MutationState { #[serde(default, skip_serializing_if = "Vec::is_empty")] counters: Vec, + stage: GatewayAttemptStage, + #[serde(default, skip_serializing_if = "Option::is_none")] + refusal: Option, #[serde(default, skip_serializing_if = "Option::is_none")] response_status: Option, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -555,6 +779,58 @@ fn canonical(value: &T) -> Result, GatewayAttemptError> { } impl Record { + fn counters(&self) -> Result, GatewayAttemptError> { + if self.state.counters.len() > MAX_COUNTERS { + return Err(GatewayAttemptError::Corrupt); + } + let counters = self + .state + .counters + .iter() + .map(|entry| { + Ok(GatewayCounterEntry { + kind: entry.kind, + counter: digest_bytes(&entry.counter)?, + slot: entry.slot, + }) + }) + .collect::, GatewayAttemptError>>()?; + if counters.windows(2).any(|pair| pair[0] >= pair[1]) { + return Err(GatewayAttemptError::Corrupt); + } + Ok(counters) + } + + fn recovery_target(&self) -> Result { + let binding = self.validate_header()?; + let link = self.link(); + let stage_resolvable = match self.state.stage { + GatewayAttemptStage::EntryGranted | GatewayAttemptStage::Unknown => { + transition::resolves_unknown(link) + } + GatewayAttemptStage::ResponseRecorded => transition::has_link(link), + GatewayAttemptStage::Reserved + | GatewayAttemptStage::NotEntered + | GatewayAttemptStage::Observed + | GatewayAttemptStage::ObservedByProvider => false, + }; + if !stage_resolvable { + return Err(GatewayAttemptError::InvalidTransition); + } + let request = self + .observation_request() + .ok_or(GatewayAttemptError::InvalidTransition)?; + let echo = self + .state + .observation_plan + .as_ref() + .filter(|plan| plan.echo_pointer.is_some()) + .map(|_| self.echo_token()) + .transpose()?; + crate::effect::RecoveryReadTarget::from_journal(binding, request, echo) + .map_err(|_| GatewayAttemptError::Corrupt) + } + fn echo_token(&self) -> Result { let namespace = OperatorNamespace::parse(&self.namespace).map_err(|_| GatewayAttemptError::Corrupt)?; @@ -568,26 +844,28 @@ impl Record { } fn link(&self) -> Link { - self.observation_plan + self.state + .observation_plan .as_ref() .map_or(Link::None, ObservationTemplate::link) } /// The projection the translated transition rule inspects. fn view(&self) -> Result { - let reading = match (self.observation_match, self.observation_fact) { + let reading = match (self.state.observation_match, self.state.observation_fact) { (None, None) => Reading::None, (Some(true), None) => Reading::Match, (Some(false), None) => Reading::Mismatch, (Some(false), Some(GatewayObservationFact::EchoMismatch)) => Reading::EchoMismatch, (Some(true) | None, Some(_)) => return Err(GatewayAttemptError::Corrupt), }; - let response = match (self.response_status, &self.response_digest) { + let response = match (self.state.response_status, &self.state.response_digest) { (None, None) => Vec::new(), (Some(status), Some(digest)) => canonical(&(status, digest))?, _ => return Err(GatewayAttemptError::Corrupt), }; Ok(AttemptView { + protocol: transition::Protocol::Mutation, revision: self.revision, entry: self .entry @@ -605,12 +883,13 @@ impl Record { recipe_digest: &self.recipe_digest, nonce: &self.nonce, evaluated_at: self.evaluated_at, - counters: &self.counters, - observation_plan: self.observation_plan.as_ref(), + counters: &self.state.counters, + observation_plan: self.state.observation_plan.as_ref(), })?, - stage: self.stage.kernel(), - refusal: self.refusal.is_some(), + stage: self.state.stage.kernel(), + refusal: self.state.refusal.is_some(), pre_entry: self + .state .pre_entry .as_ref() .map(canonical) @@ -618,14 +897,15 @@ impl Record { .unwrap_or_default(), response, locator: self + .state .response_locator .as_ref() .map(canonical) .transpose()? .unwrap_or_default(), reading, - evidence: self.provider_evidence.is_some(), - observation: self.observation_plan.is_some(), + evidence: self.state.provider_evidence.is_some(), + observation: self.state.observation_plan.is_some(), link: self.link(), }) } @@ -633,30 +913,10 @@ impl Record { /// The read-back request of the stored plan and locator, when one can /// be built. fn observation_request(&self) -> Option { - self.observation_plan + self.state + .observation_plan .as_ref()? - .request(self.response_locator.as_ref()) - } - - fn counters(&self) -> Result, GatewayAttemptError> { - if self.counters.len() > MAX_COUNTERS { - return Err(GatewayAttemptError::Corrupt); - } - let counters = self - .counters - .iter() - .map(|entry| { - Ok(GatewayCounterEntry { - kind: entry.kind, - counter: digest_bytes(&entry.counter)?, - slot: entry.slot, - }) - }) - .collect::, GatewayAttemptError>>()?; - if counters.windows(2).any(|pair| pair[0] >= pair[1]) { - return Err(GatewayAttemptError::Corrupt); - } - Ok(counters) + .request(self.state.response_locator.as_ref()) } fn validate_reservations( @@ -756,7 +1016,7 @@ impl Record { } fn locator_valid(&self) -> bool { - match (&self.response_locator, &self.observation_plan) { + match (&self.state.response_locator, &self.state.observation_plan) { (None, _) => true, (Some(_), None) => false, (Some(locator), Some(plan)) => { @@ -771,57 +1031,18 @@ impl Record { } fn snapshot(&self, recovered: bool) -> Result { - let binding = EffectBinding::from_private_bytes(self.binding_canonical.as_bytes()) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let approval = ExactEffectApproval::from_private_bytes(self.approval_canonical.as_bytes()) - .map_err(|_| GatewayAttemptError::Corrupt)?; - binding - .validate_recorded_approval(&approval, self.evaluated_at) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let (namespace, operation, action, recipe) = binding.journal_identity(); - if namespace != self.namespace - || operation != self.operation_id - || hex::encode(action) != self.action_commitment - || hex::encode(recipe) != self.recipe_digest - { - return Err(GatewayAttemptError::Corrupt); - } - if self.entry.as_ref().is_some_and(|entry| { - entry.schema != "auths.effect-entry/2" - || entry.revision < 2 - || entry.revision > self.revision - || entry.authorization_started_at < self.evaluated_at - || entry.granted_at < entry.authorization_started_at - || entry.granted_at < self.evaluated_at - || entry.granted_at > MAX_JSON_INTEGER - || entry.effect_id != hex::encode(binding.id().as_bytes()) - || entry.dependencies.len() > 3 - || entry - .dependencies - .iter() - .any(|value| digest_bytes(value).is_err()) - }) { + if !self.validate_header()?.is_mutation() { return Err(GatewayAttemptError::Corrupt); } - if let Some(entry) = &self.entry { - let approval = - ExactEffectApproval::from_private_bytes(entry.approval_canonical.as_bytes()) - .map_err(|_| GatewayAttemptError::Corrupt)?; - binding - .validate_recorded_approval(&approval, entry.granted_at) - .map_err(|_| GatewayAttemptError::Corrupt)?; - if let Some(pre_entry) = &entry.pre_entry { - pre_entry.decode()?; - } - } if self.schema != SCHEMA || self.nonce.len() != 32 || !self .nonce .bytes() .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) - || !self.refusal.as_deref().is_none_or(valid_code) + || !self.state.refusal.as_deref().is_none_or(valid_code) || !self + .state .observation_plan .as_ref() .is_none_or(ObservationTemplate::valid) @@ -837,17 +1058,19 @@ impl Record { let action_commitment = digest_bytes(&self.action_commitment)?; let recipe_digest = digest_bytes(&self.recipe_digest)?; let response_digest = self + .state .response_digest .as_deref() .map(digest_bytes) .transpose()?; if self + .state .response_status .is_some_and(|status| !(100..=599).contains(&status)) { return Err(GatewayAttemptError::Corrupt); } - let provider_evidence = match &self.provider_evidence { + let provider_evidence = match &self.state.provider_evidence { Some(wire) => { let locator = self .observation_request() @@ -859,7 +1082,9 @@ impl Record { let pre_entry = self .entry .as_ref() - .map_or(self.pre_entry.as_ref(), |entry| entry.pre_entry.as_ref()) + .map_or(self.state.pre_entry.as_ref(), |entry| { + entry.pre_entry.as_ref() + }) .map(PreEntryWire::decode) .transpose()?; Ok(GatewayAttemptSnapshot { @@ -869,18 +1094,18 @@ impl Record { action_commitment, recipe_digest, evaluated_at: self.evaluated_at, - stage: if recovered && self.stage == GatewayAttemptStage::EntryGranted { + stage: if recovered && self.state.stage == GatewayAttemptStage::EntryGranted { GatewayAttemptStage::Unknown } else { - self.stage + self.state.stage }, - refusal: self.refusal.clone(), + refusal: self.state.refusal.clone(), counters: self.counters()?, - response_status: self.response_status, + response_status: self.state.response_status, response_digest, - response_locator: self.response_locator.clone(), - observation_match: self.observation_match, - observation_fact: self.observation_fact, + response_locator: self.state.response_locator.clone(), + observation_match: self.state.observation_match, + observation_fact: self.state.observation_fact, provider_evidence, pre_entry, }) @@ -1302,6 +1527,7 @@ impl FileGatewayAttemptStore { GatewayRecordKind::Connection => "conn-", GatewayRecordKind::CommissioningBudget => "commission-", GatewayRecordKind::EffectConfiguration => "config-", + GatewayRecordKind::EffectAllocation => "allocation-", }; format!("{prefix}{}.json", hex::encode(key.as_bytes())) } @@ -1552,10 +1778,17 @@ impl FileGatewayAttemptStore { /// A record or batch file name this store writes. fn valid_file_name(name: &str) -> bool { - let Some(rest) = ["claim-", "slot-", "sum-", "conn-", "commission-", "config-"] - .iter() - .find_map(|prefix| name.strip_prefix(prefix)) - else { + let Some(rest) = [ + "claim-", + "slot-", + "sum-", + "conn-", + "commission-", + "config-", + "allocation-", + ] + .iter() + .find_map(|prefix| name.strip_prefix(prefix)) else { return false; }; rest.strip_suffix(".json").is_some_and(|key| { @@ -1856,44 +2089,25 @@ fn claim_record( approval: &ExactEffectApproval, evaluated_at: u64, ) -> Result { - let mut nonce = [0_u8; 16]; - getrandom::fill(&mut nonce).map_err(|_| GatewayAttemptError::Unavailable)?; - let record = Record { - revision: 1, - schema: SCHEMA.to_owned(), - binding_canonical: String::from_utf8( - binding - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .to_vec(), - ) - .map_err(|_| GatewayAttemptError::Corrupt)?, - approval_canonical: String::from_utf8( - approval - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .to_vec(), - ) - .map_err(|_| GatewayAttemptError::Corrupt)?, - namespace: request.namespace().as_str().to_owned(), - operation_id: request.operation_id().as_str().to_owned(), - action_commitment: hex::encode(request.action_commitment()), - recipe_digest: hex::encode(binding.journal_identity().3), - nonce: hex::encode(nonce), + let record = Record::new( + binding, + approval, evaluated_at, - stage: GatewayAttemptStage::Reserved, - entry: None, - refusal: None, - counters: Vec::new(), - response_status: None, - response_digest: None, - response_locator: None, - observation_plan: request.observation_template().cloned(), - observation_match: None, - observation_fact: None, - provider_evidence: None, - pre_entry: None, - }; + MutationState { + counters: Vec::new(), + stage: GatewayAttemptStage::Reserved, + refusal: None, + response_status: None, + response_digest: None, + response_locator: None, + observation_plan: request.observation_template().cloned(), + observation_match: None, + observation_fact: None, + provider_evidence: None, + pre_entry: None, + }, + ); + let record = record?; record.snapshot(false)?; Ok(record) } @@ -2002,7 +2216,7 @@ impl GatewayAttempts { pub async fn stages( &self, limit: usize, - ) -> Result, GatewayAttemptError> { + ) -> Result, GatewayAttemptError> { let store = Arc::clone(&self.store); let policy = self.policy.clone(); blocking(move || { @@ -2012,7 +2226,7 @@ impl GatewayAttempts { .filter_map(|key| { let stage = store .load(GatewayRecordKind::Attempt, &key) - .and_then(|bytes| bytes.map(|bytes| decode(&bytes)).transpose()) + .and_then(|bytes| bytes.map(|bytes| decode_protocol(&bytes)).transpose()) .and_then(|record| { let Some(record) = record else { return Ok(None); @@ -2024,12 +2238,26 @@ impl GatewayAttempts { if !policy.contains(&binding) { return Ok(None); } - record.snapshot(true).map(Some) + let stage = match &record.state { + ProtocolState::Mutation(_) => GatewayOperationStage::Mutation( + record + .map_state(MutationState::extract)? + .snapshot(true)? + .stage(), + ), + ProtocolState::Acquisition(_) => { + GatewayOperationStage::Acquisition( + record + .map_state(acquisition::AcquisitionState::extract)? + .snapshot()? + .stage, + ) + } + }; + Ok(Some(stage)) }); match stage { - Ok(Some(snapshot)) => { - Some(Ok((hex::encode(key.as_bytes()), snapshot.stage()))) - } + Ok(Some(snapshot)) => Some(Ok((hex::encode(key.as_bytes()), snapshot))), // Deleted between the listing and the read. Ok(None) => None, Err(error) => Some(Err(error)), @@ -2102,20 +2330,8 @@ impl GatewayAttempts { return Ok(None); }; record.snapshot(false)?; - let link = record.link(); - let stage_resolvable = match record.stage { - GatewayAttemptStage::EntryGranted | GatewayAttemptStage::Unknown => { - transition::resolves_unknown(link) - } - GatewayAttemptStage::ResponseRecorded => transition::has_link(link), - GatewayAttemptStage::Reserved - | GatewayAttemptStage::NotEntered - | GatewayAttemptStage::Observed - | GatewayAttemptStage::ObservedByProvider => false, - }; - let resumable = stage_resolvable - && record.recipe_digest == hex::encode(recipe_digest) - && record.observation_request().is_some(); + let resumable = + record.recipe_digest == hex::encode(recipe_digest) && record.recovery_target().is_ok(); let key = self.key(namespace, operation_id)?; Ok(resumable.then(|| ObservableGatewayAttempt { attempt: Attempt { @@ -2165,17 +2381,17 @@ impl GatewayAttempts { } /// One loaded or claimed attempt and the exact bytes it was read as. -struct Attempt { +struct Attempt { store: Arc, key: GatewayAttemptKey, stored: Vec, - record: Record, + record: Record, } -impl Attempt { +impl Attempt { /// Persists `next` only as a valid stage change from the exact stored /// record; a concurrent change by another process is a conflict. - async fn advance(mut self, mut next: Record) -> Result { + async fn advance(mut self, mut next: Record) -> Result { next.revision = self .record .revision @@ -2251,7 +2467,7 @@ impl ClaimedGatewayAttempt { .as_deref() .ok_or(GatewayAttemptError::Corrupt)?, )?; - if current.stage != GatewayAttemptStage::Reserved + if current.state.stage != GatewayAttemptStage::Reserved || current.binding_canonical.as_bytes() != approved .effect() @@ -2280,40 +2496,15 @@ impl ClaimedGatewayAttempt { &snapshots[dependency_end..], now, )?; - if authorization_started_at < current.evaluated_at { - return Err(GatewayAttemptError::InvalidTransition); - } let mut next = current.clone(); - next.revision = current - .revision - .checked_add(1) - .ok_or(GatewayAttemptError::InvalidTransition)?; - next.stage = GatewayAttemptStage::EntryGranted; - next.entry = Some(EntryAudit { - revision: next.revision, + next.record_grant( + &approved, authorization_started_at, - pre_entry: pre_entry.clone(), - approval_canonical: String::from_utf8( - approved - .approval() - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .to_vec(), - ) - .map_err(|_| GatewayAttemptError::Corrupt)?, - schema: "auths.effect-entry/2".to_owned(), - granted_at: now, - effect_id: hex::encode(approved.effect().binding().id().as_bytes()), - dependencies: snapshots[1..dependency_end] - .iter() - .map(|bytes| { - let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; - auths_codec::domain_commitment("auths.effect-entry-dependency/1", bytes) - .map(|digest| hex::encode(digest.as_bytes())) - .map_err(|_| GatewayAttemptError::Corrupt) - }) - .collect::, _>>()?, - }); + now, + pre_entry.clone(), + &snapshots[1..dependency_end], + )?; + next.state.stage = GatewayAttemptStage::EntryGranted; if !valid_transition(¤t, &next)? { return Err(GatewayAttemptError::InvalidTransition); } @@ -2348,15 +2539,15 @@ impl ClaimedGatewayAttempt { self, pre_entry: &GatewayPreEntry, ) -> Result { - if self.attempt.record.stage != GatewayAttemptStage::Reserved { + if self.attempt.record.state.stage != GatewayAttemptStage::Reserved { return Err(GatewayAttemptError::InvalidTransition); } let fresh = PreEntryWire::encode(pre_entry)?; - if self.attempt.record.pre_entry.is_some() { + if self.attempt.record.state.pre_entry.is_some() { return Ok(self); } let mut next = self.attempt.record.clone(); - next.pre_entry = fresh; + next.state.pre_entry = fresh; Ok(Self { attempt: self.attempt.advance(next).await?, }) @@ -2373,12 +2564,12 @@ impl ClaimedGatewayAttempt { pre_entry: Option<&GatewayPreEntry>, ) -> Result { let mut next = self.attempt.record.clone(); - next.stage = GatewayAttemptStage::NotEntered; - next.refusal = Some(refusal.to_owned()); + next.state.stage = GatewayAttemptStage::NotEntered; + next.state.refusal = Some(refusal.to_owned()); if let Some(pre_entry) = pre_entry - && next.pre_entry.is_none() + && next.state.pre_entry.is_none() { - next.pre_entry = PreEntryWire::encode(pre_entry)?; + next.state.pre_entry = PreEntryWire::encode(pre_entry)?; } self.attempt.advance(next).await?.record.snapshot(false) } @@ -2389,7 +2580,7 @@ impl ClaimedGatewayAttempt { /// Persistence failure does not permit a retry. pub async fn record_unknown(self) -> Result { let mut next = self.attempt.record.clone(); - next.stage = GatewayAttemptStage::Unknown; + next.state.stage = GatewayAttemptStage::Unknown; self.attempt.advance(next).await?.record.snapshot(false) } @@ -2408,10 +2599,10 @@ impl ClaimedGatewayAttempt { return Err(GatewayAttemptError::InvalidTransition); } let mut next = self.attempt.record.clone(); - next.stage = GatewayAttemptStage::ResponseRecorded; - next.response_status = Some(status); - next.response_digest = Some(hex::encode(digest)); - next.response_locator = locator; + next.state.stage = GatewayAttemptStage::ResponseRecorded; + next.state.response_status = Some(status); + next.state.response_digest = Some(hex::encode(digest)); + next.state.response_locator = locator; Ok(ObservableGatewayAttempt { attempt: self.attempt.advance(next).await?, }) @@ -2463,15 +2654,7 @@ impl ObservableGatewayAttempt { pub fn recovery_target( &self, ) -> Result { - let binding = crate::effect::EffectBinding::from_private_bytes( - self.attempt.record.binding_canonical.as_bytes(), - ) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let request = self - .observation_request() - .ok_or(GatewayAttemptError::InvalidTransition)?; - crate::effect::RecoveryReadTarget::from_journal(binding, request, self.echo_token()) - .map_err(|_| GatewayAttemptError::Corrupt) + self.attempt.record.recovery_target() } /// Returns this attempt's echo token, derived from the stored verified @@ -2480,6 +2663,7 @@ impl ObservableGatewayAttempt { pub fn echo_token(&self) -> Option { self.attempt .record + .state .observation_plan .as_ref() .filter(|plan| plan.echo_pointer.is_some()) @@ -2496,8 +2680,8 @@ impl ObservableGatewayAttempt { matched: bool, ) -> Result { let mut next = self.attempt.record.clone(); - next.stage = GatewayAttemptStage::Observed; - next.observation_match = Some(matched); + next.state.stage = GatewayAttemptStage::Observed; + next.state.observation_match = Some(matched); self.attempt.advance(next).await?.record.snapshot(false) } @@ -2508,9 +2692,9 @@ impl ObservableGatewayAttempt { /// Persistence failure retains only the recorded response. pub async fn record_echo_mismatch(self) -> Result { let mut next = self.attempt.record.clone(); - next.stage = GatewayAttemptStage::Observed; - next.observation_match = Some(false); - next.observation_fact = Some(GatewayObservationFact::EchoMismatch); + next.state.stage = GatewayAttemptStage::Observed; + next.state.observation_match = Some(false); + next.state.observation_fact = Some(GatewayObservationFact::EchoMismatch); self.attempt.advance(next).await?.record.snapshot(false) } @@ -2531,6 +2715,7 @@ impl ObservableGatewayAttempt { .observation_request() .filter(|_| { record + .state .observation_plan .as_ref() .is_some_and(|plan| plan.echo_pointer.is_some()) @@ -2540,7 +2725,7 @@ impl ObservableGatewayAttempt { return Err(GatewayAttemptError::InvalidTransition); } let mut next = record.clone(); - next.provider_evidence = Some(EvidenceWire { + next.state.provider_evidence = Some(EvidenceWire { channel: GatewayEvidenceChannel::ReadBack, locator: locator.url().to_owned(), echo: record.echo_token()?, @@ -2548,13 +2733,15 @@ impl ObservableGatewayAttempt { evidence_b64: Base64::encode_string(evidence), observed_at, }); - next.stage = GatewayAttemptStage::ObservedByProvider; + next.state.stage = GatewayAttemptStage::ObservedByProvider; self.attempt.advance(next).await?.record.snapshot(false) } } -fn encode(record: &Record) -> Result, GatewayAttemptError> { - let bytes = serde_json::to_vec(record).map_err(|_| GatewayAttemptError::Corrupt)?; +fn encode(record: &Record) -> Result, GatewayAttemptError> { + let record = record.clone(); + let wire = record.map_state(|state| Ok(state.wrap()))?; + let bytes = serde_json::to_vec(&wire).map_err(|_| GatewayAttemptError::Corrupt)?; if bytes.is_empty() || bytes.len() > MAX_RECORD_BYTES { return Err(GatewayAttemptError::Corrupt); } @@ -2573,8 +2760,7 @@ fn existing_binding( let bytes = store .load(GatewayRecordKind::Attempt, &key)? .ok_or(GatewayAttemptError::Corrupt)?; - let record = decode(&bytes)?; - record.snapshot(false)?; + let record = decode_protocol(&bytes)?; Ok::<_, GatewayAttemptError>(record.binding_canonical == expected) })(); match checked { @@ -2585,10 +2771,33 @@ fn existing_binding( } fn decode(bytes: &[u8]) -> Result { + decode_as(bytes) +} + +fn decode_as(bytes: &[u8]) -> Result, GatewayAttemptError> { + decode_protocol(bytes)?.map_state(S::extract) +} + +fn decode_protocol(bytes: &[u8]) -> Result, GatewayAttemptError> { if bytes.is_empty() || bytes.len() > MAX_RECORD_BYTES { return Err(GatewayAttemptError::Corrupt); } - serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt) + let record: Record = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + record.validate_header()?; + match &record.state { + ProtocolState::Mutation(_) => { + let typed = record.clone().map_state(MutationState::extract)?; + MutationState::validate(&typed)?; + } + ProtocolState::Acquisition(_) => { + let typed = record + .clone() + .map_state(acquisition::AcquisitionState::extract)?; + acquisition::AcquisitionState::validate(&typed)?; + } + } + Ok(record) } /// The snapshot of one stored record's bytes, for the fuzz targets. @@ -2606,8 +2815,11 @@ pub(crate) fn fuzz_transition(old: &[u8], new: &[u8]) -> Option { /// Whether `new` may replace `old`: the translated transition rule on both /// projections, and a fully valid `new`. -fn valid_transition(old: &Record, new: &Record) -> Result { - Ok(transition::valid_transition(&old.view()?, &new.view()?) && new.snapshot(false).is_ok()) +fn valid_transition( + old: &Record, + new: &Record, +) -> Result { + Ok(transition::valid_transition(&S::view(old)?, &S::view(new)?) && S::validate(new).is_ok()) } fn sync_directory(root: &Path) -> Result<(), GatewayAttemptError> { @@ -2733,8 +2945,8 @@ fn store_exhausted( code: &'static str, ) -> Result { let mut record = base.clone(); - record.stage = GatewayAttemptStage::NotEntered; - record.refusal = Some(code.to_owned()); + record.state.stage = GatewayAttemptStage::NotEntered; + record.state.refusal = Some(code.to_owned()); record.snapshot(false)?; store.insert(&GatewayRecordEntry { kind: GatewayRecordKind::Attempt, @@ -2779,7 +2991,7 @@ fn claim_batch( ) .collect(); counters.sort_unstable(); - record.counters = counters + record.state.counters = counters .iter() .map(|entry| CounterWire { kind: entry.kind, @@ -2972,7 +3184,7 @@ impl GatewayAttempts { { return Err(GatewayAttemptError::BindingConflict); } - if record.stage != GatewayAttemptStage::Reserved { + if record.state.stage != GatewayAttemptStage::Reserved { return Err(GatewayAttemptError::Replay); } // This handle grants no entry. A fresh fenced CAS still checks diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs new file mode 100644 index 000000000..e00e88899 --- /dev/null +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -0,0 +1,620 @@ +//! Typed recovery acquisitions in the existing operation journal. Permanent +//! allocation slots, the source operation and current entry dependencies share +//! the same adapter fence. No stored grant can recreate a read permit. + +use super::*; +use crate::effect::{RecoveryCapacity, RecoveryPlan}; + +const ALLOCATION_SCHEMA: &str = "auths.effect-allocation/1"; + +/// Public facts about a bounded acquisition, with no content or private digest. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AcquisitionSnapshot { + /// Durable journal revision. + pub revision: u64, + /// A recovered grant projects unknown, never a fresh permit. + pub stage: AcquisitionStage, + /// Permanently allocated invocation units, including uncertain entry. + pub reserved_calls: u64, + /// Permanently allocated response-byte ceiling. + pub reserved_bytes: u64, + /// Recorded HTTP status; it is not a mutation outcome or disclosure ACK. + pub response_status: Option, + /// Bounded received byte count, without the content or its commitment. + pub response_bytes: Option, + /// Whether required response-version headers matched the installed recipe. + pub response_version_ok: Option, +} + +/// Acquisition has no mutation-observed or disclosure-acknowledged state. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum AcquisitionStage { + /// Capacity held; no provider permit. + Reserved, + /// A durable grant exists; execution may have occurred. + EntryGranted, + /// No grant was issued. + NotEntered, + /// A grant exists without a recorded response. + Unknown, + /// A provider response is retained privately. + ResponseRecorded, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct AcquisitionState { + plan: RecoveryPlan, + allocation: Option, + phase: AcquisitionPhase, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(tag = "stage", rename_all = "kebab-case", deny_unknown_fields)] +enum AcquisitionPhase { + Reserved, + EntryGranted, + NotEntered { code: String }, + Unknown, + ResponseRecorded { response: AcquisitionResponse }, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct AcquisitionResponse { + status: u16, + version_ok: bool, + body_b64: String, + received_at: u64, +} + +impl AcquisitionPhase { + const fn kernel(&self) -> transition::Stage { + match self { + Self::Reserved => transition::Stage::Reserved, + Self::EntryGranted => transition::Stage::EntryGranted, + Self::NotEntered { .. } => transition::Stage::NotEntered, + Self::Unknown => transition::Stage::Unknown, + Self::ResponseRecorded { .. } => transition::Stage::ResponseRecorded, + } + } +} + +impl JournalProtocol for AcquisitionState { + fn wrap(self) -> ProtocolState { + ProtocolState::Acquisition(self) + } + + fn extract(state: ProtocolState) -> Result { + match state { + ProtocolState::Acquisition(state) => Ok(state), + ProtocolState::Mutation(_) => Err(GatewayAttemptError::BindingConflict), + } + } + + fn view(record: &Record) -> Result { + Ok(AttemptView { + protocol: transition::Protocol::Acquisition, + revision: record.revision, + fixed: canonical(&( + &record.schema, + &record.binding_canonical, + &record.approval_canonical, + &record.namespace, + &record.operation_id, + &record.action_commitment, + &record.recipe_digest, + &record.nonce, + record.evaluated_at, + &record.state.plan, + record.state.allocation, + ))?, + entry: record + .entry + .as_ref() + .map(canonical) + .transpose()? + .unwrap_or_default(), + stage: record.state.phase.kernel(), + refusal: matches!(record.state.phase, AcquisitionPhase::NotEntered { .. }), + response: match &record.state.phase { + AcquisitionPhase::ResponseRecorded { response } => canonical(response)?, + _ => Vec::new(), + }, + pre_entry: Vec::new(), + locator: Vec::new(), + reading: Reading::None, + evidence: false, + observation: false, + link: Link::None, + }) + } + + fn validate(record: &Record) -> Result<(), GatewayAttemptError> { + let binding = record.validate_header()?; + let capacity = record + .state + .plan + .validate(&binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !transition::consistent(&Self::view(record)?) + || record + .entry + .as_ref() + .is_some_and(|entry| entry.pre_entry.is_some()) + || match record.state.allocation { + Some(slot) => slot >= capacity.attempts, + None => !matches!(record.state.phase, AcquisitionPhase::NotEntered { .. }), + } + { + return Err(GatewayAttemptError::Corrupt); + } + match &record.state.phase { + AcquisitionPhase::NotEntered { code } if !valid_code(code) => { + return Err(GatewayAttemptError::Corrupt); + } + AcquisitionPhase::ResponseRecorded { response } => { + let body = response.body(&capacity)?; + let entry = record.entry.as_ref().ok_or(GatewayAttemptError::Corrupt)?; + if response.received_at < entry.granted_at + || response.received_at > MAX_JSON_INTEGER + || !(100..=599).contains(&response.status) + || body.len() > MAX_EVIDENCE_BYTES + { + return Err(GatewayAttemptError::Corrupt); + } + } + _ => {} + } + Ok(()) + } +} + +impl AcquisitionResponse { + fn body(&self, capacity: &RecoveryCapacity) -> Result, GatewayAttemptError> { + if self.body_b64.len() > MAX_EVIDENCE_BYTES.div_ceil(3) * 4 { + return Err(GatewayAttemptError::Corrupt); + } + let body = Base64::decode_vec(&self.body_b64).map_err(|_| GatewayAttemptError::Corrupt)?; + if body.len() as u64 > capacity.maximum_bytes + || Base64::encode_string(&body) != self.body_b64 + { + return Err(GatewayAttemptError::Corrupt); + } + Ok(body) + } +} + +impl Record { + pub(super) fn snapshot(&self) -> Result { + AcquisitionState::validate(self)?; + let capacity = self + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let (stage, response_status, response_bytes) = match &self.state.phase { + AcquisitionPhase::Reserved => (AcquisitionStage::Reserved, None, None), + AcquisitionPhase::EntryGranted | AcquisitionPhase::Unknown => { + (AcquisitionStage::Unknown, None, None) + } + AcquisitionPhase::NotEntered { .. } => (AcquisitionStage::NotEntered, None, None), + AcquisitionPhase::ResponseRecorded { response } => ( + AcquisitionStage::ResponseRecorded, + Some(response.status), + Some(response.body(&capacity)?.len() as u64), + ), + }; + Ok(AcquisitionSnapshot { + revision: self.revision, + stage, + reserved_calls: u64::from(self.state.allocation.is_some()), + reserved_bytes: if self.state.allocation.is_some() { + capacity.maximum_bytes + } else { + 0 + }, + response_status, + response_bytes, + response_version_ok: match &self.state.phase { + AcquisitionPhase::ResponseRecorded { response } => Some(response.version_ok), + _ => None, + }, + }) + } +} + +/// One immutable slot charges both distinct units at the same atomic admission. +/// Every read of this source has the same native maximum, so slot i holds one +/// call and that maximum, and cumulative bytes are (i + 1) * maximum. No expiry. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Allocation { + schema: String, + claim: String, + source: String, + count_key: String, + bytes_key: String, + slot: u64, + calls: u64, + bytes: u64, +} + +impl Allocation { + fn new( + plan: &RecoveryPlan, + key: GatewayAttemptKey, + slot: u64, + ) -> Result { + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; + if slot >= capacity.attempts { + return Err(GatewayAttemptError::InvalidTransition); + } + Ok(Self { + schema: ALLOCATION_SCHEMA.to_owned(), + claim: hex::encode(key.as_bytes()), + source: hex::encode(source.id().as_bytes()), + count_key: hex::encode(capacity.count_key), + bytes_key: hex::encode(capacity.bytes_key), + slot, + calls: 1, + bytes: capacity.maximum_bytes, + }) + } +} + +fn allocation_key(capacity: &RecoveryCapacity, slot: u64) -> GatewayAttemptKey { + GatewayAttemptKey(crate::bounds::count_slot_key(&capacity.count_key, slot)) +} + +/// Admission reserves capacity but grants no provider capability. +pub enum AcquisitionClaim { + /// An equal reservation can resume only through fresh fenced authorization. + Reserved(Box), + /// Existing immutable facts; no provider or custody call is warranted. + Existing(AcquisitionSnapshot), +} + +/// A typed handle to the same durable journal used for mutations. +pub struct ReservedAcquisition { + attempt: Attempt, + source_key: GatewayAttemptKey, +} + +impl GatewayAttempts { + /// Returns retained facts for this exact approved read, without any I/O + /// outside the journal. A stored grant projects unknown, never a permit. + /// + /// # Errors + /// Refuses a different protocol, operation binding or installed partition, + /// and corrupt/unavailable state. + pub async fn read_recovery( + &self, + approved: &ApprovedEffect, + ) -> Result, GatewayAttemptError> { + if approved.recovery_target().is_none() + || !self.policy.contains(approved.effect().binding()) + { + return Err(GatewayAttemptError::BindingConflict); + } + let binding = approved.effect().binding(); + let (namespace, operation, _, _) = binding.journal_identity(); + let key = self.key( + &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, + &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, + )?; + let store = Arc::clone(&self.store); + let Some(bytes) = blocking(move || store.load(GatewayRecordKind::Attempt, &key)).await? + else { + return Ok(None); + }; + let record: Record = decode_as(&bytes)?; + if record.binding_canonical.as_bytes() + != binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + record.snapshot().map(Some) + } + + /// Atomically admits one recovery read and its permanent count/byte slot. + /// Equal reservations reopen without charging twice; post-grant replay is + /// history only. Changed bindings under any protocol conflict. + /// + /// # Errors + /// Refuses non-acquisitions, changed source/partition, invalid approval and + /// corrupt or unavailable state. No error can return a transport permit. + pub async fn claim_recovery( + &self, + approved: &ApprovedEffect, + evaluated_at: u64, + ) -> Result { + let target = approved + .recovery_target() + .ok_or(GatewayAttemptError::InvalidTransition)?; + let plan = target + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let binding = approved.effect().binding(); + let capacity = plan + .validate(binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let (namespace, operation, _, _) = binding.journal_identity(); + let namespace = + OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?; + let operation = + LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; + let key = self.key(&namespace, &operation)?; + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let source_operation = LogicalOperationId::parse(source.journal_identity().1) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let source_key = self.key(&namespace, &source_operation)?; + let base = Record::new( + binding, + approved.approval(), + evaluated_at, + AcquisitionState { + plan, + allocation: None, + phase: AcquisitionPhase::Reserved, + }, + )?; + base.validate_header()?; + let store = Arc::clone(&self.store); + let reserved = blocking(move || { + for slot in 0..capacity.attempts { + let mut record = base.clone(); + record.state.allocation = Some(slot); + AcquisitionState::validate(&record)?; + let stored = encode(&record)?; + let allocation = Allocation::new(&record.state.plan, key, slot)?; + let entries = [ + GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: stored.clone(), + expires_at: None, + }, + GatewayRecordEntry { + kind: GatewayRecordKind::EffectAllocation, + key: allocation_key(&capacity, slot), + record: canonical(&allocation)?, + expires_at: None, + }, + ]; + match store.insert_all(&entries)? { + GatewayInsert::Inserted => return Ok((record, stored)), + GatewayInsert::Exists { index: 0 } => { + return Err(existing_binding(&*store, key, &base.binding_canonical)); + } + GatewayInsert::Exists { index: 1 } => {} + GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), + } + } + let mut record = base; + record.state.phase = AcquisitionPhase::NotEntered { + code: "gateway.acquisition.exhausted".to_owned(), + }; + AcquisitionState::validate(&record)?; + let stored = encode(&record)?; + match store.insert(&GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: stored.clone(), + expires_at: None, + }) { + Ok(()) => Ok((record, stored)), + Err(GatewayAttemptError::Replay) => { + Err(existing_binding(&*store, key, &record.binding_canonical)) + } + Err(error) => Err(error), + } + }) + .await; + let (record, stored) = match reserved { + Ok(value) => value, + Err(GatewayAttemptError::Replay) => { + let store = Arc::clone(&self.store); + let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&bytes)?; + if record.binding_canonical.as_bytes() + != binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + (record, bytes) + } + Err(error) => return Err(error), + }; + if matches!(record.state.phase, AcquisitionPhase::Reserved) { + Ok(AcquisitionClaim::Reserved(Box::new(ReservedAcquisition { + source_key, + attempt: Attempt { + store: Arc::clone(&self.store), + key, + stored, + record, + }, + }))) + } else { + Ok(AcquisitionClaim::Existing(record.snapshot()?)) + } + } +} + +impl ReservedAcquisition { + /// Inspects the reservation without granting entry or reading a provider. + /// + /// # Errors + /// Refuses malformed retained facts. + pub fn snapshot(&self) -> Result { + self.attempt.record.snapshot() + } + + pub(crate) async fn grant_entry( + self, + approved: Arc, + validation: crate::entry::EntryValidation, + authorization_started_at: u64, + ) -> Result<(GrantedAcquisition, AcquisitionEntryPermit), GatewayAttemptError> { + let target = approved + .recovery_target() + .ok_or(GatewayAttemptError::InvalidTransition)?; + let request = target.closed_request().clone(); + let plan = target + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?; + blocking(move || { + let mut attempt = self.attempt; + let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; + let slot = attempt + .record + .state + .allocation + .ok_or(GatewayAttemptError::Corrupt)?; + let dependencies = validation.dependencies(); + let mut keys = vec![ + (GatewayRecordKind::Attempt, attempt.key), + (GatewayRecordKind::Attempt, self.source_key), + ( + GatewayRecordKind::EffectAllocation, + allocation_key(&capacity, slot), + ), + ]; + keys.extend_from_slice(&dependencies); + let mut committed = None; + attempt.store.fenced_replace(&keys, &mut |snapshots| { + if snapshots.len() != keys.len() + || snapshots[0].as_deref() != Some(attempt.stored.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + let current: Record = decode_as( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if !matches!(current.state.phase, AcquisitionPhase::Reserved) + || current.state.plan != plan + || current.binding_canonical.as_bytes() + != approved + .effect() + .binding() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + let source = decode( + snapshots[1] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + let source_target = source.recovery_target()?; + if source_target + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)? + != plan + || snapshots[2].as_deref() + != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) + { + return Err(GatewayAttemptError::BindingConflict); + } + let now = validation + .validate(&approved, &snapshots[3..], authorization_started_at) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + let mut next = current.clone(); + next.record_grant( + &approved, + authorization_started_at, + now, + None, + &snapshots[1..], + )?; + next.state.phase = AcquisitionPhase::EntryGranted; + if !valid_transition(¤t, &next)? { + return Err(GatewayAttemptError::InvalidTransition); + } + let bytes = encode(&next)?; + committed = Some((next, bytes.clone())); + Ok(bytes) + })?; + let (record, stored) = committed.ok_or(GatewayAttemptError::Unavailable)?; + attempt.record = record; + attempt.stored = stored; + Ok(( + GrantedAcquisition { attempt }, + AcquisitionEntryPermit { + _approved: approved, + request, + }, + )) + }) + .await + } +} + +pub(crate) struct AcquisitionEntryPermit { + _approved: Arc, + request: ClosedObservationRequest, +} + +impl AcquisitionEntryPermit { + pub(crate) fn request(&self) -> &ClosedObservationRequest { + &self.request + } +} + +pub(crate) struct GrantedAcquisition { + attempt: Attempt, +} + +impl GrantedAcquisition { + pub(crate) async fn record_unknown(self) -> Result { + let mut next = self.attempt.record.clone(); + next.state.phase = AcquisitionPhase::Unknown; + self.attempt.advance(next).await?.record.snapshot() + } + + pub(crate) async fn record_response( + self, + status: u16, + version_ok: bool, + bytes: &[u8], + received_at: u64, + ) -> Result { + let capacity = self + .attempt + .record + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)?; + if bytes.len() as u64 > capacity.maximum_bytes || !(100..=599).contains(&status) { + return Err(GatewayAttemptError::InvalidTransition); + } + let mut next = self.attempt.record.clone(); + next.state.phase = AcquisitionPhase::ResponseRecorded { + response: AcquisitionResponse { + status, + version_ok, + body_b64: Base64::encode_string(bytes), + received_at, + }, + }; + self.attempt.advance(next).await?.record.snapshot() + } +} diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index c7ee569d8..8d201259c 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -227,10 +227,17 @@ pub(crate) fn denied_result(response: Option<&ProviderResponse>, refused: &[u16] /// Ends the in-flight count of one entry when dropped, so a count taken /// before the final reload is released on every path. -struct InFlight<'a, I: SubmitIo> { +pub(crate) struct InFlight<'a, I: SubmitIo> { io: &'a I, } +impl<'a, I: SubmitIo> InFlight<'a, I> { + pub(crate) fn enter(io: &'a I) -> Self { + io.enter(); + Self { io } + } +} + impl Drop for InFlight<'_, I> { fn drop(&mut self) { self.io.leave(); @@ -378,8 +385,7 @@ impl Run<'_, I> { // Counted before the reload, so an admin change committed // after this point is seen by the reload, and one committed // before it waits for this entry. - self.io.enter(); - self.in_flight = Some(InFlight { io: self.io }); + self.in_flight = Some(InFlight::enter(self.io)); SubmitEvent::Reload(self.io.reload().await) } SubmitAction::Lease(_) => { diff --git a/product/runtime/auths-gateway/src/support.rs b/product/runtime/auths-gateway/src/support.rs index d6ef7581d..6f1d50720 100644 --- a/product/runtime/auths-gateway/src/support.rs +++ b/product/runtime/auths-gateway/src/support.rs @@ -8,12 +8,12 @@ //! identifier, or raw header therefore has no member to arrive through. An //! attempt appears as the digest that keys it and its stage. -use crate::{GatewayAttemptStage, QualificationStatus}; +use crate::{AcquisitionStage, GatewayAttemptStage, GatewayOperationStage, QualificationStatus}; use serde::Serialize; use std::collections::BTreeMap; /// The schema of the archive. -pub const SUPPORT_BUNDLE_SCHEMA: &str = "auths.gateway-support-bundle/1"; +pub const SUPPORT_BUNDLE_SCHEMA: &str = "auths.gateway-support-bundle/2"; /// The most attempts one archive lists. pub const MAX_SUPPORT_ATTEMPTS: usize = 256; @@ -64,20 +64,29 @@ pub struct SupportFacts { pub connection: Option, /// Stored attempts as key digest and stage, at most /// [`MAX_SUPPORT_ATTEMPTS`]; `None` when the store could not be read. - pub attempts: Option>, + pub attempts: Option>, /// Whether the store holds more attempts than were listed. pub attempts_truncated: bool, } -const fn stage_token(stage: GatewayAttemptStage) -> &'static str { +const fn stage_token(stage: GatewayOperationStage) -> &'static str { match stage { - GatewayAttemptStage::NotEntered => "not-entered", - GatewayAttemptStage::Reserved => "reserved", - GatewayAttemptStage::EntryGranted => "entry-granted", - GatewayAttemptStage::ResponseRecorded => "response-recorded", - GatewayAttemptStage::Unknown => "unknown", - GatewayAttemptStage::Observed => "observed", - GatewayAttemptStage::ObservedByProvider => "observed-by-provider", + GatewayOperationStage::Mutation(stage) => match stage { + GatewayAttemptStage::NotEntered => "not-entered", + GatewayAttemptStage::Reserved => "reserved", + GatewayAttemptStage::EntryGranted => "entry-granted", + GatewayAttemptStage::ResponseRecorded => "response-recorded", + GatewayAttemptStage::Unknown => "unknown", + GatewayAttemptStage::Observed => "observed", + GatewayAttemptStage::ObservedByProvider => "observed-by-provider", + }, + GatewayOperationStage::Acquisition(stage) => match stage { + AcquisitionStage::Reserved => "reserved", + AcquisitionStage::EntryGranted => "entry-granted", + AcquisitionStage::NotEntered => "not-entered", + AcquisitionStage::Unknown => "unknown", + AcquisitionStage::ResponseRecorded => "response-recorded", + }, } } @@ -100,6 +109,7 @@ struct Connection { #[derive(Serialize)] struct Attempt { key_sha256: String, + protocol: &'static str, stage: &'static str, } @@ -107,7 +117,7 @@ struct Attempt { struct Attempts { listed: usize, truncated: bool, - by_stage: BTreeMap<&'static str, u64>, + by_stage: BTreeMap<&'static str, BTreeMap<&'static str, u64>>, identifiers: Vec, } @@ -157,7 +167,11 @@ pub fn support_bundle(facts: &SupportFacts) -> Result, &'static str> { let listed = &available[..available.len().min(MAX_SUPPORT_ATTEMPTS)]; let mut by_stage = BTreeMap::new(); for (_, stage) in listed { - *by_stage.entry(stage_token(*stage)).or_insert(0_u64) += 1; + *by_stage + .entry(stage.protocol()) + .or_insert_with(BTreeMap::new) + .entry(stage_token(*stage)) + .or_insert(0_u64) += 1; } Attempts { listed: listed.len(), @@ -167,6 +181,7 @@ pub fn support_bundle(facts: &SupportFacts) -> Result, &'static str> { .iter() .map(|(key, stage)| Attempt { key_sha256: hex::encode(key), + protocol: stage.protocol(), stage: stage_token(*stage), }) .collect(), @@ -243,9 +258,22 @@ mod tests { in_flight: 0, }), attempts: Some(vec![ - ([9; 32], GatewayAttemptStage::Unknown), - ([8; 32], GatewayAttemptStage::ObservedByProvider), - ([7; 32], GatewayAttemptStage::Unknown), + ( + [9; 32], + GatewayOperationStage::Mutation(GatewayAttemptStage::Unknown), + ), + ( + [8; 32], + GatewayOperationStage::Mutation(GatewayAttemptStage::ObservedByProvider), + ), + ( + [7; 32], + GatewayOperationStage::Mutation(GatewayAttemptStage::Unknown), + ), + ( + [6; 32], + GatewayOperationStage::Acquisition(AcquisitionStage::Unknown), + ), ]), attempts_truncated: false, } @@ -260,7 +288,12 @@ mod tests { assert_eq!(archive["credential_store_kind"], "aws-secrets-manager-v1"); assert_eq!(archive["qualification"]["state"], "stale"); assert_eq!(archive["connection"]["state"], "disabled"); - assert_eq!(archive["attempts"]["by_stage"]["unknown"], 2); + assert_eq!(archive["attempts"]["by_stage"]["mutation"]["unknown"], 2); + assert_eq!(archive["attempts"]["by_stage"]["acquisition"]["unknown"], 1); + assert_eq!( + archive["attempts"]["identifiers"][3]["protocol"], + "acquisition" + ); assert_eq!( archive["attempts"]["identifiers"][1]["key_sha256"], "08".repeat(32) @@ -288,7 +321,13 @@ mod tests { ]) ); let mut many = facts(); - many.attempts = Some(vec![([5; 32], GatewayAttemptStage::NotEntered); 400]); + many.attempts = Some(vec![ + ( + [5; 32], + GatewayOperationStage::Mutation(GatewayAttemptStage::NotEntered) + ); + 400 + ]); many.attempts_truncated = false; let bytes = support_bundle(&many).expect("archive"); let archive: serde_json::Value = serde_json::from_slice(&bytes).expect("JSON"); diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 31a07e28e..2921a2d81 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -343,6 +343,25 @@ impl GatewayHttpTransport { .await } + /// Consumes one newly acknowledged acquisition grant and sends its exact + /// native request once. No caller supplies replacement URL or byte limits. + pub(crate) async fn recovery_read( + &self, + permit: crate::store::AcquisitionEntryPermit, + lease: &StoredSecretLease, + ) -> Option { + let secret = lease.expose(Instant::now()).ok()?; + let request = permit.request(); + self.read( + reqwest::Method::GET, + request.url(), + request.headers(), + request.maximum_response_bytes(), + secret, + ) + .await + } + /// One bounded read with `secret`: the complete response of any status, /// or `None` after a transport failure or an oversized body. Redirects /// are never followed, so a 3xx comes back as its own status. diff --git a/product/runtime/auths-gateway/tests/support_bundle.rs b/product/runtime/auths-gateway/tests/support_bundle.rs index c66ff0bb8..951e159c8 100644 --- a/product/runtime/auths-gateway/tests/support_bundle.rs +++ b/product/runtime/auths-gateway/tests/support_bundle.rs @@ -158,7 +158,7 @@ fn a_support_bundle_holds_no_planted_canary() { let offline = bundle(&state, &planted); let archive: serde_json::Value = serde_json::from_slice(&offline).expect("archive"); - assert_eq!(archive["schema"], "auths.gateway-support-bundle/1"); + assert_eq!(archive["schema"], "auths.gateway-support-bundle/2"); assert_eq!(archive["recipe_sha256"], digest.as_str()); assert_eq!(archive["deployment"], "development"); assert_eq!(archive["attempts"]["listed"], 0); diff --git a/product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql b/product/stores/auths-stores/migrations/postgres_lifecycle_v8.sql similarity index 92% rename from product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql rename to product/stores/auths-stores/migrations/postgres_lifecycle_v8.sql index c9800a223..b43e526be 100644 --- a/product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql +++ b/product/stores/auths-stores/migrations/postgres_lifecycle_v8.sql @@ -1,13 +1,13 @@ CREATE TABLE auths_lifecycle_store_meta ( singleton BOOLEAN PRIMARY KEY DEFAULT TRUE CHECK (singleton), - schema_version INTEGER NOT NULL CHECK (schema_version = 7), + schema_version INTEGER NOT NULL CHECK (schema_version = 8), contract_id TEXT NOT NULL CHECK ( contract_id = 'auths.lifecycle.transactional-store/4' ) ); INSERT INTO auths_lifecycle_store_meta (singleton, schema_version, contract_id) -VALUES (TRUE, 7, 'auths.lifecycle.transactional-store/4'); +VALUES (TRUE, 8, 'auths.lifecycle.transactional-store/4'); CREATE TABLE auths_lifecycle_records ( workflow_id TEXT PRIMARY KEY CHECK ( @@ -55,7 +55,7 @@ CREATE TABLE auths_recovery_leases ( CREATE TABLE auths_gateway_records ( record_key BYTEA PRIMARY KEY CHECK (octet_length(record_key) = 32), record_kind TEXT NOT NULL CHECK ( - record_kind IN ('attempt', 'count-slot', 'sum-slot', 'connection', 'commissioning-budget', 'effect-configuration') + record_kind IN ('attempt', 'count-slot', 'sum-slot', 'connection', 'commissioning-budget', 'effect-configuration', 'effect-allocation') ), expires_at BIGINT NULL CHECK (expires_at IS NULL OR expires_at >= 0), record_bytes BYTEA NOT NULL CHECK ( diff --git a/product/stores/auths-stores/src/gateway_attempt.rs b/product/stores/auths-stores/src/gateway_attempt.rs index 24a389510..6cf900f53 100644 --- a/product/stores/auths-stores/src/gateway_attempt.rs +++ b/product/stores/auths-stores/src/gateway_attempt.rs @@ -2,7 +2,7 @@ //! //! This is a mechanism only: all-or-none insert-once batches, a //! compare-and-swap replacement, and a bounded sweep of expired slots, over -//! bounded bytes tagged with one of six closed record kinds. The gateway +//! bounded bytes tagged with one of seven closed record kinds. The gateway //! owns every record format, its stages, and which replacements are valid. use crate::lifecycle::{PostgresLifecycleStore, map_postgres_error}; @@ -97,6 +97,8 @@ pub enum GatewayRecordKind { CommissioningBudget, /// Installed effect policy/configuration and shared qualification memory. EffectConfiguration, + /// Permanent effect capacity allocation; never swept or refunded by age. + EffectAllocation, } impl GatewayRecordKind { @@ -110,6 +112,7 @@ impl GatewayRecordKind { Self::Connection => "connection", Self::CommissioningBudget => "commissioning-budget", Self::EffectConfiguration => "effect-configuration", + Self::EffectAllocation => "effect-allocation", } } @@ -123,6 +126,7 @@ impl GatewayRecordKind { "connection" => Some(Self::Connection), "commissioning-budget" => Some(Self::CommissioningBudget), "effect-configuration" => Some(Self::EffectConfiguration), + "effect-allocation" => Some(Self::EffectAllocation), _ => None, } } @@ -508,7 +512,7 @@ mod tests { bounded(&vec![0; MAX_GATEWAY_RECORD_BYTES + 1]), Err(StoreError::LimitExceeded) ); - let schema = include_str!("../migrations/postgres_lifecycle_v7.sql"); + let schema = include_str!("../migrations/postgres_lifecycle_v8.sql"); assert!( schema.contains("octet_length(record_bytes) BETWEEN 1 AND 262144"), "the schema bound and the Rust bound are the same" @@ -520,6 +524,7 @@ mod tests { "connection", "commissioning-budget", "effect-configuration", + "effect-allocation", ] { assert_eq!( GatewayRecordKind::parse(kind).map(GatewayRecordKind::as_str), diff --git a/product/stores/auths-stores/src/lifecycle.rs b/product/stores/auths-stores/src/lifecycle.rs index b00620fd6..6c7549e96 100644 --- a/product/stores/auths-stores/src/lifecycle.rs +++ b/product/stores/auths-stores/src/lifecycle.rs @@ -34,9 +34,9 @@ use tokio_postgres_rustls::MakeRustlsConnect; const DATABASE_MAGIC: &[u8; 8] = b"AUTHSLF1"; const MAX_DATABASE_BYTES: usize = 256 * 1024 * 1024; const MAX_RECORD_BYTES: usize = auths_lifecycle::MAX_LIFECYCLE_RECORD_BYTES; -const SCHEMA_VERSION: i32 = 7; +const SCHEMA_VERSION: i32 = 8; const CONTRACT_ID: &str = "auths.lifecycle.transactional-store/4"; -const POSTGRES_SCHEMA: &str = include_str!("../migrations/postgres_lifecycle_v7.sql"); +const POSTGRES_SCHEMA: &str = include_str!("../migrations/postgres_lifecycle_v8.sql"); /// One closed capacity rule configured by a domain registration. #[derive(Clone, Debug, Eq, PartialEq)] @@ -536,7 +536,7 @@ impl PostgresStoreSummary { /// Returns the physical schema identity. #[must_use] pub const fn schema_id(self) -> &'static str { - "auths.lifecycle.postgresql/7" + "auths.lifecycle.postgresql/8" } /// Returns the transactional store contract identity. diff --git a/xtask/src/semantic_freeze.rs b/xtask/src/semantic_freeze.rs index 647ccaa56..d9bd95fd2 100644 --- a/xtask/src/semantic_freeze.rs +++ b/xtask/src/semantic_freeze.rs @@ -527,7 +527,7 @@ fn generate_inventory() -> Result { "product/fixtures/v1/lifecycle/registry.toml".to_owned(), "product/runtime/auths-lifecycle/src".to_owned(), "product/stores/auths-stores/src/lifecycle.rs".to_owned(), - "product/stores/auths-stores/migrations/postgres_lifecycle_v7.sql".to_owned(), + "product/stores/auths-stores/migrations/postgres_lifecycle_v8.sql".to_owned(), "product/stores/auths-stores/tests/postgres_lifecycle.rs".to_owned(), "product/stores/auths-stores/tests/postgres_tls".to_owned(), ], From 1322d1829f5dd8f023aef262cac229fb7d42e18c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 06:16:11 +0000 Subject: [PATCH 025/136] chore(formal): regenerate qualification artifacts Source-SHA: 3ca2c36488b54fbfc3b0a86c9544896e7c8ee0ab Workflow-Run: 40642554358 --- formal/qualification/aeneas/source-closure.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 534df8e38..b12830c08 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "7641cbe2873f3b33fba2772531267878c2eb1e907d74b379e3885559172dd8be", + "digest": "145371541013f20b442ed785c5985d09733c8f8b6248619521874dfa29a19c45", "files": [ { "path": ".cargo/config.toml", @@ -205,7 +205,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/transition.rs", - "sha256": "f876c72fa70abf6cb76bbd1ad385c48255702c06192889242c7f37b20a112584" + "sha256": "c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51" }, { "path": "product/runtime/auths-lifecycle/Cargo.toml", @@ -401,7 +401,7 @@ }, { "path": "xtask/src/semantic_freeze.rs", - "sha256": "c57617cd19351f71e145974e9c134717ce3d9e816510a8a03c922746b66bb9b0" + "sha256": "f98ace0550ead760eeb850fdb2a120ce0ea953ab2b6112da3a5f80175b222c9a" }, { "path": "xtask/src/stripe.rs", From 9f717d39c8df262770cff8286178befc39804461 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 06:41:17 +0000 Subject: [PATCH 026/136] feat(gateway)!: link recovery evidence and replace operator reads --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 52 ++- .../fixtures/gateway/recovery-refinement.json | 319 +++++++++++++++ compliance.toml | 7 +- demos/airtable-gateway/README.md | 14 +- ...017-bound-effect-and-recovery-ownership.md | 21 + docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md | 31 +- .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 33 +- docs/plans/0074-implementation-status.md | 55 ++- .../0009-bound-effect-and-recovery.md | 18 + .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6519 -> 6519 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6402 -> 6402 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5684 -> 5684 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4993 -> 4993 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/admin.rs | 26 +- product/runtime/auths-gateway/src/app.rs | 69 +++- .../auths-gateway/src/bin/auths-gateway.rs | 141 +++++-- product/runtime/auths-gateway/src/effect.rs | 4 +- .../auths-gateway/src/effect_native_tests.rs | 323 ++++++++++++++- product/runtime/auths-gateway/src/engine.rs | 141 ++++--- product/runtime/auths-gateway/src/lib.rs | 5 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 8 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- product/runtime/auths-gateway/src/recipe.rs | 5 +- .../auths-gateway/src/recipe/response.rs | 86 ++++ .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 74 +++- .../auths-gateway/src/store/acquisition.rs | 11 +- .../src/store/acquisition/recovery.rs | 379 ++++++++++++++++++ product/runtime/auths-gateway/src/submit.rs | 9 +- .../auths-gateway/tests/admin_capacity.rs | 14 +- 40 files changed, 1682 insertions(+), 189 deletions(-) create mode 100644 bindings/fixtures/gateway/recovery-refinement.json create mode 100644 product/runtime/auths-gateway/src/recipe/response.rs create mode 100644 product/runtime/auths-gateway/src/store/acquisition/recovery.rs diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 63fec0a43..4ed01c985 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/7", + "attempt_schema": "auths.gateway-attempt/8", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 6642a83ed..7a8d00ddd 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -185,11 +185,27 @@ "case": null }, { - "code": "gateway.admin.reobserved", + "code": "gateway.admin.recovered", "owner": "admin", "stage": "admin", "status": "new", - "epic": 5, + "epic": 74, + "case": null + }, + { + "code": "gateway.admin.recovery-recorded", + "owner": "admin", + "stage": "admin", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.admin.recovery-refused", + "owner": "admin", + "stage": "admin", + "status": "new", + "epic": 74, "case": null }, { @@ -756,6 +772,30 @@ "id": "account-scope-removed" } }, + { + "code": "gateway.recovery.binding", + "owner": "effect", + "stage": "recovery", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.recovery.not-observable", + "owner": "effect", + "stage": "compile", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.recovery.unavailable", + "owner": "effect", + "stage": "recovery", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.relative-ceiling.above", "owner": "engine", @@ -789,14 +829,6 @@ "id": "relative-basis-unavailable" } }, - { - "code": "gateway.reobserve.not-observable", - "owner": "admin", - "stage": "admin", - "status": "new", - "epic": 5, - "case": null - }, { "code": "gateway.serve.accept-failed", "owner": "serve", diff --git a/bindings/fixtures/gateway/recovery-refinement.json b/bindings/fixtures/gateway/recovery-refinement.json new file mode 100644 index 000000000..fc108c988 --- /dev/null +++ b/bindings/fixtures/gateway/recovery-refinement.json @@ -0,0 +1,319 @@ +{ + "schema": "auths.recovery-refinement-fixture/1", + "scope": "native signed effects and real file journal; synthetic entry validation/provider bodies and controlled deployment clock; no installed transport or PostgreSQL claim", + "cases": [ + { + "case": "http-error", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 503, + "response_bytes": 176, + "response_version_ok": true + }, + "disposition": "response-unusable" + } + }, + { + "case": "wrong-version", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 176, + "response_version_ok": false + }, + "disposition": "response-unusable" + } + }, + { + "case": "missing-field", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + "disposition": "response-unusable" + } + }, + { + "case": "malformed-json", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 1, + "response_version_ok": true + }, + "disposition": "response-unusable" + } + }, + { + "case": "multiple-records", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 75, + "response_version_ok": true + }, + "disposition": "response-unusable" + } + }, + { + "case": "duplicate-members", + "disposition": "response-unusable", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 148, + "response_version_ok": true + }, + "disposition": "response-unusable" + } + }, + { + "case": "state-match-without-echo", + "disposition": "inconclusive", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive" + } + }, + { + "case": "unrelated-echo", + "disposition": "inconclusive", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 61, + "response_version_ok": true + }, + "disposition": "inconclusive" + } + }, + { + "case": "wrong-value", + "disposition": "inconclusive", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 2, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 124, + "response_version_ok": true + }, + "disposition": "inconclusive" + } + }, + { + "case": "exact-linked-evidence", + "disposition": "recorded", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000004 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 176, + "response_version_ok": true + }, + "disposition": "recorded" + } + } + ], + "freshness": { + "maximum_age_seconds": 30, + "age_31_refused": true, + "future_receipt_refused": true, + "age_30_recorded": true + }, + "history": { + "expired_writer_preserved": true, + "late_replay_idempotent": true, + "receipt_time_unchanged": true, + "charges_retained": true, + "no_mutation_readmission": true + }, + "recipe_substitution_refused": true, + "concurrent_refinement": "one recorded, one already-recorded, same immutable facts", + "public_report_excludes_private_content_and_commitments": true, + "admin_frames": [ + { + "frame": { + "command": "recover", + "source_operation": "source-1", + "schema": "auths.gateway-admin-request/2" + }, + "accepted": true + }, + { + "frame": { + "command": "recovery-record", + "source_operation": "source-1", + "acquisition_operation": "read-1", + "schema": "auths.gateway-admin-request/2" + }, + "accepted": true + }, + { + "frame": { + "command": "reobserve", + "operation_id": "source-1", + "schema": "auths.gateway-admin-request/2" + }, + "accepted": false + }, + { + "frame": { + "command": "recover", + "source_operation": "source-1", + "url": "https://untrusted.example/", + "schema": "auths.gateway-admin-request/2" + }, + "accepted": false + }, + { + "frame": { + "command": "recovery-record", + "source_operation": "source-1", + "acquisition_operation": "read-1", + "evidence": "synthetic", + "schema": "auths.gateway-admin-request/2" + }, + "accepted": false + } + ], + "shared_native_submission_decoder": "bounded data only; no authority from decoding" +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 877e84ca9..cb903e32b 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/7", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/1"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/8", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/1", "auths.gateway-admin-response/1", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/7", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/8", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +recovery-refinement = [ + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", +] recovery-entry = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index a40cb2fef..247fcad38 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -58,9 +58,10 @@ does not establish a linked observation. **Lose PATCH response** actually drops the socket after the provider applies the write. The result stays unknown while fresh reads lack its value/echo. -After three seconds choose **Observe lost operation again**. This submits the -original proof/action to the native replay boundary: it can read again, and -cannot PATCH again. The automated journey measures zero new write entries. +The original proof/action replay returns retained history without another read +or PATCH. The demo's recovery UI still needs the AP074 independent read-authority +cutover; it must not be treated as evidence of the completed recovery journey. +Fresh observations require a new native bounded read proof and exact approval. There is no automatic recovery or write retry. **Competing writer** makes a second actual HTTP actor write the same value with @@ -93,11 +94,14 @@ docker exec --user 62004:62005 auths-airtable-gateway-demo \ ``` An IPC failure is unconfirmed, never permission to send another PATCH. -Operator-only read-only re-observation and diagnostics use the shipped CLI: +Operator-only recovery uses a separately authorized native read and exact approval; +diagnostics remain available through the shipped CLI: ```sh docker exec auths-airtable-gateway-demo /opt/demo/bin/auths-gateway-simulation \ - reobserve --state-dir /run/demo/gateway0 --operation-id lost-response + recover --state-dir /run/demo/gateway0 --source-operation lost-response \ + --proof /private/read-proof.cbor --action /private/read-action.cbor \ + --approval /private/read-approval.json docker exec auths-airtable-gateway-demo /opt/demo/bin/auths-gateway-simulation \ doctor --state-dir /run/demo/gateway0 --app-socket /run/demo/sockets/app0.sock \ --app-uid 62004 --app-gid 62005 diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 4dbc4f5a4..817211a39 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -386,3 +386,24 @@ credential replacement, managed bounds, public execution routes and removal of existing raw observation/ancillary paths remain required work. The native file corpus uses synthetic entry validation and response bytes; it is narrow durable mechanism evidence, not an installed authority or transport claim. + + +## Retained recovery evidence and operator cutover + +Journal `/8` adds immutable acquisition provenance to source observation facts. +The existing adapter fence checks source/read/allocation and samples the deployed +clock before the same transition predicate can advance the mutation. Read +receipt time is preserved. Newly recorded evidence must have age 0–30 seconds; +exact already-recorded history does not expire or refresh. Unknown sends require +supported provider linkage; state equality alone does not establish execution. +Duplicate object members are refused by the bounded native observation decoder. + +The production operator `reobserve` path is removed. Admin request/response `/2` +uses `recover` with a separately signed native read and exact approval, or +`recovery-record` with already retained read evidence and no external I/O. +Application and operator input frames share a bounded native decoder. Redacted +recovery report `/1` separates read facts, source facts and evidence disposition +without private content, locators or commitments. The old operator step driver +is test-only; automatic post-write and ancillary/application reads remain the +next production cutovers. The native corpus is file-journal mechanism evidence +with synthetic entry/response/clock inputs, not installed transport qualification. diff --git a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md index c42db3210..07b70b499 100644 --- a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md +++ b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md @@ -151,17 +151,26 @@ and rebuild authority/connection state under owner review; do not serve old operations as fresh. A newly created host without a floor cannot prove that a database is current; recover its floors before starting it. -For each response-recorded or unknown operation, use `reobserve --state-dir -... --operation-id ...` once. It uses the stored plan and a fresh read-only -check under the declared capability. Reobserve requires an enabled connection -because it leases a credential; a disabled or revoked connection refuses even -this read. Only when the restored state passes the continuity and retained-floor -checks, keep app ingress blocked on both hosts, require every other readiness -check to pass, enable and rerun full doctor before reconciling. Do not enable -a quarantined restore to work around a refusal. Confirmed evidence may advance the -record; missing or delayed evidence stays unknown. Reobserve again after -visibility returns; never issue a new provider write as recovery. Keep the -opaque operation digest and stage only in support evidence. +For a response-recorded or unknown operation, author a distinct bounded read +using `effect-recovery-call`, authorize it through the native MCP flow, review +it with `effect-review --recovery-of`, and sign its exact approval. Then use +`recover --state-dir ... --source-operation ... --proof ... --action ... +--approval ...`. The old unapproved `reobserve` command is refused. Each read +reserves capacity permanently from the source's 16-attempt count/byte limit. +Changed credentials and unimplemented ancillary/read-policy bounds fail closed. + +A new read requires an enabled connection. Only when restored state passes the +continuity and retained-floor checks, keep app ingress blocked on both hosts, +require every other readiness check to pass, enable and rerun full doctor before +reconciling. Do not enable a quarantined restore to work around a refusal. +`recovery-record --source-operation ... --acquisition-operation ...` can record +fresh evidence already acquired; it performs no provider or credential I/O and +does not borrow the writer's authority. New evidence must be no older than 30 +seconds at the journal fence. Stale, missing or inconclusive evidence leaves the +source unresolved and charged. A repeated recorded fact is history with its +original timestamp. No recovery command authorizes another mutation send. +Retain only native redacted reports in support evidence. The complete installed +AP074 recovery journey and fault evidence remain under implementation. ## Rolling upgrade diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index ef1f9f368..528abdbbd 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -76,9 +76,30 @@ A compiled read cannot be sent through mutation `submit`. The native runtime now has a separate recovery acquisition entry point with permanent count/byte allocation and a durable one-use grant. It refuses recipes needing additional credential reads until those reads are accounted for. The commands above still -perform authoring/review only. Source-evidence refinement, public execution -routes, installed authenticated review, frontend, and full concurrency/fault -evidence remain open AP074 requirements. +perform authoring/review only. After signing the exact review request and +assembling `read-approval.json`, the owner-only operator socket accepts: + +```text +auths-gateway recover --state-dir --source-operation \ + --proof read-proof.cbor --action read-action.cbor --approval read-approval.json +auths-gateway recovery-record --state-dir \ + --source-operation --acquisition-operation +``` + +`recover` performs the independently authorized read and then attempts evidence +refinement. `recovery-record` only uses an already retained acquisition response; +it performs no credential or provider I/O. The original writer's expired proof +is never reused as read authority. Freshness is checked under the journal fence: +evidence older than 30 seconds, or with a future receipt time, cannot newly +refine the source. A previously recorded fact remains history and does not get +a new time on replay. Unknown sends remain unknown without supported linked +evidence; a state match alone does not prove the original write occurred. + +Admin request/response `/2` removes the unapproved `reobserve` command. Native +recovery report `/1` separates read and mutation facts and excludes provider +content, locators, echo and private commitments. Installed transport/fault +coverage, the authenticated approval frontend, ancillary acquisition cutovers +and full acceptance evidence remain open AP074 requirements. A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints @@ -155,7 +176,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/7`; a store holding obsolete records is refused as + `auths.gateway-attempt/8`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. @@ -212,7 +233,7 @@ held which key, is operator evidence and is not produced by this code. - **Sockets.** `serve` keeps separate capacity for the app socket (`--app-capacity`, 1–1 024, default 64) and the owner-only `admin.sock` (4), so `auths-gateway disable`, `enable`, `revoke`, `rotate`, `status`, - and `reobserve` still connect while the application holds or refills the + and `recovery-record` still connect while the application holds or refills the app socket. A connection past either socket's capacity is closed at accept without a response. An admin change commits without waiting for any submission or provider call, then waits at most 20 seconds for this @@ -229,7 +250,7 @@ held which key, is operator evidence and is not produced by this code. must already exist, equal its canonical path (on macOS `/tmp` resolves to `/private/tmp`), be owned by the gateway's UID, and grant no group or other permission (mode 0700 or narrower); `rotate` sends the credential - over this socket. Give `disable`, `enable`, `status`, `reobserve`, + over this socket. Give `disable`, `enable`, `status`, `recover`, `recovery-record`, `revoke`, `rotate`, `operator-attest`, and `doctor` the same `--admin-socket`; without it they look for `/admin.sock` and report `gateway.admin.socket-unavailable` naming that path. The admin diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 61a2a20ed..39144a475 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -453,14 +453,61 @@ closure regeneration passed after that correction (one artifact-generation test) bindings, installed fault/race evidence and final formal/CI gates. No A01–A22 acceptance criterion is closed by this checkpoint. +## Recovery evidence and operator cutover checkpoint + +- Journal `/8` links newly recorded source evidence to the independently + authorized acquisition effect, operation, revision, original receipt time and + exact private response digest. It preserves source binding, actor attribution, + grant, response history and charges. Source/read/allocation and the deployment + clock are checked under the existing adapter fence; no new transaction owner + or provider capability is introduced by evidence recording. +- Evidence is fresh through age 30 seconds; older or future-dated bytes cannot + newly refine a source. HTTP error, wrong version, malformed/missing/multiple + records and duplicate JSON members are unusable. Value equality without the + expected echo cannot resolve an unknown write. Recipe observation parsing now + rejects duplicate members at every depth while retaining its byte/depth bounds. +- Exact supported echo/value evidence can refine an unknown mutation. Its private + provenance is immutable; repeated recording after expiry returns history with + the original time and charges. The source's retained contract remains available + for exact read replay after refinement; new read entry still requires an + eligible source under the grant fence. +- Removed `GatewayEngine::reobserve` and the operator `reobserve` command. Admin + request/response `/2` exposes `recover` with a second bounded native + proof/action/approval frame and `recovery-record` for previously acquired + evidence without provider/custody I/O. Both submission channels reuse one + bounded input decoder. The former operator driver is a test-only reference. + Automatic post-write and other ancillary/application read paths still require + cutover; they are not made compliant by removing the operator endpoint. +- Native recovery report `/1` exposes separate source/acquisition stages, + revisions, retained count/byte capacity and evidence disposition. It excludes + provider bytes, locators, echo, action commitments and private response digests. + This report is not a content-disclosure capability. +- `recovery-refinement.json` extends the signed-proof/file-journal corpus with + unusable/inconclusive cases, age 30/31 and future-receipt boundaries, simultaneous + refinement (one update and one exact history result), expired-writer history, + unchanged receipt time/charges, recipe substitution refusal, redacted reports + and closed admin frame grammar. Provider bodies, entry validation and the + controllable clock remain synthetic. Installed sockets/provider transport, + lock-wait expiry, PostgreSQL, crash/ACK-loss and full binding evidence are open. +- Required native recovery/entry/replay, attempt-scenario, stable/production-code, + custody and qualification schema/verification artifact construction passed. + Final CLI approval-envelope construction matched the signed corpus; final + semantic closure generation passed on `1322d182` plus this source. Remote bot + commit `1322d182` changed only formal qualification source-closure hashes and + was preserved by fast-forward. No broad local suite or hosted CI was run. +- This source does not close A01–A22. Safe credential replacement, managed read + bounds, ordered admission, remaining read cutovers, disclosure/ACK, complete + UI/bindings, generated histories, final formal/release artifacts and hosted CI + remain required. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | -| P2 | Mutation grant and reservation restart wired | Public projections, independent recovery, installed fault/race evidence and formal links | -| P3 | Recovery acquisition journal and runtime entry wired | Ancillary read/source-evidence cutover, disclosure/ACK; remove Python semantic owner | +| P2 | Mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | +| P3 | Recovery acquisition/refinement and operator route wired | Remaining read cutovers, disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -481,11 +528,11 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A08 | ACK loss, restart, no redelivery, late ACK | Pending / no / no | Typed ACK protocol | | A09 | ACK substitution in every dimension | Pending / no / no | Authenticated exact ACK | | A10 | Timeout/denial/response/state-match distinction | Pending / no / no | Native projection | -| A11 | Missing/multiple/unrelated/incomplete reconciliation | Pending / no / no | Bounded independent observation | +| A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | | A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | -| A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file journal / synthetic entry only | Source refinement, revocation and installed execution | +| A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index f80afc3db..c05c14a94 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -216,3 +216,21 @@ slots, permanent retention, private response history and mixed-protocol stage projection. It establishes neither provider execution nor installed revocation, PostgreSQL parity, process crash behavior, source-evidence freshness or disclosure. Those remain required independent evidence and cutover gates. + + +## Evidence refinement comparison + +The concrete recovery-read response is evaluated against its original closed +source contract inside the shared source/read/allocation fence. No response field +selects a provider implementation. The existing typed read-back distinction is +retained: exact echo plus expected value can link provider evidence; equality +without that echo cannot resolve an unknown mutation. Duplicate object members +are rejected instead of silently choosing one value. This parsing hardening is +a bounded observation leaf, not a new provider-semantic evaluator. + +`recovery-refinement.json` covers unusable/missing/multiple/duplicate responses, +unrelated echo and noncausal equality, freshness boundaries, concurrent/idempotent +recording, source attribution/charge retention and report privacy. It also freezes +the closed replacement operator-frame grammar. These are native file-journal +results with synthetic response, clock and entry validation; independent process, +installed transport, PostgreSQL and final differential evidence are still needed. diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 72fc68290..7643b218a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index cf1137e70..9040fdbbe 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 0bbd09fe7..cd209ec19 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 6bd61f32c..ce0bc61a3 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 192705591..9c4c2074b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/7","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 7cf858e1dd3d651e41bb68a20d22343285b3c953..d72e25a36cfcdc586469481c5994bfc75b659f5f 100644 GIT binary patch delta 25 ecmexv^xbHJ5u?TCtvq|VHhJOFxU2^RnW delta 25 dcmZoNYBHK&#Av>GE6-l8%^$dqFoM~>JOFx62^9bU diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 6fd46e6b827db33fce9ed07481c8bb703cc270a2..1d1826a52986b72a8a5501710e09dcdd78de1159 100644 GIT binary patch delta 25 ecmdm@vqfiu5u?TChnzduH@{~8$_Qo$^8f&b@CoPu delta 25 ecmdm@vqfiu5u^F$hnzduH@{~8$_Qo$^8f&b*a_wU diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index c96aec16fe2dae78876b71ba5db7d9de538ade7e..8d031aa429a040e02f3fe9980f344f60dd7f316a 100644 GIT binary patch delta 25 dcmZovZ&aUP#AvbkA?G{x&59iR8NuuYoB(xu2>Ad2 delta 25 dcmZovZ&aUP#Av?xA?G{x&59iR8NuuYoB(xW2=@R0 diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 86d26e812..5203b0820 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"0dee40a9fb67c5de10142fc37a7bbabdd8979fb0199fb26caf4bdb024e0a5a40"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e8036e6892cea1b2f77e44102f843ec3918dcf8c50fa19532fb294acbcf6c893"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0bc408ce7a8a6e52426be04e79bc0b89e143fc43c76aab1cd6a757f462a90061"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"210880c01803c7f7ef7acef5886a05c347db66af709b1316885f3b23ca32e4ff"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"d2f34174f9111240f054e8e959a3ce861f84187ddb735b210483f07f9a434bc2"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4ac0e694b8152698b946d29c78d667a814e2ae960eccd47ec99792bf26b595a7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"5fe809d9e07c2b73bbadc9ddd51e627e34df2c413771e5c62e91d89329bdf9b0"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"07e37424f7c7487a5cd600aa58cbd2bad2f3e714cd22916097180049d173c8e2"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"d202c236a634379634fcbdf6803736bb63e50c839502bfe6ba3bfea0219ae516"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"11442e9254c29f6eb09e862b599e21a761093a629ea3d559c96507ab56e0289e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b85bae6de739ff345dd97583009c58c3b22af92e3c06a4c81426eeeea4cb7dcf"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"61bd6ad144cf064806d72342882b67192d669ac5cb4b5d1de6af5a8b09249946"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"eada49a01083d7869d256e1831e56c0a4507b4e2170ff5bbbc0baeb780fd08c5"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"49b7f36a682a746b5023d6361e07453348f9962505d21a90a7e18cc5c0783591"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"a41b864c32929dd2c7895cb354319a6fc8d89d80366bc54edff06253e2f20566"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"72138d516eabe700ac516d4a6b13654a1eaae9c9fa33e0269187005bfb0d1bbf"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"adfa056c9fcbe7e061754b07fc36c0efa0298a81ac8c6744ee873bfdb14a1b2e"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"35bcb4b4c40e62efa83c90dd558fce517dd7371a518630d54cfb9e5c2a7976ed"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a9d75cdbdbc459bc3a282618e682b11dccf902a8d43caca26607aab779afadbd"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"b96753f7ba3197f5dd9c11440cd258a3f4d46b3cc474bbade7fbda41b35b13b0"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2b9e05c65435c91edc6594d667d07dd8664faa61499074a98422272537fd0dac"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"44b86b5b0277257b8d4c9628a977420b0c0f67cf7fd2220b413feca3aeb77b68"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"6d237830bc11cce09dff4a5895041a11c66ba172405b99ad7c664352c80c7e60"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"58ae05d87af3b750d42e8baa50f967ef9ae46b5c7c05a50f1af4cbd6bce12361"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"cde0279ce6ebd736c99102554ebb726a5147ef19470fe743141fdc50cf1519c4"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ce93d41787c170874abe73d517c2e21720fc04b997650743205c5977cba9ef72"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"bb7abcc4dbafec8efd29a3801795f687e133b95bef892b1fcb0f689c3f3dbe8b"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/admin.rs b/product/runtime/auths-gateway/src/admin.rs index bb67d56e2..cbffa4efb 100644 --- a/product/runtime/auths-gateway/src/admin.rs +++ b/product/runtime/auths-gateway/src/admin.rs @@ -1,14 +1,13 @@ //! The operator socket's request frame: one JSON object with exactly the -//! schema, the command, and that command's arguments. A secret, which only -//! `rotate` and `rotate-prepare` carry, travels in a second frame and never -//! in this one. +//! schema, the command, and that command's arguments. Rotation secrets and +//! recovery proof/action/approval inputs travel in a second bounded frame. use serde::Deserialize; /// Schema of an admin request frame. -pub const ADMIN_REQUEST_SCHEMA: &str = "auths.gateway-admin-request/1"; +pub const ADMIN_REQUEST_SCHEMA: &str = "auths.gateway-admin-request/2"; /// Schema of an admin response frame. -pub const ADMIN_RESPONSE_SCHEMA: &str = "auths.gateway-admin-response/1"; +pub const ADMIN_RESPONSE_SCHEMA: &str = "auths.gateway-admin-response/2"; /// One admin command and its arguments. #[derive(Clone, Debug, Deserialize, Eq, PartialEq)] @@ -40,14 +39,21 @@ pub enum AdminRequestCommand { /// Read the qualification inputs the operator placed on this host again /// and report the resulting state. QualificationReload {}, - /// Re-observe one logical operation, read-only. - Reobserve { - /// The logical operation ID. - operation_id: String, + /// Acquire/refine one recovery read; a native submission follows in frame 2. + Recover { + /// Retained source mutation whose contract the read must bind. + source_operation: String, + }, + /// Record evidence from an existing acquisition without provider/custody I/O. + RecoveryRecord { + /// Retained source mutation. + source_operation: String, + /// Separately authorized read whose response is already retained. + acquisition_operation: String, }, } -/// Parses one `auths.gateway-admin-request/1` frame. +/// Parses one `auths.gateway-admin-request/2` frame. /// /// # Errors /// Returns `gateway.admin.invalid-frame` for anything but a JSON object with diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 2a9f228c9..6915184d3 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -139,6 +139,48 @@ pub struct AppSubmission { pub approval_b64: String, } +/// Bounded decoded transport input. This is data only, not verified authority. +pub struct DecodedSubmission { + /// Canonical proof bytes for native verification. + pub proof: Zeroizing>, + /// Canonical action bytes for native verification. + pub action: Zeroizing>, + /// Parsed exact-effect approval; native entry still validates it. + pub approval: ExactEffectApproval, +} + +impl AppSubmission { + /// Decodes one bounded proof/action/approval frame without authorizing it. + /// + /// # Errors + /// Refuses wrong schema, oversized fields and invalid native encoding. + pub fn decode(&self) -> Result { + let invalid = "gateway.submit.invalid-encoding"; + if self.schema != APP_REQUEST_SCHEMA + || self.approval_b64.len() > (MAX_EFFECT_APPROVAL_BYTES * 4).div_ceil(3) + { + return Err("gateway.submit.invalid-frame"); + } + if self.proof_b64.len() > (4 * 1024 * 1024 * 4_usize).div_ceil(3) + || self.action_b64.len() > (64 * 1024 * 4_usize).div_ceil(3) + { + return Err(invalid); + } + let proof = + Zeroizing::new(Base64UrlUnpadded::decode_vec(&self.proof_b64).map_err(|_| invalid)?); + let action = + Zeroizing::new(Base64UrlUnpadded::decode_vec(&self.action_b64).map_err(|_| invalid)?); + let approval = + Zeroizing::new(Base64UrlUnpadded::decode_vec(&self.approval_b64).map_err(|_| invalid)?); + let approval = ExactEffectApproval::from_private_bytes(&approval).map_err(|_| invalid)?; + Ok(DecodedSubmission { + proof, + action, + approval, + }) + } +} + impl Drop for AppSubmission { fn drop(&mut self) { self.proof_b64.zeroize(); @@ -258,26 +300,15 @@ fn invalid_frame() -> GatewaySubmitResult { } async fn submit_frame(submission: AppSubmission, application: &impl GatewayApplication) -> Vec { - let result = if submission.schema == APP_REQUEST_SCHEMA - && submission.approval_b64.len() <= (MAX_EFFECT_APPROVAL_BYTES * 4).div_ceil(3) - { - match ( - Base64UrlUnpadded::decode_vec(&submission.proof_b64).map(Zeroizing::new), - Base64UrlUnpadded::decode_vec(&submission.action_b64).map(Zeroizing::new), - Base64UrlUnpadded::decode_vec(&submission.approval_b64) - .ok() - .map(Zeroizing::new) - .and_then(|bytes| ExactEffectApproval::from_private_bytes(&bytes).ok()), - ) { - (Ok(proof), Ok(action), Some(approval)) => { - application.submit(&proof, &action, approval).await - } - _ => GatewaySubmitResult::Indeterminate { - code: "gateway.submit.invalid-encoding".to_owned(), - }, + let result = match submission.decode() { + Ok(decoded) => { + application + .submit(&decoded.proof, &decoded.action, decoded.approval) + .await } - } else { - invalid_frame() + Err(code) => GatewaySubmitResult::Indeterminate { + code: code.to_owned(), + }, }; serde_json::to_vec(&result).unwrap_or_default() } diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index fecf749b2..a62dd7501 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -509,17 +509,31 @@ mod unix { #[arg(long)] admin_socket: Option, }, - /// Ask the private operator socket for one read-only re-observation - /// of a stored attempt. - Reobserve { + /// Acquire and refine one separately authorized bounded recovery read. + Recover { #[arg(long)] state_dir: PathBuf, - /// The admin socket `serve` was given with `--admin-socket`; - /// defaults to `/admin.sock`. #[arg(long)] admin_socket: Option, #[arg(long)] - operation_id: String, + source_operation: String, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + }, + /// Refine from an existing acquisition response; performs no provider I/O. + RecoveryRecord { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + admin_socket: Option, + #[arg(long)] + source_operation: String, + #[arg(long)] + acquisition_operation: String, }, /// Print the operator statement and the preimage the operator's own /// signer signs for `install --operator-attestation`. Prints no @@ -1025,6 +1039,8 @@ mod unix { execution_witness: Option, #[serde(skip_serializing_if = "Option::is_none")] result: Option, + #[serde(skip_serializing_if = "Option::is_none")] + recovery: Option, /// The reference commitment of a prepared successor. It names the /// stored secret without revealing it or where it is kept. #[serde(skip_serializing_if = "Option::is_none")] @@ -1065,6 +1081,7 @@ mod unix { status: None, execution_witness: None, result: None, + recovery: None, commitment: None, qualification: None, } @@ -2193,7 +2210,14 @@ mod unix { RotateCommit([u8; 32]), Status, ExecutionWitness, - Reobserve(String), + Recover { + source_operation: String, + submission: Box, + }, + RecoveryRecord { + source_operation: String, + acquisition_operation: String, + }, QualificationReload, } @@ -2214,9 +2238,22 @@ mod unix { AdminRequestCommand::Status {} => Ok(AdminCommand::Status), AdminRequestCommand::ExecutionWitness {} => Ok(AdminCommand::ExecutionWitness), AdminRequestCommand::QualificationReload {} => Ok(AdminCommand::QualificationReload), - AdminRequestCommand::Reobserve { operation_id } => { - Ok(AdminCommand::Reobserve(operation_id)) + AdminRequestCommand::Recover { source_operation } => { + let frame = Zeroizing::new(clock.read_frame(stream).await?); + let submission: AppSubmission = + serde_json::from_slice(&frame).map_err(|_| "gateway.admin.invalid-frame")?; + Ok(AdminCommand::Recover { + source_operation, + submission: Box::new(submission.decode()?), + }) } + AdminRequestCommand::RecoveryRecord { + source_operation, + acquisition_operation, + } => Ok(AdminCommand::RecoveryRecord { + source_operation, + acquisition_operation, + }), AdminRequestCommand::Rotate {} => read_admin_secret(clock, stream) .await .map(AdminCommand::Rotate), @@ -2322,12 +2359,42 @@ mod unix { Err(_) => AdminResponse::refused("gateway.qualification.unavailable"), } } - Ok(AdminCommand::Reobserve(operation_id)) => { - match engine.reobserve(&operation_id).await { - Ok(result) => AdminResponse { + Ok(AdminCommand::Recover { + source_operation, + submission, + }) => { + match engine + .recover( + &source_operation, + &submission.proof, + &submission.action, + submission.approval, + ) + .await + { + Ok(snapshot) => AdminResponse { ok: true, + recovery: Some(snapshot.report()), + ..AdminResponse::refused("gateway.admin.recovered") + }, + Err(result) => AdminResponse { result: Some(result), - ..AdminResponse::refused("gateway.admin.reobserved") + ..AdminResponse::refused("gateway.admin.recovery-refused") + }, + } + } + Ok(AdminCommand::RecoveryRecord { + source_operation, + acquisition_operation, + }) => { + match engine + .refine_recovery(&source_operation, &acquisition_operation) + .await + { + Ok(snapshot) => AdminResponse { + ok: true, + recovery: Some(snapshot.report()), + ..AdminResponse::refused("gateway.admin.recovery-recorded") }, Err(code) => AdminResponse::refused(code), } @@ -4119,14 +4186,42 @@ mod unix { let command = serde_json::json!({"command": "status"}); admin_command(&state_dir, &admin_socket, command, None).await } - Command::Reobserve { + Command::Recover { state_dir, admin_socket, - operation_id, + source_operation, + proof, + action, + approval, } => { let admin_socket = admin_socket_path(&state_dir, admin_socket); + let approval = read_effect_approval(&approval)? + .to_private_bytes() + .map_err(|_| "gateway.effect.approval")?; + let proof = Zeroizing::new(read_bounded(&proof, 4 * 1024 * 1024)?); + let action = Zeroizing::new(read_bounded(&action, 64 * 1024)?); + let submission = AppSubmission { + schema: APP_REQUEST_SCHEMA.to_owned(), + proof_b64: Base64UrlUnpadded::encode_string(&proof), + action_b64: Base64UrlUnpadded::encode_string(&action), + approval_b64: Base64UrlUnpadded::encode_string(&approval), + }; + let frame = Zeroizing::new( + serde_json::to_vec(&submission).map_err(|_| "gateway.admin.invalid-frame")?, + ); let command = - serde_json::json!({"command": "reobserve", "operation_id": operation_id}); + serde_json::json!({"command": "recover", "source_operation": source_operation}); + admin_command(&state_dir, &admin_socket, command, Some(&frame)).await + } + Command::RecoveryRecord { + state_dir, + admin_socket, + source_operation, + acquisition_operation, + } => { + let admin_socket = admin_socket_path(&state_dir, admin_socket); + let command = serde_json::json!({"command": "recovery-record", "source_operation": source_operation, + "acquisition_operation": acquisition_operation}); admin_command(&state_dir, &admin_socket, command, None).await } Command::OperatorRequest { @@ -4533,21 +4628,21 @@ mod unix { parse(serde_json::json!({"schema": ADMIN_REQUEST_SCHEMA, "command": "disable"})) .expect("disable"); assert!(matches!(disable, AdminRequestCommand::Disable {})); - let reobserve = parse(serde_json::json!({ + let recover = parse(serde_json::json!({ "schema": ADMIN_REQUEST_SCHEMA, - "command": "reobserve", - "operation_id": "op-1" + "command": "recover", + "source_operation": "op-1" })) - .expect("reobserve"); + .expect("recover"); assert!(matches!( - reobserve, - AdminRequestCommand::Reobserve { ref operation_id } if operation_id == "op-1" + recover, + AdminRequestCommand::Recover { ref source_operation } if source_operation == "op-1" )); for refused in [ serde_json::json!({"command": "disable"}), serde_json::json!({"schema": ADMIN_REQUEST_SCHEMA, "command": "delete"}), serde_json::json!({"schema": ADMIN_REQUEST_SCHEMA, "command": "disable", "secret": "x"}), - serde_json::json!({"schema": "auths.gateway-admin-request/2", "command": "disable"}), + serde_json::json!({"schema": "auths.gateway-admin-request/1", "command": "disable"}), serde_json::json!({"schema": ADMIN_REQUEST_SCHEMA, "command": "reobserve"}), ] { assert!(parse(refused.clone()).is_err(), "{refused}"); diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 2fe5f85d1..0b770d1df 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -19,7 +19,9 @@ use std::fmt; use zeroize::Zeroizing; mod acquisition; -pub(crate) use acquisition::{RECOVERY_READ_TOOL, RecoveryCapacity, RecoveryPlan}; +pub(crate) use acquisition::{ + MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, RecoveryCapacity, RecoveryPlan, +}; pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; /// Only accepted effect binding schema. Old disposable state is rejected. diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 0c960edec..8393692c8 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -216,7 +216,9 @@ async fn native_recovery_acquisition_fixture_is_current() { ) .expect("same read"); assert!( - other.approve(original_approval, &public, NOW + 2).is_err(), + other + .approve(original_approval.clone(), &public, NOW + 2) + .is_err(), "write approval cannot authorize the read" ); let mut refused = Vec::new(); @@ -302,7 +304,8 @@ async fn native_recovery_acquisition_fixture_is_current() { .expect("exact read approval"), )); } - let corpus = exercise_recovery_journal(&attempts, &root_path, policy.clone(), reads).await; + let corpus = + exercise_recovery_journal(&attempts, &root_path, policy.clone(), reads.clone()).await; assert_eq!( attempts .read(recipe.namespace(), &operation) @@ -317,6 +320,61 @@ async fn native_recovery_acquisition_fixture_is_current() { std::fs::write(&path, &bytes).expect("write recovery entry corpus"); } assert_eq!(std::fs::read(path).expect("recovery entry corpus"), bytes); + let mut corpus = exercise_recovery_refinement(&attempts, &recipe, &source, &reads).await; + let mut frame_cases = Vec::new(); + for (command, accepted) in [ + ( + json!({"command": "recover", "source_operation": "source-1"}), + true, + ), + ( + json!({"command": "recovery-record", "source_operation": "source-1", "acquisition_operation": "read-1"}), + true, + ), + ( + json!({"command": "reobserve", "operation_id": "source-1"}), + false, + ), + ( + json!({"command": "recover", "source_operation": "source-1", "url": "https://untrusted.example/"}), + false, + ), + ( + json!({"command": "recovery-record", "source_operation": "source-1", "acquisition_operation": "read-1", "evidence": "synthetic"}), + false, + ), + ] { + let mut frame = command; + frame["schema"] = json!(crate::admin::ADMIN_REQUEST_SCHEMA); + let bytes = serde_json::to_vec(&frame).expect("admin frame"); + assert_eq!(crate::admin::parse_admin_request(&bytes).is_ok(), accepted); + frame_cases.push(json!({"frame": frame, "accepted": accepted})); + } + corpus["admin_frames"] = json!(frame_cases); + let frame = crate::app::AppSubmission { + schema: crate::app::APP_REQUEST_SCHEMA.to_owned(), + proof_b64: Base64UrlUnpadded::encode_string(&original.proof), + action_b64: Base64UrlUnpadded::encode_string(&original.action), + approval_b64: Base64UrlUnpadded::encode_string( + &original_approval.to_private_bytes().expect("approval"), + ), + }; + let decoded = frame.decode().expect("bounded shared input decoder"); + assert_eq!(&*decoded.proof, &original.proof); + assert_eq!(&*decoded.action, &original.action); + assert_eq!( + decoded.approval.to_private_bytes().expect("approval"), + original_approval.to_private_bytes().expect("approval") + ); + corpus["shared_native_submission_decoder"] = + json!("bounded data only; no authority from decoding"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/recovery-refinement.json"); + let bytes = serde_json::to_vec_pretty(&corpus).expect("refinement corpus"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write refinement corpus"); + } + assert_eq!(std::fs::read(path).expect("refinement corpus"), bytes); } /// Real file-journal race and restart evidence. Both source and read entry use @@ -494,6 +552,267 @@ async fn exercise_recovery_journal( }) } +/// Signed read effects and durable file records with synthetic provider bodies. +/// No installed authority, network or PostgreSQL claim is made by this corpus. +#[allow( + clippy::too_many_lines, + reason = "one native evidence history and its refusal matrix" +)] +async fn exercise_recovery_refinement( + attempts: &crate::GatewayAttempts, + recipe: &CompiledRecipe, + source: &std::sync::Arc, + reads: &[std::sync::Arc], +) -> Value { + use crate::{AcquisitionClaim, AcquisitionStage, RecoveryDisposition as D}; + use std::sync::Arc; + let source_operation = LogicalOperationId::parse("source-1").expect("source operation"); + let namespace = recipe.namespace(); + let before = attempts + .read(namespace, &source_operation) + .await + .expect("source") + .expect("record"); + let token = crate::echo_token(namespace, &source_operation, before.action_commitment()); + let matched = + serde_json::to_vec(&json!({"fields": {"DemoStatus": "Approved", "auths_echo": token}, "private_note": "synthetic-recovery-content-canary"})) + .expect("body"); + let cases = vec![ + ("http-error", 503, true, matched.clone(), D::ResponseUnusable), + ("wrong-version", 200, false, matched.clone(), D::ResponseUnusable), + ("missing-field", 200, true, b"{}".to_vec(), D::ResponseUnusable), + ("malformed-json", 200, true, b"{".to_vec(), D::ResponseUnusable), + ("multiple-records", 200, true, b"[{\"fields\":{\"DemoStatus\":\"Approved\"}},{\"fields\":{\"DemoStatus\":\"Approved\"}}]".to_vec(), D::ResponseUnusable), + ("duplicate-members", 200, true, format!("{{\"fields\":{{\"DemoStatus\":\"Pending\",\"DemoStatus\":\"Approved\",\"auths_echo\":\"{token}\"}}}}").into_bytes(), D::ResponseUnusable), + ("state-match-without-echo", 200, true, b"{\"fields\":{\"DemoStatus\":\"Approved\"}}".to_vec(), D::Inconclusive), + ("unrelated-echo", 200, true, b"{\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"unrelated\"}}".to_vec(), D::Inconclusive), + ("wrong-value", 200, true, serde_json::to_vec(&json!({"fields": {"DemoStatus": "Pending", "auths_echo": token}})).expect("body"), D::Inconclusive), + ("exact-linked-evidence", 200, true, matched.clone(), D::Recorded), + ]; + let clock = Arc::new(crate::FixedClock::at(NOW + 4)); + let gate = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::clone(&clock)), + auths_recipe_qualification::VerifierState::default(), + )); + let mut available = Vec::new(); + for read in reads { + if attempts + .read_recovery(read) + .await + .expect("read") + .expect("record") + .stage + == AcquisitionStage::Reserved + { + available.push(Arc::clone(read)); + } + } + assert!(available.len() >= cases.len()); + let incomplete = LogicalOperationId::parse(reads[0].effect().binding().journal_identity().1) + .expect("operation"); + let unknown = attempts + .refine_recovery( + namespace, + &source_operation, + &incomplete, + *recipe.digest(), + Arc::clone(&gate), + ) + .await + .expect("incomplete history"); + assert_eq!(unknown.disposition, D::AcquisitionIncomplete); + assert_eq!(unknown.source, before); + let mut outcomes = Vec::new(); + for ((name, status, version_ok, body, expected), read) in cases.into_iter().zip(&available) { + let operation = LogicalOperationId::parse(read.effect().binding().journal_identity().1) + .expect("read operation"); + let AcquisitionClaim::Reserved(reserved) = attempts + .claim_recovery(read, NOW + 2) + .await + .expect("resume") + else { + panic!("reservation"); + }; + let (granted, permit) = reserved + .grant_entry( + Arc::clone(read), + crate::entry::EntryValidation::Oracle { now: NOW + 3 }, + NOW + 2, + ) + .await + .expect("grant"); + drop(permit); + granted + .record_response(status, version_ok, &body, NOW + 4) + .await + .expect("synthetic response"); + assert!( + attempts + .refine_recovery( + namespace, + &source_operation, + &operation, + [255; 32], + Arc::clone(&gate) + ) + .await + .is_err(), + "wrong recipe" + ); + if expected == D::Recorded { + clock.set(NOW + 35); + let stale = attempts + .refine_recovery( + namespace, + &source_operation, + &operation, + *recipe.digest(), + Arc::clone(&gate), + ) + .await + .expect("stale history"); + assert_eq!(stale.disposition, D::EvidenceStale); + assert_eq!(stale.source, before); + clock.set(NOW + 3); + let future = attempts + .refine_recovery( + namespace, + &source_operation, + &operation, + *recipe.digest(), + Arc::clone(&gate), + ) + .await + .expect("future history"); + assert_eq!(future.disposition, D::EvidenceStale); + assert_eq!(future.source, before); + clock.set(NOW + 34); + } + let refine = || { + attempts.refine_recovery( + namespace, + &source_operation, + &operation, + *recipe.digest(), + Arc::clone(&gate), + ) + }; + let result = if expected == D::Recorded { + let (first, second) = tokio::join!(refine(), refine()); + let (first, second) = ( + first.expect("concurrent refinement"), + second.expect("concurrent refinement"), + ); + assert_eq!(first.source, second.source); + let (recorded, replay) = if first.disposition == D::Recorded { + (first, second) + } else { + (second, first) + }; + assert_eq!(replay.disposition, D::AlreadyRecorded); + recorded + } else { + refine().await.expect("refinement") + }; + assert_eq!(result.disposition, expected, "{name}"); + assert_eq!(result.acquisition.reserved_calls, 1); + if expected == D::Recorded { + assert_eq!( + result.source.stage(), + crate::GatewayAttemptStage::ObservedByProvider + ); + assert_eq!(result.source.revision(), before.revision() + 1); + assert_eq!(result.source.evaluated_at(), before.evaluated_at()); + assert_eq!( + result.source.action_commitment(), + before.action_commitment() + ); + assert_eq!(result.source.counters(), before.counters()); + assert_eq!(result.source.response_status(), None); + assert!(result.source.has_recovery_evidence()); + assert_eq!(result.source.recovery_received_at(), Some(NOW + 4)); + assert_eq!( + result + .source + .provider_evidence() + .expect("evidence") + .evidence(), + matched + ); + clock.set(NOW + 1000); + let replay = attempts + .refine_recovery( + namespace, + &source_operation, + &operation, + *recipe.digest(), + Arc::clone(&gate), + ) + .await + .expect("late history replay"); + assert_eq!(replay.disposition, D::AlreadyRecorded); + assert_eq!(replay.source, result.source); + assert_eq!(replay.acquisition, result.acquisition); + let retained = attempts + .retained_recovery_target(namespace, &source_operation, *recipe.digest()) + .await + .expect("terminal contract remains available for replay"); + assert!( + retained.journal_plan().expect("retained plan") + == read + .recovery_target() + .expect("read target") + .journal_plan() + .expect("approved plan") + ); + assert!( + matches!( + attempts + .claim_recovery(read, NOW + 4) + .await + .expect("read replay"), + AcquisitionClaim::Existing(_) + ), + "terminal read cannot grant again" + ); + assert!( + matches!( + attempts.claim_bounded(source, NOW).await, + Err(crate::GatewayAttemptError::Replay) + ), + "no new mutation admission" + ); + } else { + assert_eq!(result.source, before, "unresolved source remains unchanged"); + } + let report = result.report(); + let report_bytes = serde_json::to_vec(&report).expect("public report"); + let text = std::str::from_utf8(&report_bytes).expect("report UTF-8"); + for private in [ + token.as_str(), + "Approved", + "synthetic-recovery-content-canary", + ] { + assert!(!text.contains(private), "private data in report"); + } + assert!(!text.contains(&hex::encode(before.action_commitment()))); + outcomes.push(json!({"case": name, "disposition": result.disposition, "report": report})); + } + json!({ + "schema": "auths.recovery-refinement-fixture/1", + "scope": "native signed effects and real file journal; synthetic entry validation/provider bodies and controlled deployment clock; no installed transport or PostgreSQL claim", + "cases": outcomes, + "freshness": {"maximum_age_seconds": 30, "age_31_refused": true, "future_receipt_refused": true, "age_30_recorded": true}, + "history": {"expired_writer_preserved": true, "late_replay_idempotent": true, "receipt_time_unchanged": true, "charges_retained": true, "no_mutation_readmission": true}, + "recipe_substitution_refused": true, + "concurrent_refinement": "one recorded, one already-recorded, same immutable facts", + "public_report_excludes_private_content_and_commitments": true, + }) +} + fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { ConnectionRecord::new( ProviderKind::parse("airtable").expect("provider"), diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 295a2068a..a44eaa5ad 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1201,59 +1201,6 @@ impl GatewayEngine { checks } - /// Performs the operator's read-only re-observation of one stored - /// attempt: one read-back from the stored plan under a fresh lease that - /// passes every credential check, when the recipe digest is unchanged - /// and the stored stage can be resolved by a read-back. It records only - /// positive evidence and never writes to the provider. The answer is the - /// recorded result, or the stored attempt's result when nothing was - /// recorded. - /// - /// # Errors - /// Returns `gateway.reobserve.not-observable` when the attempt is absent - /// or cannot be re-observed, and the entry refusal when the connection - /// cannot be leased. - pub async fn reobserve(&self, operation_id: &str) -> Result { - let not_observable = "gateway.reobserve.not-observable"; - let operation = - crate::LogicalOperationId::parse(operation_id).map_err(|_| not_observable)?; - let namespace = self.recipe.namespace(); - let attempt = match self - .attempts - .resume_observable_operation(namespace, &operation, *self.recipe.digest()) - .await - { - Ok(Some(attempt)) => attempt, - Ok(None) | Err(_) => return Err(not_observable), - }; - let io = EngineIo { - engine: self, - pending: std::sync::Mutex::new(None), - started: Instant::now(), - prepared: OnceLock::new(), - #[cfg(unix)] - commissioning: None, - #[cfg(unix)] - commissioned_action: OnceLock::new(), - #[cfg(unix)] - commissioning_refusal: OnceLock::new(), - }; - io.prepare().await?; - let context = SubmitContext { - recipe: &self.recipe, - attempts: &self.attempts, - context: &self.trusted_context, - observer: self.observer.as_ref(), - }; - if let Some(result) = submit::reobserve(&context, &io, attempt).await { - return Ok(result); - } - match self.attempts.read(namespace, &operation).await { - Ok(Some(snapshot)) => Ok(stored_result(&snapshot)), - Ok(None) | Err(_) => Err(not_observable), - } - } - /// Deletes at most [`SLOT_SWEEP_LIMIT`] count and sum slots whose expiry, /// one full window after their window ends, is at or before the gateway /// clock, and returns how many were deleted. Claims are never swept. @@ -1381,6 +1328,15 @@ impl GatewayEngine { .approve(approval, self.effect_policy.approver(), now) .map_err(|_| not_entered("gateway.effect.approval"))?, ); + self.acquire_recovery_approved(approved, now, started).await + } + + async fn acquire_recovery_approved( + &self, + approved: Arc, + now: u64, + started: Instant, + ) -> Result { let reads = self .recipe .credential_reads() @@ -1411,6 +1367,78 @@ impl GatewayEngine { } } + /// Acquires and records independently approved recovery evidence. The read + /// operation comes from the native compiled effect, never an extra transport + /// parameter. A completed response remains distinct from source refinement. + /// + /// # Errors + /// Returns a native refusal or indeterminate state. No failure authorizes + /// retry of a granted acquisition or the original mutation. + pub async fn recover( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self + .compile_recovery_effect(source_operation, proof, action) + .await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + let operation = approved.effect().binding().journal_identity().1.to_owned(); + self.acquire_recovery_approved(approved, now, started) + .await?; + self.refine_recovery(source_operation, &operation) + .await + .map_err(|code| GatewaySubmitResult::Indeterminate { + code: code.to_owned(), + }) + } + + /// Refines a retained mutation from one separately authorized, recorded + /// recovery acquisition. This performs journal I/O only; it never leases a + /// credential, sends a request or refreshes the read's receipt time. The + /// writer's expired or revoked authority does not erase historical facts. + /// + /// # Errors + /// Refuses an unrelated source/read pair, corrupt or unavailable journal, + /// or an unavailable deployment clock. Stale or inconclusive evidence is + /// returned as unchanged history with an explicit disposition. + pub async fn refine_recovery( + &self, + source_operation: &str, + read_operation: &str, + ) -> Result { + let source = crate::LogicalOperationId::parse(source_operation) + .map_err(|_| "gateway.recovery.binding")?; + let read = crate::LogicalOperationId::parse(read_operation) + .map_err(|_| "gateway.recovery.binding")?; + let snapshot = self + .attempts + .refine_recovery( + self.recipe.namespace(), + &source, + &read, + *self.recipe.digest(), + Arc::clone(&self.qualification), + ) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => "gateway.recovery.binding", + _ => "gateway.recovery.unavailable", + })?; + Ok(snapshot) + } + async fn recovery_projection( &self, approved: &ApprovedEffect, @@ -1487,15 +1515,12 @@ impl GatewayEngine { &self, source_operation: &str, ) -> Result { - let unavailable = || not_entered("gateway.reobserve.not-observable"); + let unavailable = || not_entered("gateway.recovery.not-observable"); let operation = crate::LogicalOperationId::parse(source_operation).map_err(|_| unavailable())?; self.attempts - .resume_observable_operation(self.recipe.namespace(), &operation, *self.recipe.digest()) + .retained_recovery_target(self.recipe.namespace(), &operation, *self.recipe.digest()) .await - .map_err(|_| unavailable())? - .ok_or_else(unavailable)? - .recovery_target() .map_err(|_| unavailable()) } diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 6ae25ee27..144359136 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -143,8 +143,9 @@ pub use store::{ GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, GatewayInsert, GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, - GatewayRecordEntry, GatewayRecordKind, GatewayRelativeBasis, ObservableGatewayAttempt, - PostgresGatewayAttemptStore, PrivateDirectoryError, ReservedAcquisition, + GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, + ObservableGatewayAttempt, PostgresGatewayAttemptStore, PrivateDirectoryError, + RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, check_private_directory, check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 21bc4419a..48fdda138 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -18,7 +18,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/7"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/8"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 3450f991a..18546693d 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,8 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.recovery.binding effect recovery new 74 -", + "gateway.recovery.unavailable effect recovery new 74 -", "gateway.acquisition.binding effect compile new 74 -", "gateway.acquisition.exhausted effect admission new 74 -", "gateway.acquisition.ancillary-required effect before-claim new 74 -", @@ -86,7 +88,9 @@ const ROWS: &[&str] = &[ "gateway.admin.credential-probe admin admin new 3 -", "gateway.admin.generation-conflict admin admin new 5 -", "gateway.admin.peer-refused admin admin existing - -", - "gateway.admin.reobserved admin admin new 5 -", + "gateway.admin.recovered admin admin new 74 -", + "gateway.admin.recovery-refused admin admin new 74 -", + "gateway.admin.recovery-recorded admin admin new 74 -", "gateway.admin.status admin admin new 5 -", "gateway.install.connection-exists install install new 5 -", "gateway.install.credential-account install install new 3 -", @@ -97,7 +101,7 @@ const ROWS: &[&str] = &[ "gateway.install.join-record-missing install install new 5 -", "gateway.install.operator-attestation-invalid install install new 5 -", "gateway.install.operator-attestation-required install install new 5 -", - "gateway.reobserve.not-observable admin admin new 5 -", + "gateway.recovery.not-observable effect compile new 74 -", "gateway.serve.accept-failed serve serve existing - -", "gateway.serve.descriptor-limit serve serve new 5 -", "audit.bound-exceeded audit audit new 4 B:audit-count-capacity-three-and-one", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index e250ecc94..1b7b19eb8 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/7"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/8"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 5012611d2..adc9f82c3 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/7", + "store_schema": "auths.gateway-attempt/8", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 47f9d138f..a7e319427 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -22,6 +22,7 @@ pub use auths_gateway_kernel::{construct, recovery}; mod effect_review; mod lower; +mod response; mod review; #[cfg(any(test, feature = "testkit-harness"))] pub(crate) use effect_review::synthetic_review; @@ -1307,7 +1308,7 @@ impl ClosedObservationRequest { if response.len() > self.maximum_response_bytes { return None; } - let decoded: Value = serde_json::from_slice(response).ok()?; + let decoded = response::parse(response)?; let value = decoded.pointer(&self.json_pointer)?.clone(); let echo = self .echo_pointer @@ -1325,7 +1326,7 @@ impl ClosedObservationRequest { if response.len() > self.maximum_response_bytes { return None; } - let decoded: Value = serde_json::from_slice(response).ok()?; + let decoded = response::parse(response)?; let matched = decoded.pointer(&self.json_pointer)? == &self.expected; let (Some(pointer), Some(token)) = (self.echo_pointer.as_deref(), token) else { return Some(ReadBack::Value { matched }); diff --git a/product/runtime/auths-gateway/src/recipe/response.rs b/product/runtime/auths-gateway/src/recipe/response.rs new file mode 100644 index 000000000..c18c65be3 --- /dev/null +++ b/product/runtime/auths-gateway/src/recipe/response.rs @@ -0,0 +1,86 @@ +//! Bounded provider JSON with no duplicate object members. A last-key-wins +//! decoder would let ambiguous bytes become a definitive observation. + +use serde::de::{Error as _, MapAccess, SeqAccess, Visitor}; +use serde::{Deserialize, Deserializer}; +use serde_json::{Map, Number, Value}; +use std::fmt; + +struct Unique(Value); + +impl<'de> Deserialize<'de> for Unique { + fn deserialize>(deserializer: D) -> Result { + deserializer.deserialize_any(UniqueVisitor).map(Self) + } +} + +struct UniqueVisitor; + +impl<'de> Visitor<'de> for UniqueVisitor { + type Value = Value; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("unambiguous provider JSON") + } + + fn visit_unit(self) -> Result { + Ok(Value::Null) + } + + fn visit_bool(self, value: bool) -> Result { + Ok(Value::Bool(value)) + } + + fn visit_i64(self, value: i64) -> Result { + Ok(Value::Number(Number::from(value))) + } + + fn visit_u64(self, value: u64) -> Result { + Ok(Value::Number(Number::from(value))) + } + + fn visit_f64(self, value: f64) -> Result { + Number::from_f64(value) + .map(Value::Number) + .ok_or_else(|| E::custom("non-finite provider number")) + } + + fn visit_str(self, value: &str) -> Result { + Ok(Value::String(value.to_owned())) + } + + fn visit_string(self, value: String) -> Result { + Ok(Value::String(value)) + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut values = Vec::new(); + while let Some(Unique(value)) = seq.next_element()? { + values.push(value); + } + Ok(Value::Array(values)) + } + + fn visit_map>(self, mut map: A) -> Result { + let mut values = Map::new(); + while let Some(key) = map.next_key::()? { + if values.contains_key(&key) { + return Err(A::Error::custom("duplicate provider member")); + } + let Unique(value) = map.next_value()?; + values.insert(key, value); + } + Ok(Value::Object(values)) + } +} + +pub(super) fn parse(bytes: &[u8]) -> Option { + if bytes.len() > 65_536 { + return None; + } + // serde_json's default recursion bound remains enabled, including while + // deserializing nested Unique values. Trailing data is rejected as well. + serde_json::from_slice::(bytes) + .ok() + .map(|value| value.0) +} diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 3450f32e5..2f39ecfe0 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1416,7 +1416,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/7"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/8"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1545,7 +1545,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/7", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/8", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 1b487668f..bc3d53798 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "74f8b9cf036f5797b8f5fcd513617f111b9f98717c1a9f787c81feff1c2e3f79"; + "69a0a36b8289af3d98feb9d00831268ade92328d993ffe3adb5452794d99f914"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 53741d08c..d99689725 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,12 +2,12 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/7`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/8`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none //! insert-once, compare-and-swap, and sweep mechanism over opaque bounded -//! bytes of six closed kinds: [`FileGatewayAttemptStore`] for one host, and +//! bytes of seven closed kinds: [`FileGatewayAttemptStore`] for one host, and //! the multi-host `PostgresLifecycleStore`, whose production qualification is //! still open. @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/7"; +const SCHEMA: &str = "auths.gateway-attempt/8"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -282,9 +282,24 @@ pub struct GatewayAttemptSnapshot { observation_fact: Option, provider_evidence: Option, pre_entry: Option, + recovery_evidence: Option, } impl GatewayAttemptSnapshot { + /// Whether this history was refined by an independently authorized read. + #[must_use] + pub const fn has_recovery_evidence(&self) -> bool { + self.recovery_evidence.is_some() + } + + /// Returns the read's original receipt time, without refreshing it on replay. + #[must_use] + pub fn recovery_received_at(&self) -> Option { + self.recovery_evidence + .as_ref() + .map(|link| link.received_at()) + } + /// Returns the durable journal revision. #[must_use] pub const fn revision(&self) -> u64 { @@ -689,7 +704,8 @@ enum ProtocolState { mod acquisition; pub(crate) use acquisition::AcquisitionEntryPermit; pub use acquisition::{ - AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, ReservedAcquisition, + AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, GatewayRecoveryReport, + RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, }; trait JournalProtocol: Clone + Sized { @@ -741,6 +757,8 @@ struct MutationState { provider_evidence: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pre_entry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + recovery_evidence: Option, } /// Private immutable evidence of the unique acknowledged grant. It does not @@ -802,13 +820,10 @@ impl Record { } fn recovery_target(&self) -> Result { - let binding = self.validate_header()?; - let link = self.link(); let stage_resolvable = match self.state.stage { - GatewayAttemptStage::EntryGranted | GatewayAttemptStage::Unknown => { - transition::resolves_unknown(link) - } - GatewayAttemptStage::ResponseRecorded => transition::has_link(link), + GatewayAttemptStage::EntryGranted + | GatewayAttemptStage::Unknown + | GatewayAttemptStage::ResponseRecorded => true, GatewayAttemptStage::Reserved | GatewayAttemptStage::NotEntered | GatewayAttemptStage::Observed @@ -817,6 +832,15 @@ impl Record { if !stage_resolvable { return Err(GatewayAttemptError::InvalidTransition); } + self.recovery_target_data() + } + + /// The immutable observation contract also remains available after final + /// evidence, so history can be checked without acquiring new authority. + fn recovery_target_data( + &self, + ) -> Result { + let binding = self.validate_header()?; let request = self .observation_request() .ok_or(GatewayAttemptError::InvalidTransition)?; @@ -1070,6 +1094,9 @@ impl Record { { return Err(GatewayAttemptError::Corrupt); } + if let Some(link) = &self.state.recovery_evidence { + link.validate(self)?; + } let provider_evidence = match &self.state.provider_evidence { Some(wire) => { let locator = self @@ -1108,6 +1135,7 @@ impl Record { observation_fact: self.state.observation_fact, provider_evidence, pre_entry, + recovery_evidence: self.state.recovery_evidence.clone(), }) } } @@ -1355,7 +1383,7 @@ fn fence_keys( Ok(keys) } -/// Durable storage of opaque gateway records of six closed kinds. +/// Durable storage of opaque gateway records of seven closed kinds. /// Implementations never interpret the bytes. /// /// Every implementation must pass the same conformance suite: one winner per @@ -2104,6 +2132,7 @@ fn claim_record( observation_match: None, observation_fact: None, provider_evidence: None, + recovery_evidence: None, pre_entry: None, }, ); @@ -2314,6 +2343,29 @@ impl GatewayAttempts { record.snapshot(true).map(Some) } + /// Retained source contract, including terminal history. Compiling it does + /// not permit a new read: acquisition entry separately requires an eligible + /// source under the writer fence. This enables exact read replay after a + /// source was refined without recreating a provider permit. + pub(crate) async fn retained_recovery_target( + &self, + namespace: &OperatorNamespace, + operation_id: &LogicalOperationId, + recipe_digest: [u8; 32], + ) -> Result { + let (_, record) = self + .load(namespace, operation_id) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + record.snapshot(true)?; + if record.recipe_digest != hex::encode(recipe_digest) + || !transition::requires_entry(record.state.stage.kernel()) + { + return Err(GatewayAttemptError::BindingConflict); + } + record.recovery_target_data() + } + /// Reopens a stored attempt for the operator's read-only /// re-observation. The recipe must match and the stored stage must permit /// evidence from its stored plan. Application replay cannot call this path. diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index e00e88899..a2bf0a8ca 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -5,10 +5,16 @@ use super::*; use crate::effect::{RecoveryCapacity, RecoveryPlan}; +mod recovery; +pub(super) use recovery::RecoveryEvidenceLink; +pub use recovery::{ + GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, +}; + const ALLOCATION_SCHEMA: &str = "auths.effect-allocation/1"; /// Public facts about a bounded acquisition, with no content or private digest. -#[derive(Clone, Debug, Eq, PartialEq)] +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] pub struct AcquisitionSnapshot { /// Durable journal revision. pub revision: u64, @@ -27,7 +33,8 @@ pub struct AcquisitionSnapshot { } /// Acquisition has no mutation-observed or disclosure-acknowledged state. -#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] pub enum AcquisitionStage { /// Capacity held; no provider permit. Reserved, diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs new file mode 100644 index 000000000..b1d6d08b3 --- /dev/null +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -0,0 +1,379 @@ +//! Source refinement from retained, separately authorized acquisition history. +//! The same adapter fence orders the source, read and permanent allocation. +//! This path has no credential/transport capability and never refreshes evidence. + +use super::*; +use crate::effect::MAX_RECOVERY_EVIDENCE_AGE_SECONDS; +use crate::recipe::ReadBack; + +/// Why a recorded recovery acquisition did or did not refine its source. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub enum RecoveryDisposition { + /// Fresh, supported evidence was durably added to the original mutation. + Recorded, + /// This exact evidence was already recorded; no timestamp or charge changed. + AlreadyRecorded, + /// The source already has terminal facts from another observation. + SourceFinal, + /// The acquisition has no complete response. Its charges remain retained. + AcquisitionIncomplete, + /// Status, version headers, JSON or projection did not provide usable evidence. + ResponseUnusable, + /// Evidence is too old, or the clock is earlier than its receipt time. + EvidenceStale, + /// A comparison cannot establish the source's effect or causal link. + Inconclusive, +} + +/// Protected journal history from a recovery refinement. Provider evidence in +/// `source` remains private; this value is deliberately not serializable. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct RecoverySnapshot { + /// Original mutation facts and attribution; never replaced by reader identity. + pub source: GatewayAttemptSnapshot, + /// Independently charged read facts without its private response bytes. + pub acquisition: AcquisitionSnapshot, + /// The bounded evidence decision, without implying a new execution permit. + pub disposition: RecoveryDisposition, +} + +/// Public recovery projection containing no response bytes, locators, echo, +/// private commitments, proof, approval or credential material. +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +pub struct GatewayRecoveryReport { + /// Versioned native projection schema. + pub schema: &'static str, + /// Distinct facts about the original mutation. + pub source: RecoverySourceFacts, + /// Independently charged acquisition facts. + pub acquisition: AcquisitionSnapshot, + /// Evidence decision; response alone never implies mutation success. + pub disposition: RecoveryDisposition, +} + +/// Safe source facts without the protected evidence used to establish them. +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +pub struct RecoverySourceFacts { + /// Conservative source stage. + pub stage: GatewayAttemptStage, + /// Durable source revision. + pub revision: u64, + /// HTTP status of the original write, when retained. + pub response_status: Option, + /// State equality is not causal attribution. + pub observation_match: Option, + /// Whether the declared provider echo linked the observed state. + pub provider_linked: bool, + /// Receipt time of the independent evidence, never refreshed by replay. + pub recovery_received_at: Option, +} + +impl RecoverySnapshot { + /// Produces the native bounded public report. It exposes no private digest + /// or provider response, even when the source has linked evidence. + #[must_use] + pub fn report(&self) -> GatewayRecoveryReport { + GatewayRecoveryReport { + schema: "auths.gateway-recovery/1", + source: RecoverySourceFacts { + stage: self.source.stage(), + revision: self.source.revision(), + response_status: self.source.response_status(), + observation_match: self.source.observation_match(), + provider_linked: self.source.provider_evidence().is_some(), + recovery_received_at: self.source.recovery_received_at(), + }, + acquisition: self.acquisition.clone(), + disposition: self.disposition, + } + } +} + +/// Immutable provenance stored beside the source's terminal observation facts. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(in crate::store) struct RecoveryEvidenceLink { + acquisition_effect: String, + acquisition_operation: String, + acquisition_revision: u64, + response_digest: String, + received_at: u64, + recorded_at: u64, +} + +impl std::fmt::Debug for RecoveryEvidenceLink { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("RecoveryEvidenceLink { private: [redacted] }") + } +} + +impl RecoveryEvidenceLink { + pub(in crate::store) const fn received_at(&self) -> u64 { + self.received_at + } + + pub(in crate::store) fn validate(&self, source: &Record) -> Result<(), GatewayAttemptError> { + let operation = LogicalOperationId::parse(&self.acquisition_operation) + .map_err(|_| GatewayAttemptError::Corrupt)?; + digest_bytes(&self.acquisition_effect)?; + digest_bytes(&self.response_digest)?; + if operation.as_str() == source.operation_id + || !(3..=MAX_JSON_INTEGER).contains(&self.acquisition_revision) + || self.received_at < source.evaluated_at + || self.recorded_at > MAX_JSON_INTEGER + || !fresh(self.received_at, self.recorded_at) + || !matches!( + source.state.stage, + GatewayAttemptStage::Observed | GatewayAttemptStage::ObservedByProvider + ) + || source + .state + .provider_evidence + .as_ref() + .is_some_and(|evidence| { + evidence.observed_at != self.received_at + || evidence.evidence_digest != self.response_digest + }) + { + return Err(GatewayAttemptError::Corrupt); + } + Ok(()) + } +} + +fn fresh(received_at: u64, now: u64) -> bool { + now.checked_sub(received_at) + .is_some_and(|age| age <= MAX_RECOVERY_EVIDENCE_AGE_SECONDS) +} + +impl Record { + fn response_link(&self, now: u64) -> Result, GatewayAttemptError> { + let AcquisitionPhase::ResponseRecorded { response } = &self.state.phase else { + return Ok(None); + }; + let capacity = self + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let body = response.body(&capacity)?; + Ok(Some(RecoveryEvidenceLink { + acquisition_effect: hex::encode(self.validate_header()?.id().as_bytes()), + acquisition_operation: self.operation_id.clone(), + acquisition_revision: self.revision, + response_digest: hex::encode(Sha256::digest(&body)), + received_at: response.received_at, + recorded_at: now, + })) + } +} + +/// Returns a proposed mutation transition, or truthful unchanged history. The +/// request/echo/projection comes only from the retained source contract. +fn refinement( + source: &Record, + read: &Record, + now: u64, +) -> Result, GatewayAttemptError> { + let Some(link) = read.response_link(now)? else { + return Ok(Err(RecoveryDisposition::AcquisitionIncomplete)); + }; + if let Some(existing) = &source.state.recovery_evidence { + let mut expected = link; + expected.recorded_at = existing.recorded_at; + return Ok(Err(if existing == &expected { + RecoveryDisposition::AlreadyRecorded + } else { + RecoveryDisposition::SourceFinal + })); + } + if matches!( + source.state.stage, + GatewayAttemptStage::Observed + | GatewayAttemptStage::ObservedByProvider + | GatewayAttemptStage::NotEntered + ) { + return Ok(Err(RecoveryDisposition::SourceFinal)); + } + if !fresh(link.received_at, now) { + return Ok(Err(RecoveryDisposition::EvidenceStale)); + } + let AcquisitionPhase::ResponseRecorded { response } = &read.state.phase else { + return Err(GatewayAttemptError::Corrupt); + }; + if !(200..=299).contains(&response.status) || !response.version_ok { + return Ok(Err(RecoveryDisposition::ResponseUnusable)); + } + let capacity = read + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let body = response.body(&capacity)?; + let target = source.recovery_target_data()?; + let request = target.closed_request(); + let token = source.echo_token()?; + let Some(reading) = request.read_back(Some(&token), &body) else { + return Ok(Err(RecoveryDisposition::ResponseUnusable)); + }; + let mut next = source.clone(); + match reading { + ReadBack::EchoMatched => { + // A response-derived locator cannot resolve an unknown send. The + // shared reducer checks this link condition again before commit. + if source.state.response_status.is_none() + && !transition::resolves_unknown(source.link()) + { + return Ok(Err(RecoveryDisposition::Inconclusive)); + } + next.state.stage = GatewayAttemptStage::ObservedByProvider; + next.state.provider_evidence = Some(EvidenceWire { + channel: GatewayEvidenceChannel::ReadBack, + locator: request.url().to_owned(), + echo: token, + evidence_digest: link.response_digest.clone(), + evidence_b64: response.body_b64.clone(), + observed_at: response.received_at, + }); + } + ReadBack::Value { matched } => { + if source.state.response_status.is_none() { + return Ok(Err(RecoveryDisposition::Inconclusive)); + } + next.state.stage = GatewayAttemptStage::Observed; + next.state.observation_match = Some(matched); + } + ReadBack::EchoMismatch => { + if source.state.response_status.is_none() { + return Ok(Err(RecoveryDisposition::Inconclusive)); + } + next.state.stage = GatewayAttemptStage::Observed; + next.state.observation_match = Some(false); + next.state.observation_fact = Some(GatewayObservationFact::EchoMismatch); + } + } + next.state.recovery_evidence = Some(link); + next.revision = next + .revision + .checked_add(1) + .ok_or(GatewayAttemptError::InvalidTransition)?; + if !valid_transition(source, &next)? { + return Err(GatewayAttemptError::InvalidTransition); + } + Ok(Ok(next)) +} + +impl GatewayAttempts { + /// Records supported evidence from an already authorized read. It never + /// re-verifies the expired writer or performs provider/custody I/O. The + /// deployment clock is sampled inside the source/read/allocation fence. + pub(crate) async fn refine_recovery( + &self, + namespace: &OperatorNamespace, + source_operation: &LogicalOperationId, + read_operation: &LogicalOperationId, + recipe_digest: [u8; 32], + clock: Arc, + ) -> Result { + if source_operation == read_operation { + return Err(GatewayAttemptError::BindingConflict); + } + let key = self.key(namespace, source_operation)?; + let read_key = self.key(namespace, read_operation)?; + let policy = self.policy.clone(); + let store = Arc::clone(&self.store); + blocking(move || { + let bytes = store + .load(GatewayRecordKind::Attempt, &read_key)? + .ok_or(GatewayAttemptError::Unavailable)?; + let read: Record = decode_as(&bytes)?; + let binding = read.validate_header()?; + let capacity = read + .state + .plan + .validate(&binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !policy.contains(&binding) || *binding.journal_identity().3 != recipe_digest { + return Err(GatewayAttemptError::BindingConflict); + } + let mut keys = vec![ + (GatewayRecordKind::Attempt, key), + (GatewayRecordKind::Attempt, read_key), + ]; + if let Some(slot) = read.state.allocation { + keys.push(( + GatewayRecordKind::EffectAllocation, + allocation_key(&capacity, slot), + )); + } + let mut result = None; + let mut unchanged = false; + let persisted = store.fenced_replace(&keys, &mut |snapshots| { + if snapshots.len() != keys.len() + || snapshots[1].as_deref() != Some(bytes.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + let source = decode( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Unavailable)?, + )?; + if source.binding_canonical != read.state.plan.source_binding + || !policy.contains(&source.validate_header()?) + || source + .recovery_target_data()? + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)? + != read.state.plan + { + return Err(GatewayAttemptError::BindingConflict); + } + if let Some(slot) = read.state.allocation + && snapshots[2].as_deref() + != Some( + canonical(&Allocation::new(&read.state.plan, read_key, slot)?)? + .as_slice(), + ) + { + return Err(GatewayAttemptError::Corrupt); + } + let now = clock + .effect_time() + .filter(|now| *now <= MAX_JSON_INTEGER) + .ok_or(GatewayAttemptError::Unavailable)?; + let (source, disposition, next) = match refinement(&source, &read, now)? { + Ok(next) => ( + next.snapshot(true)?, + RecoveryDisposition::Recorded, + Some(encode(&next)?), + ), + Err(disposition) => (source.snapshot(true)?, disposition, None), + }; + result = Some(RecoverySnapshot { + source, + acquisition: read.snapshot()?, + disposition, + }); + match next { + Some(bytes) => Ok(bytes), + None => { + unchanged = true; + // Abort the write transaction: an inspection/replay must + // not rewrite state or acquire a new journal revision. + Err(GatewayAttemptError::Replay) + } + } + }); + match persisted { + Ok(()) => result.ok_or(GatewayAttemptError::Unavailable), + Err(GatewayAttemptError::Replay) if unchanged => { + result.ok_or(GatewayAttemptError::Unavailable) + } + Err(error) => Err(error), + } + }) + .await + } +} diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 8d201259c..0b8d30dce 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -23,10 +23,12 @@ use crate::{ ObservableGatewayAttempt, RequestHeader, }; use auths_gateway_kernel::order::{ - AccountResult, CeilingRead, ClaimResult, DeniedResult, Mode, Phase, PreEntryResult, Refusal, - ResponseRecord, Stop, SubmitAction, SubmitDecision, SubmitEvent, SubmitPlan, SubmitState, - Verification, WriteResult, next_step, start, + AccountResult, CeilingRead, ClaimResult, DeniedResult, Mode, PreEntryResult, Refusal, + ResponseRecord, Stop, SubmitAction, SubmitDecision, SubmitEvent, SubmitPlan, Verification, + WriteResult, next_step, start, }; +#[cfg(test)] +use auths_gateway_kernel::order::{Phase, SubmitState}; use auths_model::{ResourceId, TrustedContext}; use serde_json::Value; use sha2::{Digest as _, Sha256}; @@ -316,6 +318,7 @@ pub(crate) async fn run(cx: &SubmitContext<'_>, io: &I) -> GatewayS /// every credential check, and one read-back from the stored plan. The /// caller has already prepared the entry. Returns the recorded result, or /// `None` when the read-back recorded nothing. +#[cfg(test)] pub(crate) async fn reobserve( cx: &SubmitContext<'_>, io: &I, diff --git a/product/runtime/auths-gateway/tests/admin_capacity.rs b/product/runtime/auths-gateway/tests/admin_capacity.rs index 8de56af3e..cd1040bb6 100644 --- a/product/runtime/auths-gateway/tests/admin_capacity.rs +++ b/product/runtime/auths-gateway/tests/admin_capacity.rs @@ -288,7 +288,7 @@ fn every_admin_command_answers_while_idle_application_connections_hold_the_capac let answered = |output: &Output, code: &str| { let response = printed(output); - assert_eq!(response["schema"], "auths.gateway-admin-response/1"); + assert_eq!(response["schema"], "auths.gateway-admin-response/2"); assert_eq!(response["code"], code, "{response}"); response }; @@ -306,9 +306,17 @@ fn every_admin_command_answers_while_idle_application_connections_hold_the_capac &gateway.rotate(b"synthetic-rotated\n"), "gateway.admin.rotated", ); - let unknown = gateway.admin("reobserve", &["--operation-id", "op-never-claimed"]); + let unknown = gateway.admin( + "recovery-record", + &[ + "--source-operation", + "op-never-claimed", + "--acquisition-operation", + "read-never-claimed", + ], + ); assert!(!unknown.status.success()); - answered(&unknown, "gateway.reobserve.not-observable"); + answered(&unknown, "gateway.recovery.unavailable"); let revoked = gateway.admin("revoke", &[]); assert!( revoked.status.success(), From 119d1f78206ec39621f47366727261427de7ec5e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 06:58:23 +0000 Subject: [PATCH 027/136] feat(gateway)!: require independent acquisition after mutation responses --- .../gateway/attempt-scenarios-v3.json | 66 ++--- .../fixtures/gateway/replay-projection.json | 12 + bindings/python/tests/test_gateway_client.py | 2 + .../test/unit/gateway-client.test.js | 2 +- ...017-bound-effect-and-recovery-ownership.md | 8 +- docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md | 4 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 3 + docs/plans/0074-implementation-status.md | 30 +++ .../0009-bound-effect-and-recovery.md | 17 ++ .../runtime/auths-gateway-kernel/src/order.rs | 247 +++++------------- .../auths-gateway/semantic-closure.json | 2 +- .../src/pending_vectors/attempts.rs | 24 +- .../auths-gateway/src/scenario_tests.rs | 205 ++++++++++++--- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 16 +- product/runtime/auths-gateway/src/submit.rs | 143 +--------- 16 files changed, 353 insertions(+), 430 deletions(-) diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 4ed01c985..7b0630c73 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -192,13 +192,12 @@ "reserved", "reserved", "entry-granted", - "response-recorded", - "observed-by-provider" + "response-recorded" ], "code": null, - "leases": 2, + "leases": 1, "credential_reads": 0, - "action_reads": 2, + "action_reads": 1, "provider_entries": 1, "pre_entry_observations": 1 }, @@ -277,13 +276,12 @@ "reserved", "reserved", "entry-granted", - "response-recorded", - "observed-by-provider" + "response-recorded" ], "code": null, - "leases": 2, - "credential_reads": 6, - "action_reads": 2, + "leases": 1, + "credential_reads": 3, + "action_reads": 1, "provider_entries": 1, "basis": 1001 }, @@ -605,13 +603,12 @@ "reserved", "reserved", "entry-granted", - "response-recorded", - "observed-by-provider" + "response-recorded" ], "code": null, - "leases": 2, - "credential_reads": 6, - "action_reads": 2, + "leases": 1, + "credential_reads": 3, + "action_reads": 1, "provider_entries": 1, "requests": [ { @@ -653,38 +650,6 @@ "stripe_account": "acct_TESTACCOUNT01", "idempotency_key": true, "credential": true - }, - { - "method": "GET", - "path": "/v1/account", - "stripe_version": "2025-03-31.basil", - "stripe_account": null, - "idempotency_key": false, - "credential": true - }, - { - "method": "GET", - "path": "/v1/customers", - "stripe_version": "2025-03-31.basil", - "stripe_account": null, - "idempotency_key": false, - "credential": true - }, - { - "method": "GET", - "path": "/v1/payouts", - "stripe_version": "2025-03-31.basil", - "stripe_account": null, - "idempotency_key": false, - "credential": true - }, - { - "method": "GET", - "path": "/v1/refunds/re_TEST0000000001", - "stripe_version": "2025-03-31.basil", - "stripe_account": "acct_TESTACCOUNT01", - "idempotency_key": false, - "credential": true } ] }, @@ -711,13 +676,12 @@ "reserved", "reserved", "entry-granted", - "response-recorded", - "observed-by-provider" + "response-recorded" ], "code": null, - "leases": 2, - "credential_reads": 6, - "action_reads": 2, + "leases": 1, + "credential_reads": 3, + "action_reads": 1, "provider_entries": 1 }, { diff --git a/bindings/fixtures/gateway/replay-projection.json b/bindings/fixtures/gateway/replay-projection.json index d6595a7de..a26d8e823 100644 --- a/bindings/fixtures/gateway/replay-projection.json +++ b/bindings/fixtures/gateway/replay-projection.json @@ -10,6 +10,18 @@ "additional_writes": 0, "journal_unchanged": true }, + "response_without_observation": { + "result": { + "outcome": "response-recorded", + "status": 200 + }, + "credential_leases": 1, + "provider_writes": 1, + "provider_reads": 0, + "provider_evidence": false, + "replay_additional_leases": 0, + "replay_journal_unchanged": true + }, "unacknowledged_grants": [ { "ambiguous_ack": false, diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index 33d6e1673..a449d65a9 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -30,6 +30,7 @@ GatewaySignedObservation, GatewayUnknown, GatewayReserved, + GatewayResponseRecorded, GatewayIndeterminate, ) @@ -436,6 +437,7 @@ def test_native_replay_projection_corpus() -> None: ) assert corpus["schema"] == "auths.gateway-replay-projection-fixture/1" assert _parse_result(json.dumps(corpus["unknown_replay"]["result"]).encode()) == GatewayUnknown() + assert _parse_result(json.dumps(corpus["response_without_observation"]["result"]).encode()) == GatewayResponseRecorded(200) expected = [GatewayReserved(1), GatewayUnknown(), GatewayIndeterminate("gateway.attempt.state-unavailable")] assert len(corpus["unacknowledged_grants"]) == len(expected) diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index 869740253..dec3b324a 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -318,7 +318,7 @@ test("operator gate refusals remain not-entered with the native code", { skip: p test("gateway decodes the native replay and reservation corpus", { skip: process.platform === "win32" }, async () => { const corpus = JSON.parse(await readFile(new URL("../../../fixtures/gateway/replay-projection.json", import.meta.url), "utf8")); assert.equal(corpus.schema, "auths.gateway-replay-projection-fixture/1"); - for (const result of [corpus.unknown_replay.result, ...corpus.unacknowledged_grants.map((item) => item.result), ...corpus.reserved_decoding.valid]) { + for (const result of [corpus.unknown_replay.result, corpus.response_without_observation.result, ...corpus.unacknowledged_grants.map((item) => item.result), ...corpus.reserved_decoding.valid]) { assert.deepEqual(await replyOnce(JSON.stringify(result)), result); } for (const invalid of corpus.reserved_decoding.invalid) { diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 817211a39..c16f84dcd 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -403,7 +403,9 @@ uses `recover` with a separately signed native read and exact approval, or `recovery-record` with already retained read evidence and no external I/O. Application and operator input frames share a bounded native decoder. Redacted recovery report `/1` separates read facts, source facts and evidence disposition -without private content, locators or commitments. The old operator step driver -is test-only; automatic post-write and ancillary/application reads remain the -next production cutovers. The native corpus is file-journal mechanism evidence +without private content, locators or commitments. The old observation mechanics +remain only as an explicit store-conformance test oracle. The shipping submission +step machine has no read-back/resume mode: recording a response stops it, and +observation requires the independent recovery acquisition. Ancillary/application +reads remain the next production cutovers. The native corpus is file-journal mechanism evidence with synthetic entry/response/clock inputs, not installed transport qualification. diff --git a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md index 07b70b499..697615a5e 100644 --- a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md +++ b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md @@ -151,6 +151,10 @@ and rebuild authority/connection state under owner review; do not serve old operations as fresh. A newly created host without a floor cannot prove that a database is current; recover its floors before starting it. +A mutation submission stops after recording its response; it does not perform +an automatic provider observation. A `response-recorded` result is not a +confirmation of the intended provider state. + For a response-recorded or unknown operation, author a distinct bounded read using `effect-recovery-call`, authorize it through the native MCP flow, review it with `effect-review --recovery-of`, and sign its exact approval. Then use diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 528abdbbd..cce6bfab8 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -86,6 +86,9 @@ auths-gateway recovery-record --state-dir \ --source-operation --acquisition-operation ``` +Mutation submission records the response and stops without a provider read-back. +It cannot report newly observed provider state from the write response alone. + `recover` performs the independently authorized read and then attempts evidence refinement. `recovery-record` only uses an already retained acquisition response; it performs no credential or provider I/O. The original writer's expired proof diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 39144a475..19b70751f 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -500,6 +500,36 @@ closure regeneration passed after that correction (one artifact-generation test) UI/bindings, generated histories, final formal/release artifacts and hosted CI remain required. +## Submission observation cutover checkpoint + +- Removed automatic post-write observation from the shared submission order and + driver. A recorded response stops with `ResponseRecorded`; unknown transport + stays conservative. Removed the obsolete mode enum, resume/read-back phases + and actions, and test-only operator entry from the shipping driver. +- Direct `ObservableGatewayAttempt` observation-writing methods are now + crate-private and test-only. The shipping evidence refinement path is the + source/read/allocation recovery fence. Retained record/store conformance + mechanics request their observation explicitly from a test oracle and make no + AP074 read-authority claim. +- Updated authored scenario stages, credential/read/lease counts and exact + request lists, plus measured qualification replay expectations. The generated + replay corpus now measures a successful response with one lease, one write, + zero provider reads and no evidence; its replay performs no additional I/O + and preserves the complete snapshot. Python/TypeScript parity consumers also + decode this native response case. +- Required native replay, attempt-scenario and final semantic-closure artifact + construction passed (one exact generator each), on `9f717d39` plus this source. + The replay generator exercises the new response/no-read assertions; the + scenario generator constructs expected corpus data, not adapter conformance. + No broad local suite or hosted CI has been run. Existing installed/harness + journeys with automatic-observation expectations still require explicit + independent acquisition/approval cutover, so full-suite readiness is not + claimed. Generated/translated formal links remain pending. No acceptance + gate closes. +- Next: bound/account prerequisite and application reads, ordered admission, + replacement credentials/read-policy limits, disclosure/ACK, maintained + consumer/UI cutover and complete installed/fault/formal/CI evidence. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index c05c14a94..f22d25604 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -234,3 +234,20 @@ recording, source attribution/charge retention and report privacy. It also freez the closed replacement operator-frame grammar. These are native file-journal results with synthetic response, clock and entry validation; independent process, installed transport, PostgreSQL and final differential evidence are still needed. + + +## Submission and independent observation boundary + +Mutation submission now ends at a recorded response or conservative unknown +outcome. The shared order leaf contains no automatic read-back, observation +lease mode or operator resume entry. The driver cannot promote a response into +provider evidence. Historical observation-writing helpers are crate-private and +compiled only for tests; the shipping recovery fence owns evidence refinement. + +The retained record/store oracle requests observation explicitly and makes no +AP074 acquisition-authority claim. The native replay corpus separately measures +one response-producing write with one lease and zero provider reads, no provider +evidence, and a replay that adds no I/O or journal revision. The scenario corpus +removes the former second lease, repeated credential checks and post-write read. +Installed journeys, ancillary read admission and final translated/refinement +artifacts remain required before this boundary has complete acceptance evidence. diff --git a/product/runtime/auths-gateway-kernel/src/order.rs b/product/runtime/auths-gateway-kernel/src/order.rs index 38d77a0bb..747058ff0 100644 --- a/product/runtime/auths-gateway-kernel/src/order.rs +++ b/product/runtime/auths-gateway-kernel/src/order.rs @@ -10,16 +10,15 @@ //! 1. read the clock, verify native authority and exact effect approval, admit //! (with the account-scope binding when declared), and prepare the transport, //! revalidating the approved effect against that installation, storing nothing; -//! 2. claim the logical operation; a replay goes to one read-only -//! re-observation and never to a write; +//! 2. claim the logical operation; a replay returns retained state without I/O; //! 3. reload the connection record, lease the credential, check the prefix, //! the account read, and each denied read; //! 4. run the pre-entry re-read and the relative-ceiling read, when declared, //! and record what they read in one checkpoint; //! 5. reload the connection record again, refuse entry after the deadline or //! failed fresh authority/approval validation, and send the one write; -//! 6. record the response or `unknown`, then at most one read-back under a -//! fresh lease that passes the same credential checks. +//! 6. record the response or `unknown`, then stop. Provider observation requires +//! a separate approved acquisition and cannot be entered by this machine. //! //! Every refusal before the claim stores nothing; every refusal after it and //! before transport entry records `not-entered` with its code. An event the @@ -30,17 +29,6 @@ use crate::ratio::relative_ceiling_admits; -/// Why a lease is taken. -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub enum Mode { - /// The lease for the one write. - Entry, - /// The lease for the read-back after a recorded response. - ReadBack, - /// The lease for an explicit operator re-observation. - Reobserve, -} - /// The declarations and verified values the order depends on, fixed before /// the machine starts. #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -80,18 +68,16 @@ pub enum Phase { Prepare, /// Awaiting the claim. Claim, - /// Awaiting an explicit operator re-observation start. - Resume, /// Awaiting the connection reload before a lease. - Reload(Mode), + Reload, /// Awaiting the credential lease. - Lease(Mode), + Lease, /// Awaiting the prefix guard. - Prefix(Mode), + Prefix, /// Awaiting the account read. - Account(Mode), + Account, /// Awaiting the denied read at this index. - Denied(Mode, u8), + Denied(u8), /// Awaiting the pre-entry re-read. PreEntry, /// Awaiting the relative-ceiling read. @@ -112,8 +98,6 @@ pub enum Phase { RecordUnknown, /// Awaiting the store write of `not-entered`. RecordNotEntered, - /// Awaiting the read-back. - ReadBack(Mode), /// Stopped. Done, } @@ -218,10 +202,7 @@ pub enum ResponseRecord { /// The store write failed. Failed, /// The response was recorded. - Recorded { - /// Whether a read-back request exists for it. - observable: bool, - }, + Recorded, } /// The result of the action the previous decision named. @@ -241,8 +222,6 @@ pub enum SubmitEvent { Preparation(bool), /// The claim result. Claim(ClaimResult), - /// An explicit operator attempt can be re-observed. - Resume(bool), /// The connection record is unchanged. Reload(bool), /// The credential was leased. @@ -315,16 +294,12 @@ pub enum Stop { NotEntered, /// The stored record is `entry-granted` or `unknown`. Unknown, - /// The response is recorded and no read-back transition was. + /// The response is recorded; observation requires a separate acquisition. Response, - /// A read-back recorded its transition. - Observed, /// An identical replay returned only the matching journal state. Stored, /// A grant was not acknowledged; only a fresh journal read can report state. GrantUnavailable, - /// An explicit operator re-observation recorded nothing. - ReobservationUnrecorded, /// An event the phase does not expect. Halted, } @@ -345,15 +320,15 @@ pub enum SubmitAction { /// Claim the logical operation. Claim, /// Reload the connection record before a lease. - Reload(Mode), + Reload, /// Lease the credential. - Lease(Mode), + Lease, /// Check the leased secret's prefix. - CheckPrefix(Mode), + CheckPrefix, /// Run the account read. - ReadAccount(Mode), + ReadAccount, /// Run the denied read at this index. - DeniedRead(Mode, u8), + DeniedRead(u8), /// Run the pre-entry re-read. PreEntryRead, /// Run the relative-ceiling read. @@ -374,8 +349,6 @@ pub enum SubmitAction { RecordUnknown, /// Record `not-entered` with this refusal. RecordNotEntered(Refusal), - /// Perform one read-only observation and record what it shows. - ReadBack(Mode), /// Stop. Stop(Stop), } @@ -434,17 +407,6 @@ pub const fn not_entered(state: SubmitState, refusal: Refusal) -> SubmitDecision ) } -/// A failed lease-time step: an entry records `not-entered`; a read-back or -/// re-observation records nothing. -#[must_use] -pub const fn lease_failed(state: SubmitState, mode: Mode, refusal: Refusal) -> SubmitDecision { - match mode { - Mode::Entry => not_entered(state, refusal), - Mode::ReadBack => stop(state, Stop::Response), - Mode::Reobserve => stop(state, Stop::ReobservationUnrecorded), - } -} - /// After the relative ceiling, or after the pre-entry re-read when no /// ceiling is declared: the checkpoint when anything was read, else the /// reload before entry. @@ -477,39 +439,23 @@ pub const fn pre_entry_from(state: SubmitState) -> SubmitDecision { } } -/// After every credential check passed: the entry's reads, or the one -/// read-back of a read-back or re-observation lease. -#[must_use] -pub const fn after_credentials(state: SubmitState, mode: Mode) -> SubmitDecision { - match mode { - Mode::Entry => pre_entry_from(state), - Mode::ReadBack | Mode::Reobserve => { - go(state, Phase::ReadBack(mode), SubmitAction::ReadBack(mode)) - } - } -} - /// The denied read at `index` when one remains. #[must_use] -pub const fn denied_from(state: SubmitState, mode: Mode, index: u8) -> SubmitDecision { +pub const fn denied_from(state: SubmitState, index: u8) -> SubmitDecision { if index < state.plan.denied_reads { - go( - state, - Phase::Denied(mode, index), - SubmitAction::DeniedRead(mode, index), - ) + go(state, Phase::Denied(index), SubmitAction::DeniedRead(index)) } else { - after_credentials(state, mode) + pre_entry_from(state) } } /// After the prefix guard: the account read when declared. #[must_use] -pub const fn after_prefix(state: SubmitState, mode: Mode) -> SubmitDecision { +pub const fn after_prefix(state: SubmitState) -> SubmitDecision { if state.plan.account_read { - go(state, Phase::Account(mode), SubmitAction::ReadAccount(mode)) + go(state, Phase::Account, SubmitAction::ReadAccount) } else { - denied_from(state, mode, 0) + denied_from(state, 0) } } @@ -537,11 +483,7 @@ pub const fn pre_claim(state: SubmitState, passed: bool, next: SubmitDecision) - #[must_use] pub const fn after_claim(state: SubmitState, result: ClaimResult) -> SubmitDecision { match result { - ClaimResult::Reserved => go( - state, - Phase::Reload(Mode::Entry), - SubmitAction::Reload(Mode::Entry), - ), + ClaimResult::Reserved => go(state, Phase::Reload, SubmitAction::Reload), ClaimResult::Refused => stop(state, Stop::ClaimRefused), ClaimResult::Replay => stop(state, Stop::Stored), ClaimResult::Unavailable => stop(state, Stop::StoreUnavailable), @@ -550,36 +492,27 @@ pub const fn after_claim(state: SubmitState, result: ClaimResult) -> SubmitDecis /// The account read result. #[must_use] -pub const fn after_account( - state: SubmitState, - mode: Mode, - result: AccountResult, -) -> SubmitDecision { +pub const fn after_account(state: SubmitState, result: AccountResult) -> SubmitDecision { match result { - AccountResult::Equal => denied_from(state, mode, 0), - AccountResult::Mismatch => lease_failed(state, mode, Refusal::AccountMismatch), - AccountResult::Unavailable => lease_failed(state, mode, Refusal::AccountUnavailable), + AccountResult::Equal => denied_from(state, 0), + AccountResult::Mismatch => not_entered(state, Refusal::AccountMismatch), + AccountResult::Unavailable => not_entered(state, Refusal::AccountUnavailable), } } /// The result of the denied read at `index`. #[must_use] -pub const fn after_denied( - state: SubmitState, - mode: Mode, - index: u8, - result: DeniedResult, -) -> SubmitDecision { +pub const fn after_denied(state: SubmitState, index: u8, result: DeniedResult) -> SubmitDecision { match result { DeniedResult::Refused => { if index < state.plan.denied_reads { - denied_from(state, mode, index + 1) + denied_from(state, index + 1) } else { halt(state) } } - DeniedResult::Answered => lease_failed(state, mode, Refusal::CapabilityExcess), - DeniedResult::Unavailable => lease_failed(state, mode, Refusal::CapabilityUnavailable), + DeniedResult::Answered => not_entered(state, Refusal::CapabilityExcess), + DeniedResult::Unavailable => not_entered(state, Refusal::CapabilityUnavailable), } } @@ -620,36 +553,12 @@ pub const fn after_write(state: SubmitState, result: WriteResult) -> SubmitDecis } } -/// The response record result: at most one read-back, under a fresh lease. +/// Recording a response stops the submission without granting observation I/O. #[must_use] pub const fn after_response(state: SubmitState, record: ResponseRecord) -> SubmitDecision { match record { ResponseRecord::Failed => stop(state, Stop::Unknown), - ResponseRecord::Recorded { observable } => { - if observable { - go( - state, - Phase::Reload(Mode::ReadBack), - SubmitAction::Reload(Mode::ReadBack), - ) - } else { - stop(state, Stop::Response) - } - } - } -} - -/// The read-back result. -#[must_use] -pub const fn after_read_back(state: SubmitState, mode: Mode, recorded: bool) -> SubmitDecision { - if recorded { - stop(state, Stop::Observed) - } else { - match mode { - Mode::Entry => halt(state), - Mode::ReadBack => stop(state, Stop::Response), - Mode::Reobserve => stop(state, Stop::ReobservationUnrecorded), - } + ResponseRecord::Recorded => stop(state, Stop::Response), } } @@ -715,56 +624,42 @@ pub const fn pre_claim_step(state: SubmitState, event: SubmitEvent) -> SubmitDec #[must_use] pub const fn lease_step(state: SubmitState, event: SubmitEvent) -> SubmitDecision { match state.phase { - Phase::Resume => match event { - SubmitEvent::Resume(resumable) => { - if resumable { - go( - state, - Phase::Reload(Mode::Reobserve), - SubmitAction::Reload(Mode::Reobserve), - ) - } else { - stop(state, Stop::ReobservationUnrecorded) - } - } - _ => halt(state), - }, - Phase::Reload(mode) => match event { + Phase::Reload => match event { SubmitEvent::Reload(unchanged) => { if unchanged { - go(state, Phase::Lease(mode), SubmitAction::Lease(mode)) + go(state, Phase::Lease, SubmitAction::Lease) } else { - lease_failed(state, mode, Refusal::ConnectionChanged) + not_entered(state, Refusal::ConnectionChanged) } } _ => halt(state), }, - Phase::Lease(mode) => match event { + Phase::Lease => match event { SubmitEvent::Lease(leased) => { if leased { - go(state, Phase::Prefix(mode), SubmitAction::CheckPrefix(mode)) + go(state, Phase::Prefix, SubmitAction::CheckPrefix) } else { - lease_failed(state, mode, Refusal::CredentialUnavailable) + not_entered(state, Refusal::CredentialUnavailable) } } _ => halt(state), }, - Phase::Prefix(mode) => match event { + Phase::Prefix => match event { SubmitEvent::Prefix(allowed) => { if allowed { - after_prefix(state, mode) + after_prefix(state) } else { - lease_failed(state, mode, Refusal::ModeGuard) + not_entered(state, Refusal::ModeGuard) } } _ => halt(state), }, - Phase::Account(mode) => match event { - SubmitEvent::Account(result) => after_account(state, mode, result), + Phase::Account => match event { + SubmitEvent::Account(result) => after_account(state, result), _ => halt(state), }, - Phase::Denied(mode, index) => match event { - SubmitEvent::Denied(result) => after_denied(state, mode, index, result), + Phase::Denied(index) => match event { + SubmitEvent::Denied(result) => after_denied(state, index, result), _ => halt(state), }, _ => halt(state), @@ -773,7 +668,7 @@ pub const fn lease_step(state: SubmitState, event: SubmitEvent) -> SubmitDecisio /// A step between the credential checks and the stop: the entry's reads, /// the checkpoint, the reload and deadline before entry, the write, and the -/// store writes and read-back after it. +/// store writes after it. #[must_use] pub const fn entry_step(state: SubmitState, event: SubmitEvent) -> SubmitDecision { match state.phase { @@ -842,10 +737,6 @@ pub const fn entry_step(state: SubmitState, event: SubmitEvent) -> SubmitDecisio } _ => halt(state), }, - Phase::ReadBack(mode) => match event { - SubmitEvent::Recorded(recorded) => after_read_back(state, mode, recorded), - _ => halt(state), - }, _ => halt(state), } } @@ -863,12 +754,9 @@ pub const fn next_step(state: SubmitState, event: SubmitEvent) -> SubmitDecision | Phase::Scope | Phase::Prepare | Phase::Claim => pre_claim_step(state, event), - Phase::Resume - | Phase::Reload(_) - | Phase::Lease(_) - | Phase::Prefix(_) - | Phase::Account(_) - | Phase::Denied(_, _) => lease_step(state, event), + Phase::Reload | Phase::Lease | Phase::Prefix | Phase::Account | Phase::Denied(_) => { + lease_step(state, event) + } Phase::PreEntry | Phase::Ceiling | Phase::Checkpoint @@ -878,8 +766,7 @@ pub const fn next_step(state: SubmitState, event: SubmitEvent) -> SubmitDecision | Phase::Send | Phase::RecordResponse | Phase::RecordUnknown - | Phase::RecordNotEntered - | Phase::ReadBack(_) => entry_step(state, event), + | Phase::RecordNotEntered => entry_step(state, event), Phase::Done => halt(state), } } @@ -940,17 +827,8 @@ mod tests { SubmitEvent::Deadline(true), SubmitEvent::Granted(true), SubmitEvent::Write(WriteResult::Response), - SubmitEvent::Response(ResponseRecord::Recorded { observable: true }), - SubmitEvent::Reload(true), - SubmitEvent::Lease(true), - SubmitEvent::Prefix(true), - SubmitEvent::Account(AccountResult::Equal), - SubmitEvent::Denied(DeniedResult::Refused), - SubmitEvent::Denied(DeniedResult::Refused), - SubmitEvent::Recorded(true), + SubmitEvent::Response(ResponseRecord::Recorded), ]); - let entry = Mode::Entry; - let back = Mode::ReadBack; assert_eq!( run(STRIPE, &events), [ @@ -959,12 +837,12 @@ mod tests { SubmitAction::Admit, SubmitAction::Prepare, SubmitAction::Claim, - SubmitAction::Reload(entry), - SubmitAction::Lease(entry), - SubmitAction::CheckPrefix(entry), - SubmitAction::ReadAccount(entry), - SubmitAction::DeniedRead(entry, 0), - SubmitAction::DeniedRead(entry, 1), + SubmitAction::Reload, + SubmitAction::Lease, + SubmitAction::CheckPrefix, + SubmitAction::ReadAccount, + SubmitAction::DeniedRead(0), + SubmitAction::DeniedRead(1), SubmitAction::CeilingRead, SubmitAction::RecordCheckpoint, SubmitAction::ReloadBeforeEntry, @@ -972,14 +850,7 @@ mod tests { SubmitAction::GrantEntry, SubmitAction::Send, SubmitAction::RecordResponse, - SubmitAction::Reload(back), - SubmitAction::Lease(back), - SubmitAction::CheckPrefix(back), - SubmitAction::ReadAccount(back), - SubmitAction::DeniedRead(back, 0), - SubmitAction::DeniedRead(back, 1), - SubmitAction::ReadBack(back), - SubmitAction::Stop(Stop::Observed), + SubmitAction::Stop(Stop::Response), ] ); } @@ -1040,7 +911,7 @@ mod tests { assert!( !actions .iter() - .any(|action| matches!(action, SubmitAction::Lease(_) | SubmitAction::ReadBack(_))) + .any(|action| matches!(action, SubmitAction::Lease)) ); assert_eq!(actions.last(), Some(&SubmitAction::Stop(Stop::Stored))); let refused = run( diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 5203b0820..0f69545a9 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"adfa056c9fcbe7e061754b07fc36c0efa0298a81ac8c6744ee873bfdb14a1b2e"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"35bcb4b4c40e62efa83c90dd558fce517dd7371a518630d54cfb9e5c2a7976ed"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a9d75cdbdbc459bc3a282618e682b11dccf902a8d43caca26607aab779afadbd"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"b96753f7ba3197f5dd9c11440cd258a3f4d46b3cc474bbade7fbda41b35b13b0"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2b9e05c65435c91edc6594d667d07dd8664faa61499074a98422272537fd0dac"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"44b86b5b0277257b8d4c9628a977420b0c0f67cf7fd2220b413feca3aeb77b68"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"6d237830bc11cce09dff4a5895041a11c66ba172405b99ad7c664352c80c7e60"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"58ae05d87af3b750d42e8baa50f967ef9ae46b5c7c05a50f1af4cbd6bce12361"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"cde0279ce6ebd736c99102554ebb726a5147ef19470fe743141fdc50cf1519c4"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ce93d41787c170874abe73d517c2e21720fc04b997650743205c5977cba9ef72"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"bb7abcc4dbafec8efd29a3801795f687e133b95bef892b1fcb0f689c3f3dbe8b"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"adfa056c9fcbe7e061754b07fc36c0efa0298a81ac8c6744ee873bfdb14a1b2e"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"35bcb4b4c40e62efa83c90dd558fce517dd7371a518630d54cfb9e5c2a7976ed"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a9d75cdbdbc459bc3a282618e682b11dccf902a8d43caca26607aab779afadbd"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"63eebc3a879df6e6c9c3e3562cd34fa1cdf57c447b95fb1d37de9b00819a254a"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"4d94e8cea23ef564ece2b470d09fdf89aef1e82813361a75e765e0f089d63a18"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2b9e05c65435c91edc6594d667d07dd8664faa61499074a98422272537fd0dac"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"44b86b5b0277257b8d4c9628a977420b0c0f67cf7fd2220b413feca3aeb77b68"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d4de299fd3e15ed174e969e34556f23eda5d6c6292e90fbf50e180e9a77fecb1"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d96aa5670b5da73ed81bafb988fcfe977615511ff2c09ac428445d59d1da2c26"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"cde0279ce6ebd736c99102554ebb726a5147ef19470fe743141fdc50cf1519c4"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ce93d41787c170874abe73d517c2e21720fc04b997650743205c5977cba9ef72"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"ce445b58b10b2384bfd50818918006b63790ef8597d291438cfcbfa3f2c57c25"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 48fdda138..86dea03e7 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -8,6 +8,7 @@ //! (empty when nothing is stored), the refusal code, and the lease, read, and //! write counts. //! +//! A response terminates submission with no automatic observation. //! `record_cases` retain explicit operator observation mechanics as a reference; //! application replay only returns stored state. Neither oracle establishes //! independently authorized AP074 recovery. A grant with a lost response remains @@ -165,13 +166,7 @@ fn plain_response(key: &str, status: u16, body: Value) -> Value { setup } -const FULL: [&str; 5] = [ - "reserved", - "reserved", - "entry-granted", - "response-recorded", - "observed-by-provider", -]; +const FULL: [&str; 4] = ["reserved", "reserved", "entry-granted", "response-recorded"]; const REFUSED_AFTER_BASIS: [&str; 2] = ["reserved", "not-entered"]; fn relative_ceiling_cases() -> Vec { @@ -192,7 +187,7 @@ fn relative_ceiling_cases() -> Vec { json!({}), &FULL, None, - &counts(2, 6, 2, 1), + &counts(1, 3, 1, 1), ); boundary["basis"] = json!(1001); let mut mismatch = scenario( @@ -328,7 +323,7 @@ fn account_scope_cases() -> Vec { json!({}), &FULL, None, - &counts(2, 6, 2, 1), + &counts(1, 3, 1, 1), ); let credential_reads = |requests: &mut Vec| { for path in ["/v1/account", "/v1/customers", "/v1/payouts"] { @@ -344,13 +339,6 @@ fn account_scope_cases() -> Vec { false, )); requests.push(stripe_request("POST", "/v1/refunds", true, true)); - credential_reads(&mut requests); - requests.push(stripe_request( - "GET", - &format!("/v1/refunds/{REFUND}"), - true, - false, - )); only_action["requests"] = Value::Array(requests); vec![ scenario( @@ -399,7 +387,7 @@ fn pre_entry_cases() -> Vec { json!({}), &FULL, None, - &counts(2, 0, 2, 1), + &counts(1, 0, 1, 1), ); matching["pre_entry_observations"] = json!(1); vec![ @@ -450,7 +438,7 @@ fn entry_and_recovery_cases() -> Vec { json!({"validity_seconds": 86_340}), &FULL, None, - &counts(2, 6, 2, 1), + &counts(1, 3, 1, 1), ), scenario( "entry-deadline-exceeded", diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 2f39ecfe0..36b5612e0 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -14,7 +14,7 @@ use crate::engine::{GatewaySubmitResult, VerifiedCommand}; use crate::harness::{OBSERVER_SEED, ROOT_SEED, Signer, context}; use crate::pending_vectors::attempts::FILE as SCENARIOS; -use crate::recipe::GuardChecks; +use crate::recipe::{GuardChecks, ReadBack}; use crate::store::BatchCrash; use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; use crate::submit::{self, SubmitContext, SubmitIo, account_commitment}; @@ -461,13 +461,13 @@ async fn run( .await } -/// Explicit operator mechanics retained as a test oracle while independently -/// authorized recovery is implemented. This is never an application replay and -/// establishes no AP074 recovery-authority or bounded-acquisition claim. +/// Frozen observation mechanics for store/reference conformance only. Shipping +/// submission cannot call this oracle. It supplies neither native read authority +/// nor acquisition charges and is not AP074 recovery evidence. async fn reobserve_operator( attempts: &GatewayAttempts, recipe: &CompiledRecipe, - observer: &GatewayObserver, + _observer: &GatewayObserver, io: &TestIo<'_, P>, ) -> Option { let request = &io.verified.as_ref().expect("command").request; @@ -479,18 +479,53 @@ async fn reobserve_operator( ) .await .expect("operator lookup")?; - let context = test_context(observer); - submit::reobserve( - &SubmitContext { - recipe, - attempts, - context: &context, - observer: Some(observer), - }, - io, - attempt, - ) - .await + if !io.reload().await { + return None; + } + let lease = io.lease().await?; + let prefix = recipe + .guard_checks() + .is_none_or(|guard| io.secret_admitted(&lease, &guard)); + if !submit::lease_checks(recipe, io.provider, prefix, io.account_commitment()).await { + return None; + } + let observation = attempt.observation_request()?; + let response = io + .action_read( + &lease, + observation.url(), + observation.headers(), + observation.maximum_response_bytes(), + ) + .await?; + let bytes = response.usable_body()?; + let reading = observation.read_back(attempt.echo_token().as_deref(), bytes)?; + let status = attempt.snapshot().ok()?.response_status(); + match reading { + ReadBack::EchoMatched => { + let snapshot = attempt + .record_provider_evidence(bytes, io.clock()?) + .await + .ok()?; + Some(GatewaySubmitResult::ObservedByProvider { + status, + evidence: snapshot.provider_evidence()?.into(), + }) + } + ReadBack::Value { matched } => { + let status = status?; + attempt.record_observation(matched).await.ok()?; + Some(GatewaySubmitResult::Observed { status, matched }) + } + ReadBack::EchoMismatch => { + let status = status?; + attempt.record_echo_mismatch().await.ok()?; + Some(GatewaySubmitResult::Observed { + status, + matched: false, + }) + } + } } // --------------------------------------------------------------------------- @@ -788,6 +823,16 @@ async fn run_first_attempt_case(id: &str, backend: Backend) -> (String, usize) { } else { "response-recorded" }; + if record.recipe.review().has_observation() { + let io = TestIo::new(&provider, command.clone()); + let _ = reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await; + } ( format!("{from}->{}", record.describe(&command).await), provider.writes(), @@ -804,7 +849,18 @@ async fn run_resolution_case(id: &str, backend: Backend) -> (String, usize) { let mut record = Record::open("airtable", backend); let provider = RecordProvider::new(delivery, reading); let original = record.airtable(ORIGINAL, "Approved"); - let first = record.submit(&original, &provider).await; + let mut first = record.submit(&original, &provider).await; + if id == "fresh-challenge-after-observed-by-provider" { + let io = TestIo::new(&provider, original.clone()); + first = reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await + .expect("reference observation"); + } let before = record.describe(&original).await; if id == "restart-during-unknown" { record.store.restart(); @@ -905,11 +961,31 @@ async fn postgres_record_scenarios_drive_the_counting_provider() { } #[tokio::test] -async fn normal_write_reaches_observed_by_provider_with_secret_free_evidence() { +async fn response_requires_a_separate_reference_observation_for_evidence() { let record = Record::open("airtable", Backend::File); let provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); let command = record.airtable(ORIGINAL, "Approved"); - let result = record.submit(&command, &provider).await; + assert_eq!( + record.submit(&command, &provider).await, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!((provider.writes(), provider.reads()), (1, 0)); + assert!( + record + .snapshot(&command) + .await + .provider_evidence() + .is_none() + ); + let io = TestIo::new(&provider, command.clone()); + let result = reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io, + ) + .await + .expect("reference observation"); let snapshot = record.snapshot(&command).await; let evidence = snapshot.provider_evidence().expect("evidence"); let bytes = provider.last_read.lock().expect("last read").clone(); @@ -965,7 +1041,7 @@ async fn a_lost_claim_resends_the_same_idempotency_key() { let original = intact.airtable(ORIGINAL, "Approved"); assert!(matches!( intact.submit(&original, &provider).await, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } )); let fresh = intact.airtable(FRESH, "Approved"); assert_eq!( @@ -980,7 +1056,7 @@ async fn a_lost_claim_resends_the_same_idempotency_key() { }; assert!(matches!( lost.submit(&fresh, &provider).await, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } )); assert_eq!(provider.writes(), 2, "a lost claim no longer stops it"); assert_eq!( @@ -1582,7 +1658,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { RunStep { operation: Operation::Submit, evidence_comparison: EvidenceComparison::Static {}, - expected: expected(RunOutcome::Observed, "observed-by-provider", 2, 1, 1), + expected: expected(RunOutcome::ResponseRecorded, "response-recorded", 1, 1, 0), }, RunStep { operation: Operation::Replay, @@ -1596,10 +1672,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { 0, ) } else { - let mut stored = - expected(RunOutcome::Observed, "observed-by-provider", 0, 0, 0); - stored.verdict.evidence_sha256 = Some(evidence); - stored + expected(RunOutcome::ResponseRecorded, "response-recorded", 0, 0, 0) }, }, ] @@ -1642,6 +1715,12 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { Some(Sha256Digest::try_from(evidence.evidence_digest).expect("evidence")), u32::from(provider.reads() > reads_before), ), + GatewaySubmitResult::ResponseRecorded { .. } => ( + RunOutcome::ResponseRecorded, + "response-recorded".to_owned(), + None, + 0, + ), GatewaySubmitResult::Unknown => { (RunOutcome::Unknown, "unknown".to_owned(), None, 0) } @@ -1698,7 +1777,10 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { let (_, effects) = case .execute(&tuple, |index, _| Ok(observations[index].clone())) .expect("measured stage"); - assert_eq!((effects.entered, effects.confirmed_by_read_back), (1, 1)); + assert_eq!( + (effects.entered, effects.confirmed_by_read_back), + (1, u32::from(recovering)) + ); observations[1].observed.provider_entries += 1; assert!( case.execute(&tuple, |index, _| Ok(observations[index].clone())) @@ -1731,7 +1813,7 @@ async fn conformance_claim_exactly_once_and_replay(backend: Backend) { let first = record.submit(&original, &provider).await; assert!(matches!( first, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } )); let before = record.snapshot(&original).await; for _ in 0..3 { @@ -1746,7 +1828,7 @@ async fn conformance_claim_exactly_once_and_replay(backend: Backend) { .await, Err(GatewayAttemptError::Replay) )); - assert_eq!((provider.writes(), provider.reads()), (1, 1)); + assert_eq!((provider.writes(), provider.reads()), (1, 0)); } /// Full binding comparison survives restart. Namespace/partition/epoch scope @@ -1865,7 +1947,7 @@ async fn conformance_fresh_challenge(backend: Backend) { .await; assert!(matches!( first, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } )); assert_eq!( record @@ -1882,7 +1964,7 @@ async fn conformance_fresh_challenge(backend: Backend) { crate::engine::not_entered("gateway.effect.operation-conflict") ); } - assert_eq!((provider.writes(), provider.reads()), (1, 1)); + assert_eq!((provider.writes(), provider.reads()), (1, 0)); } /// An unknown write is resolved only by a later read-only observation on @@ -1941,6 +2023,18 @@ async fn conformance_echo_mismatch(backend: Backend) { let command = record.airtable(ORIGINAL, "Approved"); assert_eq!( record.submit(&command, &provider).await, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + let io = TestIo::new(&provider, command.clone()); + assert_eq!( + reobserve_operator( + record.store.attempts(), + &record.recipe, + &record.observer, + &io + ) + .await + .expect("reference observation"), GatewaySubmitResult::Observed { status: 200, matched: false @@ -2767,10 +2861,57 @@ async fn native_replay_projection_fixture_is_current() { for invalid in &invalid_reserved { assert!(serde_json::from_value::(invalid.clone()).is_err()); } + let response_record = Record::open("airtable", Backend::File); + let response_provider = RecordProvider::new(Delivery::Respond, Reading::Faithful); + let response_command = response_record.airtable(ORIGINAL, "Approved"); + let response_io = TestIo::new(&response_provider, response_command.clone()); + let response = run( + response_record.store.attempts(), + &response_record.recipe, + &response_record.observer, + &response_io, + ) + .await; + assert_eq!( + response, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!(response_io.leases(), 1); + assert_eq!( + (response_provider.writes(), response_provider.reads()), + (1, 0) + ); + let response_before = response_record.snapshot(&response_command).await; + assert_eq!( + response_before.stage(), + GatewayAttemptStage::ResponseRecorded + ); + assert!(response_before.provider_evidence().is_none()); + let response_replay_io = TestIo::new(&response_provider, response_command.clone()); + assert_eq!( + run( + response_record.store.attempts(), + &response_record.recipe, + &response_record.observer, + &response_replay_io + ) + .await, + response + ); + assert_eq!(response_replay_io.leases(), 0); + assert_eq!( + (response_provider.writes(), response_provider.reads()), + (1, 0) + ); + assert_eq!( + response_before, + response_record.snapshot(&response_command).await + ); let cases = json!({ "schema": "auths.gateway-replay-projection-fixture/1", "scope": "native synthetic driver and file journal; no installed authority or independent recovery claim", "unknown_replay": {"result": replay, "additional_leases": io.leases(), "additional_reads": 0, "additional_writes": 0, "journal_unchanged": true}, + "response_without_observation": {"result": response, "credential_leases": response_io.leases(), "provider_writes": response_provider.writes(), "provider_reads": response_provider.reads(), "provider_evidence": false, "replay_additional_leases": response_replay_io.leases(), "replay_journal_unchanged": true}, "unacknowledged_grants": grants, "concurrent_replays": {"results": [left, right], "additional_leases": 0, "additional_reads": 0, "additional_writes": 0, "journal_unchanged": true}, "reserved_decoding": {"valid": valid_reserved, "invalid": invalid_reserved}, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index bc3d53798..f8ba4c6e3 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "69a0a36b8289af3d98feb9d00831268ade92328d993ffe3adb5452794d99f914"; + "afb36fb9f149ab68c908640821bcb8cf741a7b5dfecaa2d8af3914e3c752abc3"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index d99689725..b30ce72ed 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2676,8 +2676,9 @@ impl ProviderEntryPermit { } } -/// A stored attempt that may be advanced only by a separate read-only -/// observation, never by another write. +/// A protected view of a stored attempt and its observation contract. +/// Production refinement requires independently acquired evidence through +/// the recovery fence; this view grants no provider or journal-entry capability. pub struct ObservableGatewayAttempt { attempt: Attempt, } @@ -2727,7 +2728,8 @@ impl ObservableGatewayAttempt { /// /// # Errors /// Persistence failure retains only the recorded response. - pub async fn record_observation( + #[cfg(test)] + pub(crate) async fn record_observation( self, matched: bool, ) -> Result { @@ -2742,7 +2744,10 @@ impl ObservableGatewayAttempt { /// /// # Errors /// Persistence failure retains only the recorded response. - pub async fn record_echo_mismatch(self) -> Result { + #[cfg(test)] + pub(crate) async fn record_echo_mismatch( + self, + ) -> Result { let mut next = self.attempt.record.clone(); next.state.stage = GatewayAttemptStage::Observed; next.state.observation_match = Some(false); @@ -2757,7 +2762,8 @@ impl ObservableGatewayAttempt { /// # Errors /// Rejects a recipe without echo, empty or oversized evidence, and /// persistence failure. - pub async fn record_provider_evidence( + #[cfg(test)] + pub(crate) async fn record_provider_evidence( self, evidence: &[u8], observed_at: u64, diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 0b8d30dce..a0260e750 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -12,23 +12,20 @@ use crate::effect::ApprovedEffect; use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered}; use crate::pre_entry::{self, PreEntryObservation, SelectedRequirement}; -use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES, ReadBack}; +use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES}; use crate::store::BoundedClaim; use crate::transport::{ GatewayTransportError, ProviderPort, ProviderResponse, WriteTransportOutcome, }; use crate::{ ClaimedGatewayAttempt, ClosedCredentialRead, CompiledRecipe, GatewayAttemptError, - GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, - ObservableGatewayAttempt, RequestHeader, + GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, RequestHeader, }; use auths_gateway_kernel::order::{ - AccountResult, CeilingRead, ClaimResult, DeniedResult, Mode, PreEntryResult, Refusal, - ResponseRecord, Stop, SubmitAction, SubmitDecision, SubmitEvent, SubmitPlan, Verification, - WriteResult, next_step, start, + AccountResult, CeilingRead, ClaimResult, DeniedResult, PreEntryResult, Refusal, ResponseRecord, + Stop, SubmitAction, SubmitDecision, SubmitEvent, SubmitPlan, Verification, WriteResult, + next_step, start, }; -#[cfg(test)] -use auths_gateway_kernel::order::{Phase, SubmitState}; use auths_model::{ResourceId, TrustedContext}; use serde_json::Value; use sha2::{Digest as _, Sha256}; @@ -257,7 +254,6 @@ struct Run<'a, I: SubmitIo> { selected: Vec, claim: Option, permit: Option, - observable: Option, lease: Option, pre_entry: GatewayPreEntry, written: Option<(u16, [u8; 32], Vec, bool)>, @@ -278,7 +274,6 @@ impl<'a, I: SubmitIo> Run<'a, I> { selected: Vec::new(), claim: None, permit: None, - observable: None, lease: None, pre_entry: GatewayPreEntry::default(), written: None, @@ -312,34 +307,6 @@ pub(crate) async fn run(cx: &SubmitContext<'_>, io: &I) -> GatewayS state.finish(stop) } -/// Runs the operator's read-only re-observation of `attempt`, which -/// [`GatewayAttempts::resume_observable_operation`] reopened, through the -/// existing operator step machine: a reload, a fresh lease that passes -/// every credential check, and one read-back from the stored plan. The -/// caller has already prepared the entry. Returns the recorded result, or -/// `None` when the read-back recorded nothing. -#[cfg(test)] -pub(crate) async fn reobserve( - cx: &SubmitContext<'_>, - io: &I, - attempt: ObservableGatewayAttempt, -) -> Option { - let mut state = Run::new(cx, io); - state.observable = Some(attempt); - let resumed = SubmitState { - plan: plan(cx.recipe), - phase: Phase::Resume, - argument: 0, - }; - match state - .drive(next_step(resumed, SubmitEvent::Resume(true))) - .await - { - Stop::Observed => state.result, - _ => None, - } -} - impl Run<'_, I> { fn refuse_before_claim(&mut self, result: GatewaySubmitResult) { self.result = Some(result); @@ -383,7 +350,7 @@ impl Run<'_, I> { SubmitEvent::Preparation(valid) } SubmitAction::Claim => SubmitEvent::Claim(self.claim().await), - SubmitAction::Reload(_) => SubmitEvent::Reload(self.io.reload().await), + SubmitAction::Reload => SubmitEvent::Reload(self.io.reload().await), SubmitAction::ReloadBeforeEntry => { // Counted before the reload, so an admin change committed // after this point is seen by the reload, and one committed @@ -391,17 +358,17 @@ impl Run<'_, I> { self.in_flight = Some(InFlight::enter(self.io)); SubmitEvent::Reload(self.io.reload().await) } - SubmitAction::Lease(_) => { + SubmitAction::Lease => { self.lease = self.io.lease().await; SubmitEvent::Lease(self.lease.is_some()) } - SubmitAction::CheckPrefix(_) => SubmitEvent::Prefix(match (&self.guard, &self.lease) { + SubmitAction::CheckPrefix => SubmitEvent::Prefix(match (&self.guard, &self.lease) { (None, Some(_)) => true, (Some(guard), Some(lease)) => self.io.secret_admitted(lease, guard), (_, None) => false, }), - SubmitAction::ReadAccount(_) => SubmitEvent::Account(self.read_account().await), - SubmitAction::DeniedRead(_, index) => { + SubmitAction::ReadAccount => SubmitEvent::Account(self.read_account().await), + SubmitAction::DeniedRead(index) => { SubmitEvent::Denied(self.denied_read(usize::from(index)).await) } SubmitAction::PreEntryRead => SubmitEvent::PreEntry(self.pre_entry_read().await), @@ -439,7 +406,6 @@ impl Run<'_, I> { self.in_flight = None; SubmitEvent::Recorded(recorded) } - SubmitAction::ReadBack(mode) => SubmitEvent::Recorded(self.read_back(mode).await), SubmitAction::Stop(_) => SubmitEvent::Start, } } @@ -793,13 +759,9 @@ impl Run<'_, I> { .filter(|_| version_ok && (200..300).contains(&status)) .and_then(|template| template.extract_locator(&body)); match claim.record_response(status, digest, locator).await { - Ok(observable) => { - let can_observe = observable.observation_request().is_some(); + Ok(_) => { self.result = Some(GatewaySubmitResult::ResponseRecorded { status }); - self.observable = Some(observable); - ResponseRecord::Recorded { - observable: can_observe, - } + ResponseRecord::Recorded } Err(_) => ResponseRecord::Failed, } @@ -825,84 +787,6 @@ impl Run<'_, I> { recorded } - /// One read-only observation from the stored plan, recording only what - /// the stored stage admits. The token comes from the stored commitment, - /// never from this submission. - async fn read_back(&mut self, _mode: Mode) -> bool { - let (Some(lease), Some(attempt)) = (&self.lease, self.observable.take()) else { - return false; - }; - let Some(observation) = attempt.observation_request() else { - return false; - }; - let Some(bytes) = self - .io - .action_read( - lease, - observation.url(), - observation.headers(), - observation.maximum_response_bytes(), - ) - .await - .as_ref() - .and_then(ProviderResponse::usable_body) - .map(<[u8]>::to_vec) - else { - return false; - }; - let token = attempt.echo_token(); - let Some(reading) = observation.read_back(token.as_deref(), &bytes) else { - return false; - }; - let Ok(snapshot) = attempt.snapshot() else { - return false; - }; - let status = snapshot.response_status(); - let result = match reading { - ReadBack::EchoMatched => { - let Some(observed_at) = self.io.clock() else { - return false; - }; - attempt - .record_provider_evidence(&bytes, observed_at) - .await - .ok() - .and_then(|snapshot| { - snapshot.provider_evidence().map(|evidence| { - GatewaySubmitResult::ObservedByProvider { - status, - evidence: evidence.into(), - } - }) - }) - } - ReadBack::Value { matched } => match status { - Some(status) => attempt - .record_observation(matched) - .await - .ok() - .map(|_| GatewaySubmitResult::Observed { status, matched }), - None => None, - }, - ReadBack::EchoMismatch => match status { - Some(status) => attempt.record_echo_mismatch().await.ok().map(|_| { - GatewaySubmitResult::Observed { - status, - matched: false, - } - }), - None => None, - }, - }; - match result { - Some(result) => { - self.result = Some(result); - true - } - None => false, - } - } - fn finish(self, stop: Stop) -> GatewaySubmitResult { match stop { Stop::Refused => self @@ -911,14 +795,13 @@ impl Run<'_, I> { Stop::StoreUnavailable | Stop::Stored | Stop::GrantUnavailable => { self.result.unwrap_or_else(unavailable_state) } - Stop::ClaimRefused | Stop::Response | Stop::Observed => { + Stop::ClaimRefused | Stop::Response => { self.result.unwrap_or(GatewaySubmitResult::Unknown) } Stop::NotEntered => self .refusal .map_or(GatewaySubmitResult::Unknown, not_entered), Stop::Unknown | Stop::Halted => GatewaySubmitResult::Unknown, - Stop::ReobservationUnrecorded => unavailable_state(), } } } From 7c7ff71b15eb1693a3f95928eb480173cb72a7ed Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 07:02:53 +0000 Subject: [PATCH 028/136] chore(formal): regenerate qualification artifacts Source-SHA: 119d1f78206ec39621f47366727261427de7ec5e Workflow-Run: 40647137194 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index b12830c08..75fbda208 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "145371541013f20b442ed785c5985d09733c8f8b6248619521874dfa29a19c45", + "digest": "c9ac74676348a1f08985b1ced96146edb800e3469dd5640579967b8266764b3a", "files": [ { "path": ".cargo/config.toml", @@ -189,7 +189,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/order.rs", - "sha256": "0d90f62f5dc4448e9e68ffc4baf1c4d5a68dd777443d24b25335c37e22378a07" + "sha256": "efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8" }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", From 66cb1e44e76cedb4902a8e127987f128830b0d8c Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 07:18:59 +0000 Subject: [PATCH 029/136] feat(gateway)!: bind prerequisite acquisition plans to exact approval --- .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 79 +++--- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/prerequisite-compilation.json | 216 +++++++++++++++++ .../gateway/recovery-compilation.json | 10 +- ...017-bound-effect-and-recovery-ownership.md | 27 +++ docs/plans/0074-implementation-status.md | 31 +++ .../0009-bound-effect-and-recovery.md | 19 ++ ...ound-effects-and-recovery-state-machine.md | 15 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6519 -> 6551 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6402 -> 6434 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5684 -> 5712 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 4993 -> 5017 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 76 +++--- .../auths-gateway/src/effect/prerequisite.rs | 222 +++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 3 + .../src/effect_prerequisite_tests.rs | 224 ++++++++++++++++++ product/runtime/auths-gateway/src/harness.rs | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- 26 files changed, 861 insertions(+), 89 deletions(-) create mode 100644 bindings/fixtures/gateway/prerequisite-compilation.json create mode 100644 product/runtime/auths-gateway/src/effect/prerequisite.rs create mode 100644 product/runtime/auths-gateway/src/effect_prerequisite_tests.rs diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 138a91275..95b02ba01 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 8a389dfab..1690ed728 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"Ov3dkHEuJbpcM0n6IVlpPnZxBh6Cumb9i5y6r9UrLWjI_T3WG9iNokAX1QgM9KqBIWOj9W5fsukIJ3gU9JTfBw"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"b3ozerw4GptGOSyfIAZwiKH6x3f45ECsV1NXdZfdN2ltVWBMuETW0OF93Bo4XFVbQa34X8ps4glR17MtzrrKDw"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index befddaaae..ba8908e07 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -73,7 +73,7 @@ ], "kind": "exact" }, - "compiler": "auths.gateway-effect-compiler/4", + "compiler": "auths.gateway-effect-compiler/5", "configuration": [ 12, 12, @@ -184,38 +184,38 @@ "protocol": { "kind": "mutation", "request": [ - 246, - 40, - 160, - 130, - 141, - 190, - 67, - 73, - 36, - 122, + 10, + 3, + 212, + 214, + 155, + 114, + 230, + 62, + 87, + 216, + 12, + 154, + 74, 136, - 120, - 45, - 200, - 112, - 63, - 63, - 208, - 224, - 162, - 81, - 191, - 76, - 102, - 28, - 45, - 211, - 67, - 39, - 95, - 101, - 222 + 62, + 244, + 119, + 78, + 150, + 133, + 199, + 20, + 221, + 144, + 143, + 12, + 172, + 156, + 100, + 132, + 227, + 54 ] }, "qualification_policy": "optional", @@ -259,8 +259,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -314,6 +314,7 @@ "presentation": "literal-complete-values/1", "schema": "auths.effect-review-contract/1" }, + "prerequisite_acquisitions": [], "recipe": { "account_scope": null, "bounds": null, @@ -393,17 +394,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/4\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/4\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 246,\n 40,\n 160,\n 130,\n 141,\n 190,\n 67,\n 73,\n 36,\n 122,\n 136,\n 120,\n 45,\n 200,\n 112,\n 63,\n 63,\n 208,\n 224,\n 162,\n 81,\n 191,\n 76,\n 102,\n 28,\n 45,\n 211,\n 67,\n 39,\n 95,\n 101,\n 222\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/5\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/5\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "11e0322e938a6c32bba7c9b1f881e885b7815a077d49aea53e9b29cc0a8a4a9b", + "effect_id_hex": "19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[246,40,160,130,141,190,67,73,36,122,136,120,45,200,112,63,63,208,224,162,81,191,76,102,28,45,211,67,39,95,101,222]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[17,224,50,46,147,138,108,50,187,167,201,177,248,129,232,133,183,129,90,7,125,73,174,165,62,155,41,204,10,138,74,155],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"Ov3dkHEuJbpcM0n6IVlpPnZxBh6Cumb9i5y6r9UrLWjI_T3WG9iNokAX1QgM9KqBIWOj9W5fsukIJ3gU9JTfBw\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"b3ozerw4GptGOSyfIAZwiKH6x3f45ECsV1NXdZfdN2ltVWBMuETW0OF93Bo4XFVbQa34X8ps4glR17MtzrrKDw\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxNywyMjQsNTAsNDYsMTQ3LDEzOCwxMDgsNTAsMTg3LDE2NywyMDEsMTc3LDI0OCwxMjksMjMyLDEzMywxODMsMTI5LDkwLDcsMTI1LDczLDE3NCwxNjUsNjIsMTU1LDQxLDIwNCwxMCwxMzgsNzQsMTU1XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6Ik92M2RrSEV1SmJwY00wbjZJVmxwUG5aeEJoNkN1bWI5aTV5NnI5VXJMV2pJX1QzV0c5aU5va0FYMVFnTTlLcUJJV09qOVc1ZnN1a0lKM2dVOUpUZkJ3In0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index dcae9958d..6455312eb 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[18,100,166,66,26,248,30,173,46,176,5,39,157,5,89,253,127,243,22,211,99,66,79,15,9,198,168,38,203,37,123,63],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"JjHflbiq4Kxv0DeawZJZp1Sp2q7ulJtdlzJEP7N6LXnB9TA1E_aFbXO7UTbO8Fz4HijeJahTnw5-kepLzO4-CQ\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[50,150,69,229,33,135,64,182,196,31,108,221,236,228,204,114,78,150,1,104,4,244,108,229,77,62,251,136,221,74,3,158],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"1z-bqatxaFT6gTbrLiDF4rWmgegel6iTKTJW8izpr_LOulj3PtpwqkCt6Fwm0js4TLeLDXWymhQoEITpbc-kBQ\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "1264a6421af81ead2eb005279d0559fd7ff316d363424f0f09c6a826cb257b3f", + "effect_id": "329645e5218740b6c41f6cddece4cc724e96016804f46ce54d3efb88dd4a039e", "dependencies": [] } }, @@ -36,11 +36,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea", + "effect_id": "8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json new file mode 100644 index 000000000..ff6cd50ae --- /dev/null +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -0,0 +1,216 @@ +{ + "schema": "auths.prerequisite-compilation-fixture/1", + "scope": "native signed compilation and exact approval only; no prerequisite admission, permit, provider, disclosure or installed human claim", + "cases": [ + { + "recipe": "stripe", + "effect_id_hex": "23aedb7108ab99cce78b9d277ff6481c6d4cea7b7c1c6c9bd517dd65699205d8", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[26,73,19,136,248,164,84,124,124,160,26,95,131,145,254,51,149,52,226,250,193,121,47,235,25,58,236,203,68,7,156,165],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[105,123,247,191,43,181,123,82,239,98,30,109,135,125,148,61,27,139,24,89,201,103,200,246,127,233,174,153,52,236,25,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[35,174,219,113,8,171,153,204,231,139,157,39,127,246,72,28,109,76,234,123,124,28,108,155,213,23,221,101,105,146,5,216],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"u8va4oVbTCwaTQi1pZ9FhnZifOUdwZNcBcvo_IV09PuamTFspi6fQLJC97DoCvyVK8EjbVBRd3Y5QbSR_e0vBw\"}", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "argument": 500, + "basis_points": 5000, + "binds": [ + [ + "/currency", + "usd" + ] + ], + "json_pointer": "/amount_received", + "kind": "relative-ceiling", + "subtract_pointer": null + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Stripe-Account", + "acct_TESTACCOUNT01" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/payment_intents/pi_TEST0000000001" + } + } + ], + "fresh_native_recompilation_preserves_plan": true, + "previous_compiler_binding_refused": true + }, + { + "recipe": "airtable-pre-entry", + "effect_id_hex": "19df37a438b464b6c359abcc45a41b56228c0b2cb40e6e71f89772381de97d5b", + "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,223,55,164,56,180,100,182,195,89,171,204,69,164,27,86,34,140,11,44,180,14,110,113,248,151,114,56,29,233,125,91],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"jUzdKpGAuX-tAZ2eN1n833C6WjZamoNoaxyYtYxONqioJBbBxoyGHLDD28yXLwojIyotJn8g-kfZq7e2pTsBDw\"}", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "json_pointers": [ + "/fields/DemoStatus" + ], + "kind": "pre-entry", + "native_authority": [ + 20, + 33, + 228, + 26, + 122, + 175, + 60, + 204, + 91, + 143, + 120, + 61, + 50, + 23, + 104, + 52, + 9, + 58, + 203, + 106, + 130, + 47, + 42, + 151, + 35, + 78, + 47, + 126, + 85, + 149, + 78, + 156 + ] + }, + "request": { + "headers": [], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001" + } + } + ], + "fresh_native_recompilation_preserves_plan": true, + "previous_compiler_binding_refused": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json index 184dd5991..f4d6a11e7 100644 --- a/bindings/fixtures/gateway/recovery-compilation.json +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -1,16 +1,16 @@ { "schema": "auths.gateway-recovery-compilation-fixture/1", "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", - "binding_canonical": "{\"action\":[121,145,68,173,211,138,135,161,28,134,183,154,153,10,252,104,92,101,98,60,145,47,130,115,176,30,123,208,183,194,10,4],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[173,193,92,249,69,68,138,168,193,17,66,18,30,227,144,128,57,121,239,156,64,222,81,15,206,162,84,185,69,169,225,163],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[169,149,105,204,149,124,180,181,69,188,18,143,231,47,30,167,20,105,162,250,164,21,156,63,221,152,205,87,62,103,136,40],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[18,197,59,131,150,29,95,219,1,244,51,180,248,206,101,147,201,223,115,150,108,32,39,190,19,184,1,97,1,162,51,236],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[211,194,13,23,52,192,145,185,115,193,195,151,106,137,100,45,79,251,92,184,78,178,191,58,156,157,204,253,139,222,205,122],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id": "eb552bb84c7d23789c0c93439bbaacdfc2f001835d6c35c08a83819b9754097b", + "binding_canonical": "{\"action\":[28,29,64,199,196,100,168,122,186,200,255,50,39,187,169,162,181,39,121,46,216,3,168,44,178,6,71,169,242,151,173,171],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[79,140,244,79,218,254,15,13,137,244,118,177,16,50,60,131,139,190,78,3,210,89,22,50,180,122,195,74,102,11,87,35],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[84,133,14,150,254,76,226,204,25,238,215,152,138,87,51,202,114,137,31,20,252,168,80,167,62,20,101,210,35,251,203,245],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,218,86,32,137,2,150,150,15,10,67,164,204,104,233,111,209,79,72,108,30,198,142,145,121,77,232,229,230,47,201,66],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[231,72,65,146,18,47,22,22,213,221,241,8,78,236,114,193,251,66,144,2,146,13,138,139,51,234,214,148,109,143,227,193],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "798928b00aa6e680768de38d0510246c8aec5eb18873b4b4b4acc8e137532c21", "authorization_call": { "arguments": { "maximum_response_bytes": 16384, "operation_id": "read-1", "operator_namespace": "observer-demo", - "read_contract": "a99569cc957cb4b545bc128fe72f1ea71469a2faa4159c3fdd98cd573e678828", + "read_contract": "54850e96fe4ce2cc19eed7988a5733ca72891f14fca850a73e1465d223fbcbf5", "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", - "source_effect": "c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b", + "source_effect": "ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718", "source_operation": "source-1" }, "name": "auths_gateway_recovery_read_v1", @@ -18,7 +18,7 @@ "profile_version": 2, "service": "gateway-observer-test" }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"eb552bb84c7d23789c0c93439bbaacdfc2f001835d6c35c08a83819b9754097b\",\n \"binding_canonical\": \"{\\\"action\\\":[121,145,68,173,211,138,135,161,28,134,183,154,153,10,252,104,92,101,98,60,145,47,130,115,176,30,123,208,183,194,10,4],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/4\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[173,193,92,249,69,68,138,168,193,17,66,18,30,227,144,128,57,121,239,156,64,222,81,15,206,162,84,185,69,169,225,163],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[169,149,105,204,149,124,180,181,69,188,18,143,231,47,30,167,20,105,162,250,164,21,156,63,221,152,205,87,62,103,136,40],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[18,197,59,131,150,29,95,219,1,244,51,180,248,206,101,147,201,223,115,150,108,32,39,190,19,184,1,97,1,162,51,236],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[211,194,13,23,52,192,145,185,115,193,195,151,106,137,100,45,79,251,92,184,78,178,191,58,156,157,204,253,139,222,205,122],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 121,\n 145,\n 68,\n 173,\n 211,\n 138,\n 135,\n 161,\n 28,\n 134,\n 183,\n 154,\n 153,\n 10,\n 252,\n 104,\n 92,\n 101,\n 98,\n 60,\n 145,\n 47,\n 130,\n 115,\n 176,\n 30,\n 123,\n 208,\n 183,\n 194,\n 10,\n 4\n ],\n \"native_authority\": [\n 173,\n 193,\n 92,\n 249,\n 69,\n 68,\n 138,\n 168,\n 193,\n 17,\n 66,\n 18,\n 30,\n 227,\n 144,\n 128,\n 57,\n 121,\n 239,\n 156,\n 64,\n 222,\n 81,\n 15,\n 206,\n 162,\n 84,\n 185,\n 69,\n 169,\n 225,\n 163\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/4\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 18,\n 197,\n 59,\n 131,\n 150,\n 29,\n 95,\n 219,\n 1,\n 244,\n 51,\n 180,\n 248,\n 206,\n 101,\n 147,\n 201,\n 223,\n 115,\n 150,\n 108,\n 32,\n 39,\n 190,\n 19,\n 184,\n 1,\n 97,\n 1,\n 162,\n 51,\n 236\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 211,\n 194,\n 13,\n 23,\n 52,\n 192,\n 145,\n 185,\n 115,\n 193,\n 195,\n 151,\n 106,\n 137,\n 100,\n 45,\n 79,\n 251,\n 92,\n 184,\n 78,\n 178,\n 191,\n 58,\n 156,\n 157,\n 204,\n 253,\n 139,\n 222,\n 205,\n 122\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 169,\n 149,\n 105,\n 204,\n 149,\n 124,\n 180,\n 181,\n 69,\n 188,\n 18,\n 143,\n 231,\n 47,\n 30,\n 167,\n 20,\n 105,\n 162,\n 250,\n 164,\n 21,\n 156,\n 63,\n 221,\n 152,\n 205,\n 87,\n 62,\n 103,\n 136,\n 40\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"799144add38a87a11c86b79a990afc685c65623c912f8273b01e7bd0b7c20a04\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"a99569cc957cb4b545bc128fe72f1ea71469a2faa4159c3fdd98cd573e678828\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"c74b570dfa9d1b2d93b89e0522a5d1531da1fcca6230b361261af46d5882374b\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"798928b00aa6e680768de38d0510246c8aec5eb18873b4b4b4acc8e137532c21\",\n \"binding_canonical\": \"{\\\"action\\\":[28,29,64,199,196,100,168,122,186,200,255,50,39,187,169,162,181,39,121,46,216,3,168,44,178,6,71,169,242,151,173,171],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/5\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[79,140,244,79,218,254,15,13,137,244,118,177,16,50,60,131,139,190,78,3,210,89,22,50,180,122,195,74,102,11,87,35],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[84,133,14,150,254,76,226,204,25,238,215,152,138,87,51,202,114,137,31,20,252,168,80,167,62,20,101,210,35,251,203,245],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[40,218,86,32,137,2,150,150,15,10,67,164,204,104,233,111,209,79,72,108,30,198,142,145,121,77,232,229,230,47,201,66],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[231,72,65,146,18,47,22,22,213,221,241,8,78,236,114,193,251,66,144,2,146,13,138,139,51,234,214,148,109,143,227,193],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 28,\n 29,\n 64,\n 199,\n 196,\n 100,\n 168,\n 122,\n 186,\n 200,\n 255,\n 50,\n 39,\n 187,\n 169,\n 162,\n 181,\n 39,\n 121,\n 46,\n 216,\n 3,\n 168,\n 44,\n 178,\n 6,\n 71,\n 169,\n 242,\n 151,\n 173,\n 171\n ],\n \"native_authority\": [\n 79,\n 140,\n 244,\n 79,\n 218,\n 254,\n 15,\n 13,\n 137,\n 244,\n 118,\n 177,\n 16,\n 50,\n 60,\n 131,\n 139,\n 190,\n 78,\n 3,\n 210,\n 89,\n 22,\n 50,\n 180,\n 122,\n 195,\n 74,\n 102,\n 11,\n 87,\n 35\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/5\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 40,\n 218,\n 86,\n 32,\n 137,\n 2,\n 150,\n 150,\n 15,\n 10,\n 67,\n 164,\n 204,\n 104,\n 233,\n 111,\n 209,\n 79,\n 72,\n 108,\n 30,\n 198,\n 142,\n 145,\n 121,\n 77,\n 232,\n 229,\n 230,\n 47,\n 201,\n 66\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 231,\n 72,\n 65,\n 146,\n 18,\n 47,\n 22,\n 22,\n 213,\n 221,\n 241,\n 8,\n 78,\n 236,\n 114,\n 193,\n 251,\n 66,\n 144,\n 2,\n 146,\n 13,\n 138,\n 139,\n 51,\n 234,\n 214,\n 148,\n 109,\n 143,\n 227,\n 193\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 84,\n 133,\n 14,\n 150,\n 254,\n 76,\n 226,\n 204,\n 25,\n 238,\n 215,\n 152,\n 138,\n 87,\n 51,\n 202,\n 114,\n 137,\n 31,\n 20,\n 252,\n 168,\n 80,\n 167,\n 62,\n 20,\n 101,\n 210,\n 35,\n 251,\n 203,\n 245\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"1c1d40c7c464a87abac8ff3227bba9a2b527792ed803a82cb20647a9f297adab\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"54850e96fe4ce2cc19eed7988a5733ca72891f14fca850a73e1465d223fbcbf5\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "refused_changed_fields": [ "source_effect", "source_operation", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index c16f84dcd..94a25922f 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -409,3 +409,30 @@ step machine has no read-back/resume mode: recording a response stops it, and observation requires the independent recovery acquisition. Ancillary/application reads remain the next production cutovers. The native corpus is file-journal mechanism evidence with synthetic entry/response/clock inputs, not installed transport qualification. + + +## Prerequisite acquisition compilation + +Compiler `/5` retains each mutation prerequisite as a closed compiler request +and a typed purpose. The ordered plan is part of the mutation transport +commitment and appears in native private approval review. Account reads pin the +installed account commitment and comparison domain; denied reads pin their +ordinal and refused statuses; relative-ceiling reads resolve the verified +argument and bind values; pre-entry reads pin their pointers and complete +selected native authority. There is no deserializer or application constructor +for this compiler output. + +The maximum plan is seven reads, each allowed once with its exact response bound, +a 15-second transport deadline, a 30-second evidence-age ceiling and no release +of content. Existing proof freshness conditions can be stricter. Onboarding +probes are outside this mutation plan. The same exact-approval and native +recompilation machinery binds these declarations; no separate token format or +approval owner is introduced. + +This checkpoint does not implement prerequisite admission or grants. The +existing raw prerequisite calls still require direct cutover to journaled, +charged acquisition entries and one-use permits. The parent approval is evidence +for only its enumerated recipe-derived reads; it is not general read authority +or authority to repeat an uncertain read. The native fixture establishes signed +compilation/review only, not entry eligibility, accounting, transport or the +installed human channel. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 19b70751f..90fd8b0fa 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -530,6 +530,37 @@ closure regeneration passed after that correction (one artifact-generation test) replacement credentials/read-policy limits, disclosure/ACK, maintained consumer/UI cutover and complete installed/fault/formal/CI evidence. +## Prerequisite declaration checkpoint + +- Compiler `/5` now commits the full ordered prerequisite acquisition plan in + the mutation transport identity and retains the original closed read values + beside the verified command. Native private review renders each typed purpose, + exact request, response limit, one-call allowance, transport/freshness bounds + and no-disclosure declaration. Old compiler bindings are refused directly. +- Account comparisons pin the installed account commitment/domain; denied reads + pin their ordinal and refused statuses; ceiling reads resolve verified values; + pre-entry reads pin pointers and selected native authority. The seven-read + maximum excludes onboarding probes and post-write observations. +- A new signed native fixture covers Stripe's four prerequisites and Airtable's + pre-entry plan. Initial generation caught fixture-only trust namespace and + delegation-depth errors, now corrected. The shared test trust helper now uses + the requested MCP service instead of the default harness service. It does not + broaden installed trust. +- Required native prerequisite, effect/review/approval, recovery acquisition, + mutation-entry and replay artifact generators passed on `119d1f78` plus this + source (one exact test each). Entry generation refreshed the signed journal + and transition fuzz seeds. Native CLI approval-envelope construction matched + the signed corpus, and final semantic-closure generation passed. These are + artifact-construction results, not full-suite or hosted CI evidence. +- Preserved remote bot commit `7c7ff71b` by fast-forward after inspecting its + isolated qualification source-closure hash update. No hosted workflow results + have been inspected. +- This is compilation/approval work, not durable read accounting. Existing raw + prerequisite calls remain an explicit open cutover. They must next consume the + retained compiler requests through the shared journal, capacity accounting and + one-use permits. No A01–A22 criterion closes; installed UI/bindings, disclosure, + replacement credentials, ordered admission, faults and formal/CI remain open. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index f22d25604..556f40f69 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -251,3 +251,22 @@ evidence, and a replay that adds no I/O or journal revision. The scenario corpus removes the former second lease, repeated credential checks and post-write read. Installed journeys, ancillary read admission and final translated/refinement artifacts remain required before this boundary has complete acceptance evidence. + + +## Prerequisite declaration comparison + +The Stripe reference contributes account and denied-capability checks plus a +relative-ceiling read; Airtable contributes the pre-entry read. Compiler `/5` +retains the existing closed requests rather than reconstructing provider paths. +The shared fields are exact method/URL/headers, one-call and response-byte +allowances, transport/freshness bounds and absence of disclosure. Evaluation +purposes remain tagged: account equality, expected refusal, selected pre-entry +requirements and relative arithmetic are not interchangeable response meanings. + +`prerequisite-compilation.json` uses signed native proofs and exact approvals to +freeze both plans, including account-scope header placement, resolved bound +values, exclusion of the onboarding probe, native recompilation and obsolete +compiler refusal. The Airtable case has no pre-entry observation requirement; +it tests compilation, not admission eligibility. The fixture has no provider, +custody, durable acquisition or human-channel claim. Runtime accounting, +independent differential execution and installed evidence remain required. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index c74c28926..ec965692d 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -143,7 +143,7 @@ Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. The concrete native encoding is `auths.bound-effect/3`, with effect compiler -`auths.gateway-effect-compiler/4`. Reservations use a closed window alternative: +`auths.gateway-effect-compiler/5`. Reservations use a closed window alternative: fixed epoch-aligned windows or the retained source effect's lifetime. Mutation count/sum reservations retain fixed windows; recovery acquisitions declare separate acquisition-count and response-byte charges against one source. A @@ -213,6 +213,19 @@ the approved recipe. Account for their entry and limits explicitly; they must no be invisible I/O outside the model. Acquiring those bytes does not authorize disclosing them to the agent. +Mutation compiler `/5` retains an ordered prerequisite acquisition plan beside +its verified command and commits the complete plan in the transport identity. +The plan names at most seven requests: one account check, up to four denied +capability checks, one pre-entry read and one relative-ceiling read. Each pins +its compiler-owned GET/HEAD, headers, response-byte ceiling (at most 65,536), +evaluation purpose and resolved values, one call, 15 transport seconds, at most +30 seconds of evidence age, and no disclosure. Tighter native evidence freshness +requirements still apply. Onboarding probes and later observations are separate +operations and cannot borrow this allowance. Private approval review renders +these declarations. The declaration alone is neither a capacity reservation nor +an entry permit; runtime must durably account and grant every constituent read +through the shared journal before contacting the provider. + Independent recovery compilation uses the reserved native MCP tool `auths_gateway_recovery_read_v1`; a mutation recipe cannot claim that name. Its `auths.gateway-recovery-read/1` contract binds the retained source effect diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 7643b218a..13f812008 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 9040fdbbe..95a27343f 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index cd209ec19..d19c941c7 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index ce0bc61a3..897f19ade 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 9c4c2074b..8eb8e68f7 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/4\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[38,231,82,111,83,191,109,78,95,34,206,9,12,79,248,23,13,126,142,168,162,156,24,58,139,0,171,119,62,126,161,160]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[53,131,53,18,76,39,59,176,155,12,106,21,110,234,237,117,242,149,203,76,19,94,75,173,26,8,234,128,131,84,47,234],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"_YnjOXddBDE1PU_17Qx_l2b4cXmKUlILDBPuOZENjg0A9gcQqaYTeNgATA4eFod2IQQBa4Oga9Ge36c9kU7fDA\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"358335124c273bb09b0c6a156eeaed75f295cb4c135e4bad1a08ea8083542fea","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index d72e25a36cfcdc586469481c5994bfc75b659f5f..7796c94422ad3f3d20eda90865733b49eea674e4 100644 GIT binary patch delta 1331 zcmeHG%Sv295Ovf|L_$D}YsF;=Rn=Yn*a^a@s56dH6HR33d+!X$h>XtlF$?hzggA?Q zhumd;D!Xh`*KcqYTr||<)H$c1`Y-=7vr|*^&o8r2jfPZ)xoFCan*H<0#+u&$pWG&YCUE!S1a^9*@fIm!te{ z%zKxum?VsxElQEWcy!tsmRF}Y;gAOH+s*9jL2_#++~0QXvU7~X!`8Uh-7hyfm0eh# z{*U*Y{QUfVJ$S=;-$yL+6s<^+t!~kj8fr^!Pv(kpoExP68qu0`v$dJXi-_ z11XTgfCrRdJxG;~1M-pvP%+9l-fXquENG6%g8;N#20f%yI%+sH;^Gm`*KhB`aL^wV z;cjpq=|b|pcq1GoXtHP^-e~Y?c=g+G`F$S?V-&cdPAA3;`n;MJKSqE8=d?1>Gr{8 zCF;H^vfFTS7!RuYVO_Cs1ZR>3gIU?N4$cBS`ql7osl9!vw=?a% zU3Y$-1}rFCQ@UoE8{M>xGrETK%_7joW06I0_FM?|F@LWZHtV{+-RL^++S-{db|np_ zPTP|XGL%e;lw}zcv0_4^iJ1r^COOBeVlsjR+6+TU$`TU72v5;MQY4U6ED4#QHPEDj zr3s5eh6y;IgdnFSu@tolC&jK|9PGac>?;^#5!|BBwCm2*lU`8r4ZGT^vc}I267y&g zOcR>QEyrFTEXvt?eMm9WHVwAgyXd`^W7A1ZZ%f;F2PZ6TV~@%TY-YRGtY8LuZuHs? zoi=tdi*~)&MQvxLUANO=8=P`ubFxd@J5RoR{sGi$yVoi$f??bEmG#cdpmL8rpjfAS z@Ad{+1l|sQcBhL3`qsCmt)UUnb@c3d^n1rZrnfIf%p|2n2xurm1WN&zm@^oKq^5p!aSj_ z2w^WqUAqdgNXK~{6N{kjs7K=nldi^fHWX<{ z_O`D&2S4PRFbiLE&chgRK%llhFKpHJWa`}r25ICiA5G-8_tETN`nlNA-Qbpp>9MzY z5i2aU2(sw6C+_=iAD_=u89x1Sqqy7-KEL?cyxhv4nn#(A(jiu*kD}}C@a(+vFP@F* zrMP~)`L6i&sg7sA%j$>tu|NNXcbAX0Hh<#3I>&Bs{E=QLXWb=}5s)%z{WJ#1-SruWTY*xmFQlYIx5k^{b zZWQNbVUeTKBICA7GZUH2mO7(jwvDl*9T!3(G?j{?I8Kr@%`&Zv!kDtOz!pR;^5TfR zUBbt2I5L>H4`K9X%HK2ZpF8pxJZSM9a}Qp=pY~4y_L&D*hd|x~ry1+|trBrx!b~D_ z3H&X4-MkAyJHcHjrb#GG1@&>$F}vxmKdgZr0q5w z<={UFAjU4gxws_Ooqoi>$or!HU-ICk`|?*TSXo`#ezGA8{urhL!oh<*RGwGP*5xq& z8r9kbtUC@k4^jv!NgVAgSOj10if-g#jI8x5w;tCy4&SxSfDEujT?G<~!&G6SS+%H6 z?k_%-#5oNjm*3vrrKj*MxSeh!$mpjV$^8ovl{Tjv$*#&j-AGP161s!^$FD3-H9jxQnasO4$DMJbS+BJpTIUBR zqmor!nWuNYcN$L0>S?&AN%{ZHJF OALv&mZr5_}(59cC9)#?`i7S!k zNO9=g1-JvZkb(7FgadI5RKI&ZIQ-KccGBhlnf_Lkoz=r13$6B?EzR1}sYM-R-zzam7&=>4BK^^DuRW-a_fEnF^;@Uk^X;|d=61Qa=vq~K3kMr3qi$!l`qr+0 zO~Y#{{JX9)DBWd8VAtQQ{Bn7i-g_C`FD`SImmXSBOttF~^M zC-ug#WT`9j_Lc7*hDMnlrZQ|#3clNJSG{bO-t7dTb9d1({aQMITY9MckM@^F>yqhg z?d$Js%k*RYbW12JghDQJZbX(bm$6)X`c5JEP#D$cPUW$@{_2 IuQxuEA9&OIF#rGn diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index 8d031aa429a040e02f3fe9980f344f60dd7f316a..11d469e0beb4f57f7c2f6cc8559071e1d2adc157 100644 GIT binary patch delta 746 zcmeHD%T5A85M%=;8ZZ8V!3&ornV!e)%+Z+mNR(v}QHcas!GvHG+y&i(G5&xTPksj3 zo1Xn3|G-*4!jp$idb+BsYWlVIQLB_nYoCkCo9CH)d;QCMVWmiFpIDJq#J(USiM6J{ z60-p2NGjmkpqC_#A&XXGEU+p72~Cm>xd2Q-mdP=(vv{GTBn@GwQI6PPk9F^vF1Dt# z_%{D8FNzR`47@}@EU{bY7Afq~iVG_P1lw>1H-KQkB>knY(FEZlIo{wRDGQ|60xU4` z8OFRw;VV**v8o6E;nQUFFiiUK`_Ia_8~0vbUEM7I LAN;QlUM>Fuot?N? delta 712 zcmeHDy-EW?5Y9mqL@ay-n>17G?9T4qmUkpdP?H=al8ADgm*hx{2>}CXg7^Zlu<{XX z1ie!5b!>eEXCJ~&*kNXv`F?g@YLB&QrLy<-Ufl)(mFN4P!Gj7xDuhr1A}0mt5KuU< zAvg_+Knep6P=a+J$*%+QlLn9&WkL?l+VB)KcglePv`m8z{K&5wZjHF!z}3-mmCYvO zNuJ$L7Uk2yYcSWI62YestN~`wEXfsW?WK`DNKYtOo-HZMwPisb5!({V!&uG{SVmX{ zEb6@y!@Vc|8v!vy(euyF`XU|7r|tf57}p!v>7{6sbvlzbl=tsWd$Z Result<(), EffectBindingError> { /// Closed protocol-specific compiler output. Neither alternative is transport /// authority, and a mutation-only admission path must refuse an acquisition. enum CompiledEffect { - Mutation(Box), + Mutation(Box), Acquisition(Box), } +struct VerifiedMutation { + command: VerifiedCommand, + prerequisites: Prerequisites, +} + /// Sealed native compilation result. It owns both the private binding and the /// exact immutable compiler output. There is no public constructor, clone or /// deserializer. Compiling this value does not approve it or grant entry. @@ -722,7 +732,7 @@ impl BoundEffect { #[must_use] pub fn private_request(&self) -> Option<&ClosedProviderRequest> { match &self.command { - CompiledEffect::Mutation(command) => Some(&command.request), + CompiledEffect::Mutation(mutation) => Some(&mutation.command.request), CompiledEffect::Acquisition(_) => None, } } @@ -752,12 +762,21 @@ impl BoundEffect { "credential_generation": self.connection.credential_generation().get(), "connection_contract": self.connection.contract().as_str(), }), - semantic: self.review.clone(), + semantic: match &self.command { + CompiledEffect::Mutation(mutation) => { + let mut review = self.review.clone(); + review["prerequisite_acquisitions"] = + serde_json::to_value(&mutation.prerequisites) + .map_err(|_| not_entered("gateway.effect.invalid-binding"))?; + review + } + CompiledEffect::Acquisition(_) => self.review.clone(), + }, effect_id_hex: hex::encode(self.binding.id().as_bytes()), binding_canonical, native: match &self.command { - CompiledEffect::Mutation(command) => { - serde_json::to_value(crate::engine::review_command(command)?) + CompiledEffect::Mutation(mutation) => { + serde_json::to_value(crate::engine::review_command(&mutation.command)?) .map_err(|_| not_entered("gateway.effect.invalid-binding"))? } CompiledEffect::Acquisition(command) => command.private_review(), @@ -989,7 +1008,7 @@ impl ApprovedEffect { } pub(crate) fn command(&self) -> Option<&VerifiedCommand> { match &self.effect.command { - CompiledEffect::Mutation(command) => Some(command), + CompiledEffect::Mutation(mutation) => Some(&mutation.command), CompiledEffect::Acquisition(_) => None, } } @@ -1107,6 +1126,11 @@ fn bind_mutation( action: &[u8], ) -> Result { let request = &command.request; + let prerequisites = Prerequisites::compile( + installed.recipe, + &command, + *installed.connection.account_commitment(), + )?; let mut reservations = Vec::new(); if let Some(bound) = &command.bound { for count in &bound.counts { @@ -1161,7 +1185,7 @@ fn bind_mutation( }, reservations, protocol: Protocol::Mutation { - request: request_commitment(request)?, + request: request_commitment(request, &prerequisites)?, }, })?; let review = serde_json::json!({ @@ -1172,7 +1196,10 @@ fn bind_mutation( let effect = BoundEffect { review, binding, - command: CompiledEffect::Mutation(Box::new(command)), + command: CompiledEffect::Mutation(Box::new(VerifiedMutation { + command, + prerequisites, + })), connection: installed.connection.clone(), proof: Zeroizing::new(proof.to_vec()), action: Zeroizing::new(action.to_vec()), @@ -1233,18 +1260,6 @@ struct ReadWire<'a> { maximum_response_bytes: usize, } -fn read_wire(read: &ClosedActionRead) -> ReadWire<'_> { - ReadWire { - url: read.url(), - headers: read - .headers() - .iter() - .map(|header| (header.name(), header.value())) - .collect(), - maximum_response_bytes: read.maximum_response_bytes(), - } -} - #[derive(Serialize)] struct RequestWire<'a> { method: &'a str, @@ -1256,11 +1271,13 @@ struct RequestWire<'a> { idempotency: Option<&'a str>, echo: Option<&'a str>, observation: Option<&'a ObservationTemplate>, - pre_entry: Option>, - relative_ceiling: Option>, + prerequisite_acquisitions: &'a Prerequisites, } -fn request_commitment(request: &ClosedProviderRequest) -> Result<[u8; 32], EffectBindingError> { +fn request_commitment( + request: &ClosedProviderRequest, + prerequisites: &Prerequisites, +) -> Result<[u8; 32], EffectBindingError> { let wire = RequestWire { method: request.method().as_str(), url: request.url(), @@ -1275,8 +1292,7 @@ fn request_commitment(request: &ClosedProviderRequest) -> Result<[u8; 32], Effec idempotency: request.idempotency_key(), echo: request.echo_token(), observation: request.observation_template(), - pre_entry: request.pre_entry_read().map(read_wire), - relative_ceiling: request.relative_ceiling_read().map(read_wire), + prerequisite_acquisitions: prerequisites, }; let bytes = canonical(&wire)?; commitment("auths.effect-transport/1", &bytes) diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs new file mode 100644 index 000000000..0d6eb1567 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -0,0 +1,222 @@ +//! Closed prerequisite acquisitions derived from a verified mutation and recipe. +//! These declarations are committed by the parent effect and displayed by its +//! native review. They grant neither read entry nor disclosure; the journal must +//! independently acknowledge each one-use acquisition before transport. + +use super::{EffectBindingError, canonical}; +use crate::engine::VerifiedCommand; +use crate::{ClosedActionRead, ClosedCredentialRead, CompiledRecipe}; +use serde::{Serialize, Serializer}; +use serde_json::Value; + +/// Account, four denied-capability reads, pre-entry and relative ceiling. +const MAX_PREREQUISITES: usize = 7; +const MAX_RESPONSE_BYTES: usize = 65_536; + +/// The complete ordered set for one mutation. Construction is private to the +/// native compiler; an application cannot append a request or select a purpose. +#[derive(Serialize)] +pub(super) struct Prerequisites(Vec); + +#[derive(Serialize)] +struct Prerequisite { + purpose: Purpose, + request: Read, + maximum_calls: u64, + maximum_transport_seconds: u64, + maximum_evidence_age_seconds: u64, + disclosure: Disclosure, +} + +#[derive(Serialize)] +#[serde(rename_all = "kebab-case")] +enum Disclosure { + None, +} + +#[derive(Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case")] +enum Purpose { + Account { + json_pointer: String, + expected_account_commitment: [u8; 32], + commitment_domain: &'static str, + }, + DeniedCapability { + index: u8, + refused_statuses: Vec, + }, + PreEntry { + json_pointers: Vec, + /// All selected native branches, evidence and conditions remain pinned. + native_authority: [u8; 32], + }, + RelativeCeiling { + argument: u64, + basis_points: u16, + json_pointer: String, + subtract_pointer: Option, + /// The exact verified values, rather than names to resolve later. + binds: Vec<(String, Value)>, + }, +} + +/// Retain the compiler's sealed read, not separately reconstructed URL data. +enum Read { + Credential(ClosedCredentialRead), + Action(ClosedActionRead), +} + +impl Serialize for Read { + fn serialize(&self, serializer: S) -> Result { + #[derive(Serialize)] + struct Request<'a> { + method: &'a str, + url: &'a str, + headers: Vec<(&'a str, &'a str)>, + maximum_response_bytes: usize, + } + let (method, url, headers, maximum_response_bytes) = match self { + Self::Credential(read) => ( + read.method().as_str(), + read.url(), + read.headers(), + read.maximum_response_bytes(), + ), + Self::Action(read) => ( + "GET", + read.url(), + read.headers(), + read.maximum_response_bytes(), + ), + }; + Request { + method, + url, + headers: headers.iter().map(|h| (h.name(), h.value())).collect(), + maximum_response_bytes, + } + .serialize(serializer) + } +} + +impl Prerequisites { + /// Synthetic store/driver oracles have no installed recipe/connection and + /// make no claim that they bind or authorize actual prerequisite reads. + #[cfg(any(test, feature = "testkit-harness"))] + pub(super) const fn oracle_empty() -> Self { + Self(Vec::new()) + } + + pub(super) fn compile( + recipe: &CompiledRecipe, + command: &VerifiedCommand, + account: [u8; 32], + ) -> Result { + let mut plan = Self(Vec::new()); + let reads = recipe + .credential_reads() + .map_err(|_| EffectBindingError::Invalid)?; + // The onboarding probe is not a mutation prerequisite. Commissioning + // must acquire its own separately bound probe, never inherit this plan. + if let Some(guard) = recipe.guard_checks() { + match (reads.account(), guard.account_pointer) { + (Some(read), Some(json_pointer)) => plan.push( + Purpose::Account { + json_pointer, + expected_account_commitment: account, + commitment_domain: "auths.gateway-account/1", + }, + Read::Credential(read.clone()), + )?, + (None, None) => {} + _ => return Err(EffectBindingError::Invalid), + } + if reads.denied().len() != guard.denied_refused.len() { + return Err(EffectBindingError::Invalid); + } + for (index, (read, refused_statuses)) in + reads.denied().iter().zip(guard.denied_refused).enumerate() + { + plan.push( + Purpose::DeniedCapability { + index: u8::try_from(index).map_err(|_| EffectBindingError::Invalid)?, + refused_statuses, + }, + Read::Credential(read.clone()), + )?; + } + } else if reads.account().is_some() || !reads.denied().is_empty() { + return Err(EffectBindingError::Invalid); + } + match ( + command.request.pre_entry_read(), + recipe.pre_entry_pointers(), + ) { + (Some(read), Some(pointers)) => plan.push( + Purpose::PreEntry { + json_pointers: pointers.to_vec(), + native_authority: command.native_authority, + }, + Read::Action(read.clone()), + )?, + (None, None) => {} + _ => return Err(EffectBindingError::Invalid), + } + match ( + command.request.relative_ceiling_read(), + recipe.ceiling_check(), + ) { + (Some(read), Some(ceiling)) => { + let argument = ceiling + .argument_value(&command.arguments) + .ok_or(EffectBindingError::Invalid)?; + let binds = ceiling + .binds + .into_iter() + .map(|(pointer, field)| { + command + .arguments + .get(&field) + .cloned() + .map(|value| (pointer, value)) + .ok_or(EffectBindingError::Invalid) + }) + .collect::>()?; + plan.push( + Purpose::RelativeCeiling { + argument, + basis_points: ceiling.basis_points, + json_pointer: ceiling.json_pointer, + subtract_pointer: ceiling.subtract_pointer, + binds, + }, + Read::Action(read.clone()), + )?; + } + (None, None) => {} + _ => return Err(EffectBindingError::Invalid), + } + canonical(&plan)?; + Ok(plan) + } + + fn push(&mut self, purpose: Purpose, request: Read) -> Result<(), EffectBindingError> { + let maximum = match &request { + Read::Credential(read) => read.maximum_response_bytes(), + Read::Action(read) => read.maximum_response_bytes(), + }; + if self.0.len() >= MAX_PREREQUISITES || !(1..=MAX_RESPONSE_BYTES).contains(&maximum) { + return Err(EffectBindingError::Invalid); + } + self.0.push(Prerequisite { + purpose, + request, + maximum_calls: 1, + maximum_transport_seconds: 15, + maximum_evidence_age_seconds: 30, + disclosure: Disclosure::None, + }); + Ok(()) + } +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 8393692c8..36adbf878 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -9,6 +9,9 @@ use auths_connections::{ }; use ed25519_dalek::{Signer as _, SigningKey}; +#[path = "effect_prerequisite_tests.rs"] +mod prerequisite_tests; + /// Native read authority is independent of an expired source writer. File /// provenance is real; the source entry is a test grant with no provider send. #[tokio::test] diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs new file mode 100644 index 000000000..319ae5569 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -0,0 +1,224 @@ +//! Native signed compilation witnesses for prerequisite acquisition declarations. +//! This fixture does not claim durable acquisition admission or provider entry. + +use super::*; + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one signed compilation corpus keeps each declaration and its witness together" +)] +fn native_prerequisite_compilation_fixture_is_current() { + let corpus: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" + )) + .expect("recipes"); + let scenarios: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/attempt-scenarios-v3.json" + )) + .expect("scenario inputs"); + let root = signer(h::ROOT_SEED); + let agent = signer(0x22); + let observer = signer(h::OBSERVER_SEED); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = + EffectPolicy::new("synthetic-prerequisites".to_owned(), 1, public).expect("policy"); + let mut cases = Vec::new(); + for base in ["stripe", "airtable-pre-entry"] { + let recipe = CompiledRecipe::compile( + &serde_json::to_vec(&corpus["bases"][base]["recipe"]).expect("source"), + &serde_json::to_vec(&corpus["bases"][base]["lock"]).expect("lock"), + ) + .expect("compiled recipe"); + let mut arguments = scenarios["defaults"][base]["arguments"] + .as_object() + .expect("arguments") + .clone(); + arguments.insert( + "operator_namespace".to_owned(), + json!(recipe.namespace().as_str()), + ); + arguments.insert("recipe_digest".to_owned(), json!(recipe.digest_hex())); + let call = McpToolCall::new(recipe.review().service(), recipe.review().tool(), arguments) + .expect("call"); + let context = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("trust"); + let connection = connection(&recipe); + let grant = if base == "stripe" { + let bound = crate::ArgumentCeilingPolicy::new("amount", 1_000, 3_600, 10) + .expect("bound") + .with_sum( + 10_000, + Some(crate::ListedValues::new("currency", &["usd"]).expect("partition")), + ) + .expect("sum") + .with_scope( + crate::ListedValues::new("connect_account", &["acct_TESTACCOUNT01"]) + .expect("scope"), + ) + .expect("scope bound"); + let extension = CriticalExtension::new( + ExtensionId::parse(auths_registries::BOUNDED_POLICY_COMMITMENT_EXTENSION_V1) + .expect("extension ID"), + bound.extension_body(None).expect("bound extension"), + ) + .expect("extension"); + let statement = GrantStatement::new( + root.principal.clone(), + agent.principal.clone(), + call.profile_ref().expect("profile"), + PermissionSet::new(vec![call.permission().expect("permission")]) + .expect("permissions"), + window(NOW - 3_600, NOW + 3_600), + AudienceSet::new(vec![audience()]).expect("audiences"), + ActionConstraint::AnyBody, + None, + 0, + None, + StatusPolicy::ExpiryOnly, + AssurancePolicyId::parse(ASSURANCE).expect("assurance"), + CriticalExtensions::new(vec![extension]).expect("extensions"), + ); + let descriptor = root.descriptor(); + let signature = + root.sign(&grant_signing_preimage(&statement, &descriptor).expect("preimage")); + SignedGrant::new(statement, SignatureEnvelope::new(descriptor, signature)) + } else { + // Compilation pins all selected native authority. Runtime admission + // still requires the pre-entry observation requirement; this case + // demonstrates only request/plan compilation, never entry eligibility. + h::grant_for_tool( + &root, + &agent.principal, + None, + window(NOW - 3_600, NOW + 3_600), + &call, + ) + .expect("grant") + }; + let submission = submission_for_call(&root, &agent, &grant, &call, &[]); + let installed = policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = + compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) + .expect("native compilation"); + let review: Value = serde_json::from_slice( + &effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("private bytes"), + ) + .expect("review JSON"); + let plan = review["semantic"]["prerequisite_acquisitions"] + .as_array() + .expect("plan"); + assert_eq!(plan.len(), if base == "stripe" { 4 } else { 1 }); + for read in plan { + assert_eq!(read["maximum_calls"], 1); + assert_eq!(read["maximum_transport_seconds"], 15); + assert_eq!(read["maximum_evidence_age_seconds"], 30); + assert_eq!(read["disclosure"], "none"); + assert!( + (1..=65_536).contains( + &read["request"]["maximum_response_bytes"] + .as_u64() + .expect("limit") + ) + ); + assert!( + !read["request"]["url"] + .as_str() + .expect("URL") + .ends_with("/balance"), + "onboarding probe is not implicit mutation I/O" + ); + } + if base == "stripe" { + assert_eq!(plan[0]["purpose"]["kind"], "account"); + assert_eq!( + plan[0]["purpose"]["expected_account_commitment"], + json!(connection.account_commitment()) + ); + assert_eq!(plan[1]["purpose"]["kind"], "denied-capability"); + assert_eq!(plan[2]["purpose"]["index"], 1); + assert_eq!(plan[1]["purpose"]["refused_statuses"], json!([403])); + assert_eq!(plan[3]["purpose"]["kind"], "relative-ceiling"); + assert_eq!(plan[3]["purpose"]["argument"], 500); + assert_eq!(plan[3]["purpose"]["binds"], json!([["/currency", "usd"]])); + assert_eq!( + plan[3]["request"]["url"], + "https://api.stripe.com/v1/payment_intents/pi_TEST0000000001" + ); + for read in &plan[..3] { + assert!( + !read["request"]["headers"] + .as_array() + .expect("headers") + .iter() + .any(|header| header[0] == "Stripe-Account") + ); + } + assert!( + plan[3]["request"]["headers"] + .as_array() + .expect("headers") + .contains(&json!(["Stripe-Account", "acct_TESTACCOUNT01"])) + ); + } else { + assert_eq!(plan[0]["purpose"]["kind"], "pre-entry"); + assert_eq!( + plan[0]["purpose"]["json_pointers"], + json!(["/fields/DemoStatus"]) + ); + } + let mut obsolete: Value = + serde_json::from_slice(&effect.binding().to_private_bytes().expect("binding")) + .expect("binding JSON"); + obsolete["compiler"] = json!("auths.gateway-effect-compiler/4"); + assert_eq!( + EffectBinding::from_private_bytes( + &serde_json_canonicalizer::to_vec(&obsolete).expect("canonical obsolete binding") + ), + Err(crate::effect::EffectBindingError::Unsupported), + ); + let approval_request = effect + .approval_request(NOW, NOW + 30) + .expect("approval request"); + let signature = key + .sign(&approval_request.signing_message().expect("message")) + .to_bytes(); + let approval = approval_request.with_signature(signature); + let approved = effect + .approve(approval.clone(), &public, NOW) + .expect("approved exact plan"); + approved + .validate_for_entry(&installed, NOW + 1) + .expect("same native compilation and plan"); + cases.push(json!({ + "recipe": base, + "effect_id_hex": hex::encode(approved.effect().binding().id().as_bytes()), + "binding_canonical": std::str::from_utf8(&approved.effect().binding().to_private_bytes().expect("binding")).expect("binding UTF-8"), + "approval_canonical": std::str::from_utf8(&approval.to_private_bytes().expect("approval")).expect("approval UTF-8"), + "prerequisite_acquisitions": plan, + "fresh_native_recompilation_preserves_plan": true, + "previous_compiler_binding_refused": true, + })); + } + let fixture = serde_json::to_vec_pretty(&json!({ + "schema": "auths.prerequisite-compilation-fixture/1", + "scope": "native signed compilation and exact approval only; no prerequisite admission, permit, provider, disclosure or installed human claim", + "cases": cases, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/prerequisite-compilation.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 3654aae2b..ad0ef4bb0 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -451,7 +451,7 @@ fn context_for( "permissions", )?, vec![fixture( - ResourceId::parse(&format!("mcp://{SERVICE}/")), + ResourceId::parse(&format!("mcp://{}/", unbound.service())), "namespace", )?], fixture(AudienceSet::new(vec![audience()?]), "audiences")?, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index f8ba4c6e3..94835c4e6 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "afb36fb9f149ab68c908640821bcb8cf741a7b5dfecaa2d8af3914e3c752abc3"; + "09e170f1cb91fba85bb2ba35d6d062e8a74b5365cf0663e696903098c5f4e9c0"; #[cfg(test)] mod tests { From 8ef39b9f0178c97c2246e9fdf75460d4fb6cab08 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 07:51:00 +0000 Subject: [PATCH 030/136] feat(gateway)!: enforce durable prerequisite read grants --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/effect-entry.json | 5 +- .../gateway/prerequisite-compilation.json | 4 +- .../fixtures/gateway/prerequisite-entry.json | 230 ++++++++++++++++ ...017-bound-effect-and-recovery-ownership.md | 43 +++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 44 ++- .../0009-bound-effect-and-recovery.md | 21 ++ ...ound-effects-and-recovery-state-machine.md | 12 + .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6551 -> 6551 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6434 -> 6434 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5712 -> 5712 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5017 -> 5017 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 81 +++++- .../auths-gateway/src/effect/acquisition.rs | 49 +++- .../auths-gateway/src/effect/prerequisite.rs | 212 ++++++++++++-- .../auths-gateway/src/effect_native_tests.rs | 4 +- .../src/effect_prerequisite_tests.rs | 180 +++++++++++- product/runtime/auths-gateway/src/engine.rs | 34 +-- product/runtime/auths-gateway/src/harness.rs | 28 +- .../src/pending_vectors/attempts.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 32 +-- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 25 +- .../auths-gateway/src/store/acquisition.rs | 258 ++++++++++++++++-- .../src/store/acquisition/recovery.rs | 7 +- product/runtime/auths-gateway/src/submit.rs | 164 ++++++----- .../runtime/auths-gateway/src/transport.rs | 60 +++- 36 files changed, 1291 insertions(+), 226 deletions(-) create mode 100644 bindings/fixtures/gateway/prerequisite-entry.json diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 7b0630c73..d22d9992d 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/8", + "attempt_schema": "auths.gateway-attempt/9", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index 6455312eb..586b09ef4 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -24,7 +24,10 @@ "schema": "auths.effect-entry/2", "granted_at": 1790000061, "effect_id": "329645e5218740b6c41f6cddece4cc724e96016804f46ce54d3efb88dd4a039e", - "dependencies": [] + "dependencies": [ + "55aab28f95092b9b9abc5dce74fcd3a13b02a2f54250893bed28852ac45fa264", + "f2e4936daf26963e87b15bc36f0cdd7d548fbe5e291e318f65867fcd9156f7b2" + ] } }, "scope": "native synthetic post-verification grant; no provider entry or installed authority claim", diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index ff6cd50ae..bb024c3f0 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -6,7 +6,7 @@ "recipe": "stripe", "effect_id_hex": "23aedb7108ab99cce78b9d277ff6481c6d4cea7b7c1c6c9bd517dd65699205d8", "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[26,73,19,136,248,164,84,124,124,160,26,95,131,145,254,51,149,52,226,250,193,121,47,235,25,58,236,203,68,7,156,165],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[105,123,247,191,43,181,123,82,239,98,30,109,135,125,148,61,27,139,24,89,201,103,200,246,127,233,174,153,52,236,25,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[35,174,219,113,8,171,153,204,231,139,157,39,127,246,72,28,109,76,234,123,124,28,108,155,213,23,221,101,105,146,5,216],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"u8va4oVbTCwaTQi1pZ9FhnZifOUdwZNcBcvo_IV09PuamTFspi6fQLJC97DoCvyVK8EjbVBRd3Y5QbSR_e0vBw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[35,174,219,113,8,171,153,204,231,139,157,39,127,246,72,28,109,76,234,123,124,28,108,155,213,23,221,101,105,146,5,216],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"G3PVyIcv8g1uAusqVNgOnwUUElXyhNrtG280JQcsrmHZXJJl8LXTHulP76epBQ_34DYTUoxeyDQcXUbE03jQAA\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -154,7 +154,7 @@ "recipe": "airtable-pre-entry", "effect_id_hex": "19df37a438b464b6c359abcc45a41b56228c0b2cb40e6e71f89772381de97d5b", "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,223,55,164,56,180,100,182,195,89,171,204,69,164,27,86,34,140,11,44,180,14,110,113,248,151,114,56,29,233,125,91],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"jUzdKpGAuX-tAZ2eN1n833C6WjZamoNoaxyYtYxONqioJBbBxoyGHLDD28yXLwojIyotJn8g-kfZq7e2pTsBDw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,223,55,164,56,180,100,182,195,89,171,204,69,164,27,86,34,140,11,44,180,14,110,113,248,151,114,56,29,233,125,91],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"1WvIQRCUXSW21bv6uK8ewPNF1XK9Oi9RxPYVmzMy8XRvkOLwYum4Z74UEM0sGq0yrCozHpCqb1kz-kBzfvBBDQ\"}", "prerequisite_acquisitions": [ { "disclosure": "none", diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json new file mode 100644 index 000000000..7e1aa5d5f --- /dev/null +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -0,0 +1,230 @@ +{ + "schema": "auths.prerequisite-entry-fixture/1", + "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", + "attempt_schema": "auths.gateway-attempt/9", + "cases": [ + { + "recipe": "stripe", + "histories": [ + { + "history": "recorded-response", + "lost_read_permits": false, + "reopened_reads": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + } + ], + "second_read_grants": 0, + "write_grant": true, + "provider_calls": 0, + "stale_evidence_refused": true + }, + { + "history": "lost-permit", + "lost_read_permits": true, + "reopened_reads": [ + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": false + }, + { + "history": "missing-read", + "lost_read_permits": false, + "reopened_reads": [], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": true + }, + { + "history": "stale-response", + "lost_read_permits": false, + "reopened_reads": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + } + ], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": true + } + ] + }, + { + "recipe": "airtable-pre-entry", + "histories": [ + { + "history": "recorded-response", + "lost_read_permits": false, + "reopened_reads": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + } + ], + "second_read_grants": 0, + "write_grant": true, + "provider_calls": 0, + "stale_evidence_refused": true + }, + { + "history": "lost-permit", + "lost_read_permits": true, + "reopened_reads": [ + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": false + }, + { + "history": "missing-read", + "lost_read_permits": false, + "reopened_reads": [], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": true + }, + { + "history": "stale-response", + "lost_read_permits": false, + "reopened_reads": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + } + ], + "second_read_grants": 0, + "write_grant": false, + "provider_calls": 0, + "stale_evidence_refused": true + } + ] + } + ] +} \ No newline at end of file diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 94a25922f..e76e96e82 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -436,3 +436,46 @@ for only its enumerated recipe-derived reads; it is not general read authority or authority to repeat an uncertain read. The native fixture establishes signed compilation/review only, not entry eligibility, accounting, transport or the installed human channel. + + +## Durable prerequisite acquisitions + +Journal `/9` stores a closed acquisition-plan alternative: independently +approved recovery, or one enumerated prerequisite of the exact approved +mutation. Both use the existing acquisition states, transition predicate, +permanent allocation slots, fenced grant and response persistence. There is no +new approval envelope, task ledger or retry decision owner. Old journal records +are refused directly; the PostgreSQL storage schema remains `/8` because its +existing record kinds and transaction contract suffice. + +A prerequisite record retains the parent binding and exact approval plus its +ordinal and a bounded canonical transport membership witness. Decoding checks +the witness against the parent transport commitment and checks the declaration's +one-call, response-byte, transport, freshness and no-disclosure limits. Audit +witnesses never construct transport requests. The permit carries the original +sealed compiler read. The component replay key derives from the parent's logical +operation key and ordinal, not its effect digest; a changed binding cannot +create another component under the same operation. Its permanent allocation +charges one invocation and the full response ceiling, including unknown entry. + +The acquisition grant fence includes its record, the reserved parent, its +allocation and current native entry dependencies. A parent that already entered +or became not-entered cannot issue a prerequisite permit. Only acknowledged +publication returns a permit. Concurrent stale handles, replay and reopened +entry grants cannot issue another. Recorded responses retain their receipt +time; pre-entry evidence uses the earlier grant time conservatively. Loading +history does not refresh either timestamp. + +Submission's account, denied-capability, pre-entry and relative-ceiling reads now +consume these permits. It evaluates a response only after durable recording. The +final mutation fence includes every required child record and allocation and +refuses missing, uncertain or stale responses. Seven prerequisites add at most +14 dependencies; together with 34 mutation slots, the parent and three installed +dependencies this uses at most 52 of the existing 64-record fence limit. + +This source cutover does not close installed evidence: tighter native observer +freshness at the final lock boundary, complete selected-evidence provenance, +ordered initial admission, all application/onboarding reads and disclosure still +need completion. The file fixture uses native compilation but explicit-time +oracle grants and synthetic responses; it is not provider transport, installed +native entry or PostgreSQL qualification. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index cce6bfab8..bcc544941 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -179,7 +179,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/8`; a store holding obsolete records is refused as + `auths.gateway-attempt/9`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 90fd8b0fa..6e86f7b75 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -561,6 +561,44 @@ closure regeneration passed after that correction (one artifact-generation test) one-use permits. No A01–A22 criterion closes; installed UI/bindings, disclosure, replacement credentials, ordered admission, faults and formal/CI remain open. +## Durable prerequisite checkpoint + +- Journal `/9` now has a closed recovery/prerequisite acquisition-plan variant. + Both use the existing shared codec, reducer, permanent count/byte allocation, + fenced entry and response persistence. PostgreSQL storage schema stays `/8`; + its current record kinds suffice. Obsolete attempt records are rejected. +- A prerequisite's component key binds the parent logical operation and compiler + ordinal, so a changed binding cannot evade replay by changing its digest. + Its bounded canonical transport witness proves approved plan membership but + cannot construct a transport request. Only the retained sealed read reaches + the permit and transport. +- Read grants fence the child, still-reserved parent, allocation and current + native dependencies. Submission's account, denied, pre-entry and ceiling + reads now consume these permits. Responses are evaluated only after durable + recording. Lost permits/responses remain charged and cannot be reminted. +- Final mutation entry fences every required child response and allocation and + refuses missing, uncertain, future or stale evidence. Receipt timestamps are + immutable; signed pre-entry observations and ceiling bases use the earlier + acquisition grant time conservatively. Seven reads add 14 dependencies, for + at most 52 of the existing 64-record fence bound. +- `prerequisite-entry.json` adds eight file-journal histories across native + Stripe/Airtable plans: recorded response, missing read, lost permit and stale + response. Equal reservations preserve capacity, competing handles cannot + both grant, reopening returns history, substituted membership fails, and + future/stale reads are unusable. This uses explicit-time oracle grants and + synthetic bodies with zero provider calls. In particular, the Airtable case + does not establish installed pre-entry requirement eligibility. +- Required artifact generators passed (one exact test each): prerequisite + compilation/entry, independent recovery, mutation entry/fuzz seeds, native + replay projection and semantic closure. Earlier compilation attempts caught + stale test-only raw-read calls and zeroizing-buffer type mismatches, corrected + before generation passed. No broad local suite or hosted CI was observed. +- Still open: ordered initial admission, tighter selected observer evidence + validation at the final fence, full prerequisite fault/transport/PostgreSQL + evidence, application/onboarding reads, safe credential replacement and read + policy bounds, disclosure/ACK, Python-owner removal, installed UI/bindings, + formal/performance and final CI. No A01–A22 criterion closes at this checkpoint. + ## Phase gates | Phase | State | Outstanding gate | @@ -568,7 +606,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery acquisition/refinement and operator route wired | Remaining read cutovers, disclosure/ACK; remove Python semantic owner | +| P3 | Recovery and prerequisite acquisition routes wired | Application/onboarding read cutovers, disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -582,7 +620,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file fixture | Full adapter concurrency and all units pending | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file fixtures including prerequisite charges | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | @@ -591,7 +629,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A10 | Timeout/denial/response/state-match distinction | Pending / no / no | Native projection | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | -| A13 | Lock wait and independent evidence expiries | Pending / no / no | Clock/full verifier inside boundary | +| A13 | Lock wait and independent evidence expiries | Partial / narrow prerequisite cases / file fixture only | Lock-wait races and tighter selected observer freshness pending | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 556f40f69..a433b59ab 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -270,3 +270,24 @@ compiler refusal. The Airtable case has no pre-entry observation requirement; it tests compilation, not admission eligibility. The fixture has no provider, custody, durable acquisition or human-channel claim. Runtime accounting, independent differential execution and installed evidence remain required. + + +## Prerequisite journal cutover + +The same acquisition transition/adapter mechanism now handles the two compared +prerequisite plans. Their authority differs from recovery: a prerequisite uses +its exact parent's approved enumeration while the parent remains reserved; +recovery uses an independent read proof/approval and an eligible unresolved +source. A closed plan variant and source check preserve that distinction. +Neither path decodes audit data into a transport request or grants disclosure. + +`prerequisite-entry.json` records file-journal histories for both compiled plans: +missing reads, recorded responses, lost permits and stale responses. Equal +reservations retain their charges, only one concurrent handle wins entry, +reopening cannot remint a permit, response times are preserved, and final write +entry requires fresh recorded child facts and their original allocations. +Membership-witness substitution is rejected. Grants use an explicit-time oracle +and responses are synthetic; no provider calls occur. The Airtable compilation +case still has no native pre-entry requirement and does not establish installed +mutation eligibility. Differential semantic evaluation, actual transport, +process faults, PostgreSQL and tighter observer freshness remain exit gates. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index ec965692d..4d84bb195 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -226,6 +226,18 @@ these declarations. The declaration alone is neither a capacity reservation nor an entry permit; runtime must durably account and grant every constituent read through the shared journal before contacting the provider. +The concrete journal encoding is `auths.gateway-attempt/9`. Each prerequisite +has a component replay key derived from the parent's logical operation key and +its compiler ordinal, a permanent one-call/maximum-response-byte allocation, +and a typed acquisition record retaining the parent's exact approval. A bounded +canonical parent transport witness proves membership; it cannot construct a +transport request. Granting a read requires a still-reserved parent under the +same fence as its allocation and current native dependencies. Final mutation +entry fences all required prerequisite records and allocations and requires +recorded, fresh responses. Receipt time is immutable, and evidence age uses the +earlier grant time conservatively. These requirements do not waive tighter +native evidence freshness or independently authorized later observation. + Independent recovery compilation uses the reserved native MCP tool `auths_gateway_recovery_read_v1`; a mutation recipe cannot claim that name. Its `auths.gateway-recovery-read/1` contract binds the retained source effect diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 13f812008..f228ec72b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 95a27343f..a95eca4a2 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index d19c941c7..12e15d649 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 897f19ade..7c643a63a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 8eb8e68f7..5ab1daa0d 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/8","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 7796c94422ad3f3d20eda90865733b49eea674e4..6db9f222382ff7cb1fe5383170bd6cf1a1041d24 100644 GIT binary patch delta 24 dcmbPkJl%ML5u@eiqdaH1HgO+e1T!!30042<2?_uJ delta 24 dcmbPkJl%ML5u?TCqdaH1HgO+e1T!!30042o2?ziH diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 6106d4befae4978391993a688b356e5e86f84352..9558a2d525fc6c9c3042ce07c68d0fa5861eb0de 100644 GIT binary patch delta 24 ccmZ2vw8&_J5u@eiqdaH1HgO+e1T$lK0CKwssQ>@~ delta 24 ccmZ2vw8&_J5u?TCqdaH1HgO+e1T$lK0CJ=VrvLx| diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 95c525cdf1baef8096c557c928155e9f407cb2f2..37aa77ef7e946a22fa203759c94189ed5ee0f22c 100644 GIT binary patch delta 25 ecmcbhb3tc<5u@eix12}VH-BgU$_QpB^8f&jgbHE+ delta 25 ecmcbhb3tc<5u?TCx12}VH-BgU$_QpB^8f&jYzkli diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index 11d469e0beb4f57f7c2f6cc8559071e1d2adc157..46774f502f1f9b2b0da3ed27d9d0b5853c2b769b 100644 GIT binary patch delta 25 ecmbQKK2v>y5u@eix17J&H|uijX9Tm?Z~_2)M+s*D delta 25 ecmbQKK2v>y5u?TCx17J&H|uijX9Tm?Z~_2)F9~G; diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 00557b33f..47e3eb928 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"eb6d7afd08be01eb0743f4e2f4ec4704407fdc568ab48c1b860b01a16b087221"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"1de29e9debdedc38f249f8063394055190d5046a533673c70ae62fbae0adf333"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fa73673bdb6f3cf0643d31734f0039887ae19253382560860b85f50b76a96e73"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"75b2b9b62725f9ef2812a75007957333f7e6888b1c461dbe518842577d1407d5"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"7448bb0a22a981f5767e607713895f4708fd3351d10806e3861f7d7831c90705"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"a9d75cdbdbc459bc3a282618e682b11dccf902a8d43caca26607aab779afadbd"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6d908687b3566c23202b5766e5e2132dfd72b4538d4c34f6b03e1a3e492bbe54"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"4d94e8cea23ef564ece2b470d09fdf89aef1e82813361a75e765e0f089d63a18"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"2b9e05c65435c91edc6594d667d07dd8664faa61499074a98422272537fd0dac"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"44b86b5b0277257b8d4c9628a977420b0c0f67cf7fd2220b413feca3aeb77b68"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"d4de299fd3e15ed174e969e34556f23eda5d6c6292e90fbf50e180e9a77fecb1"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d96aa5670b5da73ed81bafb988fcfe977615511ff2c09ac428445d59d1da2c26"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"cde0279ce6ebd736c99102554ebb726a5147ef19470fe743141fdc50cf1519c4"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ce93d41787c170874abe73d517c2e21720fc04b997650743205c5977cba9ef72"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"ce445b58b10b2384bfd50818918006b63790ef8597d291438cfcbfa3f2c57c25"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"906c45fe65bbea11421244112807753dff785e6d08f37dfd280f70346cec74bd"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"d380a949ccf22c7b4d05db9c921719e5f4b4d7a2ab2520153b531953c912e5d5"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"c435456ef257b81614cc2258cb60e84b00e49ca74d7324c56ea339f86dbd20c8"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"fad4d80dae9665f6754ffd3121a595ce70917f169b0c466b6fa50e08929e2476"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"f0d2cb3ad839636a4e381cf1beaa3001627e2278bc03ce3711cbeb6e837174ae"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"117fb3cdf6caf3ef5f0d5fd22595d5736c97625b534b179db70852813d4e1ae8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"1fa57647bade5fc4b759c3596f5de84829a6bf93243a63783dc4b45f184291eb"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"ba96306f7a10ae2d522da8584525e76efd36a8540d59c7a91df4b99aa29af15b"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"3690807ab1dee53a946a6584143bc8414aa81fc1f0ed86b8cd9b4c92ed318117"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 545c28b2f..8899e2fd2 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -21,10 +21,14 @@ use zeroize::Zeroizing; mod acquisition; mod prerequisite; pub(crate) use acquisition::{ - MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, RecoveryCapacity, RecoveryPlan, + AcquisitionCapacity, AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, }; pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; use prerequisite::Prerequisites; +pub(crate) use prerequisite::{ + ClosedPrerequisiteRead, MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS, PrerequisiteKind, + PrerequisitePlan, +}; /// Only accepted effect binding schema. Old disposable state is rejected. pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/3"; @@ -188,6 +192,36 @@ pub(crate) fn approve_driver_fixture( recipe_digest: [u8; 32], now: u64, approval: Option, +) -> Result { + approve_driver_with_plan( + command, + recipe_digest, + now, + approval, + Prerequisites::oracle_empty(), + ) +} + +#[cfg(any(test, feature = "testkit-harness"))] +pub(crate) fn approve_recipe_fixture( + command: VerifiedCommand, + recipe: &CompiledRecipe, + account: [u8; 32], + now: u64, + approval: Option, +) -> Result { + let prerequisites = Prerequisites::compile(recipe, &command, account) + .map_err(|_| not_entered("test.effect.fixture-invalid"))?; + approve_driver_with_plan(command, *recipe.digest(), now, approval, prerequisites) +} + +#[cfg(any(test, feature = "testkit-harness"))] +fn approve_driver_with_plan( + command: VerifiedCommand, + recipe_digest: [u8; 32], + now: u64, + approval: Option, + prerequisites: Prerequisites, ) -> Result { use auths_connections::{ ConnectionAlias, ConnectionId, ConnectionProfile, ConnectionState, ProviderKind, SemanticId, @@ -217,19 +251,23 @@ pub(crate) fn approve_driver_fixture( None, ) .map_err(|_| invalid())?; - let binding = store_binding_fixture( + let mut binding = store_binding_fixture( &command.request, recipe_digest, command.native_authority, &fixture_policy().map_err(|_| invalid())?, ) .map_err(|_| invalid())?; + binding.wire.protocol = Protocol::Mutation { + request: request_commitment(&command.request, &prerequisites).map_err(|_| invalid())?, + }; + binding = EffectBinding::new(binding.wire).map_err(|_| invalid())?; let effect = BoundEffect { review: serde_json::json!({"scope": "synthetic post-verification oracle; no human review claim"}), binding, command: CompiledEffect::Mutation(Box::new(VerifiedMutation { command, - prerequisites: Prerequisites::oracle_empty(), + prerequisites, })), connection, proof: Zeroizing::new(Vec::new()), @@ -1020,6 +1058,30 @@ impl ApprovedEffect { } } + pub(crate) fn prerequisite_plans(&self) -> Result, EffectBindingError> { + let CompiledEffect::Mutation(mutation) = &self.effect.command else { + return Err(EffectBindingError::Invalid); + }; + mutation + .prerequisites + .kinds() + .map(|kind| self.prerequisite(kind).map(|(plan, _)| plan)) + .collect() + } + + pub(crate) fn prerequisite( + &self, + kind: PrerequisiteKind, + ) -> Result<(PrerequisitePlan, ClosedPrerequisiteRead), EffectBindingError> { + let CompiledEffect::Mutation(mutation) = &self.effect.command else { + return Err(EffectBindingError::Invalid); + }; + let (index, read) = mutation.prerequisites.select(kind)?; + let transport = request_bytes(&mutation.command.request, &mutation.prerequisites)?; + let plan = PrerequisitePlan::new(self.effect.binding(), index, transport)?; + Ok((plan, read.clone())) + } + pub(crate) fn connection(&self) -> &ConnectionRecord { &self.effect.connection } @@ -1278,6 +1340,16 @@ fn request_commitment( request: &ClosedProviderRequest, prerequisites: &Prerequisites, ) -> Result<[u8; 32], EffectBindingError> { + commitment( + "auths.effect-transport/1", + &request_bytes(request, prerequisites)?, + ) +} + +fn request_bytes( + request: &ClosedProviderRequest, + prerequisites: &Prerequisites, +) -> Result>, EffectBindingError> { let wire = RequestWire { method: request.method().as_str(), url: request.url(), @@ -1294,8 +1366,7 @@ fn request_commitment( observation: request.observation_template(), prerequisite_acquisitions: prerequisites, }; - let bytes = canonical(&wire)?; - commitment("auths.effect-transport/1", &bytes) + canonical(&wire) } #[cfg(test)] diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index a67b0600e..5c40bea84 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -205,7 +205,46 @@ pub(crate) struct RecoveryPlan { maximum_response_bytes: u64, } -pub(crate) struct RecoveryCapacity { +/// The same acquisition journal admits independent recovery reads and the +/// enumerated prerequisites of one exact approved mutation. Their source +/// eligibility is distinct; neither variant authorizes disclosure. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde( + tag = "kind", + content = "plan", + rename_all = "kebab-case", + deny_unknown_fields +)] +pub(crate) enum AcquisitionPlan { + Recovery(RecoveryPlan), + Prerequisite(PrerequisitePlan), +} + +impl AcquisitionPlan { + pub(crate) fn source(&self) -> Result { + match self { + Self::Recovery(plan) => plan.source(), + Self::Prerequisite(plan) => plan.source(), + } + } + pub(crate) fn capacity(&self) -> Result { + match self { + Self::Recovery(plan) => plan.capacity(), + Self::Prerequisite(plan) => plan.capacity(), + } + } + pub(crate) fn validate( + &self, + binding: &EffectBinding, + ) -> Result { + match self { + Self::Recovery(plan) => plan.validate(binding), + Self::Prerequisite(plan) => plan.validate(binding), + } + } +} + +pub(crate) struct AcquisitionCapacity { pub(crate) count_key: [u8; 32], pub(crate) bytes_key: [u8; 32], pub(crate) maximum_bytes: u64, @@ -217,7 +256,7 @@ impl RecoveryPlan { EffectBinding::from_private_bytes(self.source_binding.as_bytes()) } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { let source = self.source()?; if !(1..=65_536).contains(&self.maximum_response_bytes) || !matches!(source.wire.protocol, Protocol::Mutation { .. }) @@ -230,7 +269,7 @@ impl RecoveryPlan { &canonical(&(source.id().as_bytes(), unit))?, ) }; - Ok(RecoveryCapacity { + Ok(AcquisitionCapacity { count_key: key(Unit::AcquisitionCount)?, bytes_key: key(Unit::ResponseBytes)?, maximum_bytes: self.maximum_response_bytes, @@ -241,7 +280,7 @@ impl RecoveryPlan { pub(crate) fn validate( &self, effect: &EffectBinding, - ) -> Result { + ) -> Result { let source = self.source()?; let capacity = self.capacity()?; if source.wire.namespace != effect.wire.namespace @@ -266,7 +305,7 @@ impl RecoveryPlan { } } -impl RecoveryCapacity { +impl AcquisitionCapacity { fn reservations(&self) -> Vec { let mut reservations = vec![ Reservation { diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index 0d6eb1567..582fba577 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -6,12 +6,13 @@ use super::{EffectBindingError, canonical}; use crate::engine::VerifiedCommand; use crate::{ClosedActionRead, ClosedCredentialRead, CompiledRecipe}; -use serde::{Serialize, Serializer}; +use serde::{Deserialize, Serialize, Serializer}; use serde_json::Value; /// Account, four denied-capability reads, pre-entry and relative ceiling. const MAX_PREREQUISITES: usize = 7; const MAX_RESPONSE_BYTES: usize = 65_536; +pub(crate) const MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS: u64 = 30; /// The complete ordered set for one mutation. Construction is private to the /// native compiler; an application cannot append a request or select a purpose. @@ -21,26 +22,26 @@ pub(super) struct Prerequisites(Vec); #[derive(Serialize)] struct Prerequisite { purpose: Purpose, - request: Read, + request: ClosedPrerequisiteRead, maximum_calls: u64, maximum_transport_seconds: u64, maximum_evidence_age_seconds: u64, disclosure: Disclosure, } -#[derive(Serialize)] +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] #[serde(rename_all = "kebab-case")] enum Disclosure { None, } -#[derive(Serialize)] -#[serde(tag = "kind", rename_all = "kebab-case")] +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] enum Purpose { Account { json_pointer: String, expected_account_commitment: [u8; 32], - commitment_domain: &'static str, + commitment_domain: String, }, DeniedCapability { index: u8, @@ -62,12 +63,13 @@ enum Purpose { } /// Retain the compiler's sealed read, not separately reconstructed URL data. -enum Read { +#[derive(Clone)] +pub(crate) enum ClosedPrerequisiteRead { Credential(ClosedCredentialRead), Action(ClosedActionRead), } -impl Serialize for Read { +impl Serialize for ClosedPrerequisiteRead { fn serialize(&self, serializer: S) -> Result { #[derive(Serialize)] struct Request<'a> { @@ -101,6 +103,26 @@ impl Serialize for Read { } impl Prerequisites { + pub(super) fn kinds(&self) -> impl Iterator + '_ { + self.0.iter().map(|declaration| declaration.purpose.kind()) + } + + pub(super) fn select( + &self, + kind: PrerequisiteKind, + ) -> Result<(u8, &ClosedPrerequisiteRead), EffectBindingError> { + let (index, declaration) = self + .0 + .iter() + .enumerate() + .find(|(_, declaration)| declaration.purpose.kind() == kind) + .ok_or(EffectBindingError::Invalid)?; + Ok(( + u8::try_from(index).map_err(|_| EffectBindingError::Invalid)?, + &declaration.request, + )) + } + /// Synthetic store/driver oracles have no installed recipe/connection and /// make no claim that they bind or authorize actual prerequisite reads. #[cfg(any(test, feature = "testkit-harness"))] @@ -125,9 +147,9 @@ impl Prerequisites { Purpose::Account { json_pointer, expected_account_commitment: account, - commitment_domain: "auths.gateway-account/1", + commitment_domain: "auths.gateway-account/1".to_owned(), }, - Read::Credential(read.clone()), + ClosedPrerequisiteRead::Credential(read.clone()), )?, (None, None) => {} _ => return Err(EffectBindingError::Invalid), @@ -143,7 +165,7 @@ impl Prerequisites { index: u8::try_from(index).map_err(|_| EffectBindingError::Invalid)?, refused_statuses, }, - Read::Credential(read.clone()), + ClosedPrerequisiteRead::Credential(read.clone()), )?; } } else if reads.account().is_some() || !reads.denied().is_empty() { @@ -158,7 +180,7 @@ impl Prerequisites { json_pointers: pointers.to_vec(), native_authority: command.native_authority, }, - Read::Action(read.clone()), + ClosedPrerequisiteRead::Action(read.clone()), )?, (None, None) => {} _ => return Err(EffectBindingError::Invalid), @@ -191,7 +213,7 @@ impl Prerequisites { subtract_pointer: ceiling.subtract_pointer, binds, }, - Read::Action(read.clone()), + ClosedPrerequisiteRead::Action(read.clone()), )?; } (None, None) => {} @@ -201,10 +223,14 @@ impl Prerequisites { Ok(plan) } - fn push(&mut self, purpose: Purpose, request: Read) -> Result<(), EffectBindingError> { + fn push( + &mut self, + purpose: Purpose, + request: ClosedPrerequisiteRead, + ) -> Result<(), EffectBindingError> { let maximum = match &request { - Read::Credential(read) => read.maximum_response_bytes(), - Read::Action(read) => read.maximum_response_bytes(), + ClosedPrerequisiteRead::Credential(read) => read.maximum_response_bytes(), + ClosedPrerequisiteRead::Action(read) => read.maximum_response_bytes(), }; if self.0.len() >= MAX_PREREQUISITES || !(1..=MAX_RESPONSE_BYTES).contains(&maximum) { return Err(EffectBindingError::Invalid); @@ -214,9 +240,161 @@ impl Prerequisites { request, maximum_calls: 1, maximum_transport_seconds: 15, - maximum_evidence_age_seconds: 30, + maximum_evidence_age_seconds: MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS, disclosure: Disclosure::None, }); Ok(()) } } + +/// Closed selectors address compiler-owned declarations, never caller URLs. +#[derive(Clone, Copy, Eq, PartialEq)] +pub(crate) enum PrerequisiteKind { + Account, + DeniedCapability(u8), + PreEntry, + RelativeCeiling, +} + +impl Purpose { + const fn kind(&self) -> PrerequisiteKind { + match self { + Self::Account { .. } => PrerequisiteKind::Account, + Self::DeniedCapability { index, .. } => PrerequisiteKind::DeniedCapability(*index), + Self::PreEntry { .. } => PrerequisiteKind::PreEntry, + Self::RelativeCeiling { .. } => PrerequisiteKind::RelativeCeiling, + } + } +} + +/// Private membership witness for one read in the exact approved mutation. +/// Audit decoding cannot construct the sealed request or grant transport entry. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct PrerequisitePlan { + source_binding: String, + transport_canonical: String, + index: u8, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Declaration { + purpose: Purpose, + request: RequestAudit, + maximum_calls: u64, + maximum_transport_seconds: u64, + maximum_evidence_age_seconds: u64, + disclosure: Disclosure, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct RequestAudit { + method: String, + url: String, + headers: Vec<(String, String)>, + maximum_response_bytes: u64, +} + +impl PrerequisitePlan { + pub(super) fn new( + source: &super::EffectBinding, + index: u8, + transport: zeroize::Zeroizing>, + ) -> Result { + let plan = Self { + source_binding: String::from_utf8(source.to_private_bytes()?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + transport_canonical: String::from_utf8(transport.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + index, + }; + plan.validate(source)?; + Ok(plan) + } + + pub(crate) const fn index(&self) -> u8 { + self.index + } + + pub(crate) fn source(&self) -> Result { + super::EffectBinding::from_private_bytes(self.source_binding.as_bytes()) + } + + fn declaration(&self) -> Result { + let source = self.source()?; + let super::Protocol::Mutation { request } = source.wire.protocol else { + return Err(EffectBindingError::Invalid); + }; + let bytes = self.transport_canonical.as_bytes(); + if bytes.len() > super::MAX_EFFECT_BYTES + || request != super::commitment("auths.effect-transport/1", bytes)? + { + return Err(EffectBindingError::Invalid); + } + // This bounded value is only an authenticated membership witness. It + // never supplies a URL, header or body to the transport implementation. + let witness: Value = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + if canonical(&witness)?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + let declarations = witness + .get("prerequisite_acquisitions") + .and_then(Value::as_array) + .ok_or(EffectBindingError::Invalid)?; + if declarations.len() > MAX_PREREQUISITES { + return Err(EffectBindingError::Invalid); + } + let declaration: Declaration = serde_json::from_value( + declarations + .get(usize::from(self.index)) + .ok_or(EffectBindingError::Invalid)? + .clone(), + ) + .map_err(|_| EffectBindingError::Invalid)?; + if declaration.maximum_calls != 1 + || declaration.maximum_transport_seconds != 15 + || declaration.maximum_evidence_age_seconds != MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS + || declaration.disclosure != Disclosure::None + || !matches!(declaration.request.method.as_str(), "GET" | "HEAD") + || !(1..=MAX_RESPONSE_BYTES as u64) + .contains(&declaration.request.maximum_response_bytes) + { + return Err(EffectBindingError::Invalid); + } + Ok(declaration) + } + + pub(crate) fn kind(&self) -> Result { + Ok(self.declaration()?.purpose.kind()) + } + + pub(crate) fn capacity(&self) -> Result { + let source = self.source()?; + let declaration = self.declaration()?; + let key = |unit| { + super::commitment( + "auths.prerequisite-capacity/1", + &canonical(&(source.id().as_bytes(), self.index, unit))?, + ) + }; + Ok(super::AcquisitionCapacity { + count_key: key(super::Unit::AcquisitionCount)?, + bytes_key: key(super::Unit::ResponseBytes)?, + maximum_bytes: declaration.request.maximum_response_bytes, + attempts: 1, + }) + } + + pub(crate) fn validate( + &self, + effect: &super::EffectBinding, + ) -> Result { + if self.source()? != *effect { + return Err(EffectBindingError::Invalid); + } + self.capacity() + } +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 36adbf878..0f05f037f 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -422,7 +422,9 @@ async fn exercise_recovery_journal( ) .await .expect("unique read grant"); - assert!(permit.request().url().starts_with("https://")); + assert!( + matches!(permit.request(), crate::store::AcquisitionRequest::Recovery(read) if read.url().starts_with("https://")) + ); drop(permit); drop(granted); assert!( diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 319ae5569..260058b3a 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -3,12 +3,12 @@ use super::*; -#[test] +#[tokio::test] #[allow( clippy::too_many_lines, reason = "one signed compilation corpus keeps each declaration and its witness together" )] -fn native_prerequisite_compilation_fixture_is_current() { +async fn native_prerequisite_compilation_fixture_is_current() { let corpus: Value = serde_json::from_slice(include_bytes!( "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" )) @@ -25,6 +25,7 @@ fn native_prerequisite_compilation_fixture_is_current() { let policy = EffectPolicy::new("synthetic-prerequisites".to_owned(), 1, public).expect("policy"); let mut cases = Vec::new(); + let mut journals = Vec::new(); for base in ["stripe", "airtable-pre-entry"] { let recipe = CompiledRecipe::compile( &serde_json::to_vec(&corpus["bases"][base]["recipe"]).expect("source"), @@ -188,7 +189,7 @@ fn native_prerequisite_compilation_fixture_is_current() { Err(crate::effect::EffectBindingError::Unsupported), ); let approval_request = effect - .approval_request(NOW, NOW + 30) + .approval_request(NOW, NOW + 60) .expect("approval request"); let signature = key .sign(&approval_request.signing_message().expect("message")) @@ -200,6 +201,8 @@ fn native_prerequisite_compilation_fixture_is_current() { approved .validate_for_entry(&installed, NOW + 1) .expect("same native compilation and plan"); + let approved = std::sync::Arc::new(approved); + journals.push(journal_witness(&approved, &policy, base).await); cases.push(json!({ "recipe": base, "effect_id_hex": hex::encode(approved.effect().binding().id().as_bytes()), @@ -221,4 +224,175 @@ fn native_prerequisite_compilation_fixture_is_current() { std::fs::write(&path, &fixture).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), fixture); + let journal = serde_json::to_vec_pretty(&json!({ + "schema": "auths.prerequisite-entry-fixture/1", + "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", + "attempt_schema": "auths.gateway-attempt/9", + "cases": journals, + })).expect("journal fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/prerequisite-entry.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &journal).expect("write journal fixture"); + } + assert_eq!(std::fs::read(path).expect("journal fixture"), journal); +} + +async fn journal_witness( + approved: &std::sync::Arc, + policy: &EffectPolicy, + recipe: &str, +) -> Value { + use crate::entry::EntryValidation; + use crate::{AcquisitionClaim, AcquisitionStage, GatewayAttempts}; + use std::sync::Arc; + let plans = approved.prerequisite_plans().expect("closed plans"); + let mut histories = Vec::new(); + for history in [ + "recorded-response", + "lost-permit", + "missing-read", + "stale-response", + ] { + let lose_permit = history == "lost-permit"; + let directory = tempfile::tempdir().expect("directory"); + let path = std::fs::canonicalize(directory.path()) + .expect("canonical directory") + .join("journal"); + let store = Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("journal")); + let attempts = GatewayAttempts::new(store, policy.clone()).expect("attempts"); + let crate::store::BoundedClaim::Claimed(parent) = attempts + .claim_bounded(approved, NOW) + .await + .expect("parent claim") + else { + panic!("parent reservation") + }; + let mut snapshots = Vec::new(); + for plan in plans.iter().filter(|_| history != "missing-read") { + let kind = plan.kind().expect("closed purpose"); + let capacity = plan + .validate(approved.effect().binding()) + .expect("membership"); + assert_eq!(capacity.attempts, 1); + let mut corrupted = serde_json::to_value(plan).expect("plan audit"); + corrupted["transport_canonical"] = json!("{}"); + let corrupted: crate::effect::PrerequisitePlan = + serde_json::from_value(corrupted).expect("audit only"); + assert!(corrupted.validate(approved.effect().binding()).is_err()); + let AcquisitionClaim::Reserved(reserved) = attempts + .claim_prerequisite(approved, kind, NOW) + .await + .expect("read claim") + else { + panic!("reserved") + }; + let AcquisitionClaim::Reserved(stale) = attempts + .claim_prerequisite(approved, kind, NOW) + .await + .expect("equal reservation") + else { + panic!("equal reservation") + }; + assert_eq!( + reserved.snapshot().expect("snapshot"), + stale.snapshot().expect("snapshot") + ); + let (granted, permit) = reserved + .grant_entry( + Arc::clone(approved), + EntryValidation::Oracle { now: NOW }, + NOW, + ) + .await + .expect("read grant"); + assert!(matches!( + permit.request(), + crate::store::AcquisitionRequest::Prerequisite(_) + )); + drop(permit); + assert!( + stale + .grant_entry( + Arc::clone(approved), + EntryValidation::Oracle { now: NOW }, + NOW + ) + .await + .is_err() + ); + if lose_permit { + drop(granted); + } else { + granted + .record_response(200, true, b"{}", NOW + 1) + .await + .expect("retained synthetic response"); + let response = attempts + .read_prerequisite(approved, kind, NOW + 2) + .await + .expect("fresh response"); + assert_eq!(response.received_at, NOW + 1); + assert_eq!(response.observed_at, NOW); + assert!( + attempts + .read_prerequisite(approved, kind, NOW) + .await + .is_err(), + "future response cannot be fresh" + ); + assert!( + attempts + .read_prerequisite(approved, kind, NOW + 32) + .await + .is_err() + ); + } + let reopened = GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen journal")), + policy.clone(), + ) + .expect("reopened attempts"); + let AcquisitionClaim::Existing(snapshot) = reopened + .claim_prerequisite(approved, kind, NOW + 2) + .await + .expect("replay") + else { + panic!("no second permit") + }; + assert_eq!( + snapshot.stage, + if lose_permit { + AcquisitionStage::Unknown + } else { + AcquisitionStage::ResponseRecorded + } + ); + assert_eq!(snapshot.reserved_calls, 1); + assert_eq!(snapshot.reserved_bytes, capacity.maximum_bytes); + snapshots.push(json!(snapshot)); + } + let grant = parent + .grant_entry( + Arc::clone(approved), + EntryValidation::Oracle { + now: if history == "stale-response" { + NOW + 31 + } else { + NOW + 2 + }, + }, + NOW, + &crate::GatewayPreEntry::default(), + ) + .await; + assert_eq!(grant.is_ok(), history == "recorded-response"); + drop(grant); + histories.push( + json!({ "history": history, "lost_read_permits": lose_permit, "reopened_reads": snapshots, + "second_read_grants": 0, "write_grant": history == "recorded-response", "provider_calls": 0, + "stale_evidence_refused": !lose_permit }), + ); + } + json!({ "recipe": recipe, "histories": histories }) } diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index a44eaa5ad..8f38bfdec 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -22,9 +22,8 @@ use crate::transport::{ WriteTransportOutcome, }; use crate::{ - ClosedCredentialRead, ClosedObservationRequest, ClosedProviderRequest, CompiledRecipe, - GatewayAttempts, GatewayConnectionDescriptor, GatewayEvidenceChannel, GatewayProviderEvidence, - RequestHeader, + ClosedObservationRequest, ClosedProviderRequest, CompiledRecipe, GatewayAttempts, + GatewayConnectionDescriptor, GatewayEvidenceChannel, GatewayProviderEvidence, }; use auths_connections::{ ConnectionAlias, ConnectionCredentialStore, ConnectionProfile, ConnectionRecord, @@ -1492,7 +1491,7 @@ impl GatewayEngine { .await .map_err(|_| "gateway.entry.unavailable")?; let prepared = io.prepared.get().ok_or("gateway.entry.unprepared")?; - match prepared.transport.recovery_read(permit, &lease).await { + match prepared.transport.acquire(permit, &lease).await { Some(response) => match io.clock() { Some(received_at) => { granted @@ -2022,34 +2021,13 @@ impl SubmitIo for EngineIo<'_> { } } - async fn action_read( + async fn acquire( &self, lease: &StoredSecretLease, - url: &str, - headers: &[RequestHeader], - maximum_response_bytes: usize, + permit: crate::store::AcquisitionEntryPermit, ) -> Option { let prepared = self.prepared.get()?; - LeasedTransport { - transport: &prepared.transport, - lease, - } - .action_read(url, headers, maximum_response_bytes) - .await - } - - async fn credential_read( - &self, - lease: &StoredSecretLease, - read: &ClosedCredentialRead, - ) -> Option { - let prepared = self.prepared.get()?; - LeasedTransport { - transport: &prepared.transport, - lease, - } - .credential_read(read) - .await + prepared.transport.acquire(permit, lease).await } } diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index ad0ef4bb0..3ac1b4949 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -781,7 +781,14 @@ impl SubmitIo for HarnessIo<'_> { self.proof, self.action, )?; - crate::effect::approve_driver_fixture(command, *recipe.digest(), now, self.approval.clone()) + crate::effect::approve_recipe_fixture( + command, + recipe, + self.account_commitment() + .ok_or_else(|| crate::engine::not_entered("test.account"))?, + now, + self.approval.clone(), + ) } fn revalidate( @@ -842,25 +849,12 @@ impl SubmitIo for HarnessIo<'_> { self.harness.provider.write(permit).await } - async fn action_read( - &self, - _lease: &(), - url: &str, - headers: &[RequestHeader], - maximum_response_bytes: usize, - ) -> Option { - self.harness - .provider - .action_read(url, headers, maximum_response_bytes) - .await - } - - async fn credential_read( + async fn acquire( &self, _lease: &(), - read: &ClosedCredentialRead, + permit: crate::store::AcquisitionEntryPermit, ) -> Option { - self.harness.provider.credential_read(read).await + self.harness.provider.acquire(permit).await } } diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 86dea03e7..da3336e8f 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/8"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/9"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 1b7b19eb8..fcc3680e4 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/8"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/9"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index adc9f82c3..ed347b5c3 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/8", + "store_schema": "auths.gateway-attempt/9", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 36b5612e0..a0be2eeb9 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -262,7 +262,13 @@ impl SubmitIo for TestIo<'_, P> { now: u64, recipe: &CompiledRecipe, ) -> Result { - crate::effect::approve_driver_fixture(self.verified.clone()?, *recipe.digest(), now, None) + crate::effect::approve_recipe_fixture( + self.verified.clone()?, + recipe, + self.account, + now, + None, + ) } fn revalidate( @@ -318,24 +324,12 @@ impl SubmitIo for TestIo<'_, P> { self.provider.write(permit).await } - async fn action_read( - &self, - _lease: &(), - url: &str, - headers: &[RequestHeader], - maximum_response_bytes: usize, - ) -> Option { - self.provider - .action_read(url, headers, maximum_response_bytes) - .await - } - - async fn credential_read( + async fn acquire( &self, _lease: &(), - read: &ClosedCredentialRead, + permit: crate::store::AcquisitionEntryPermit, ) -> Option { - self.provider.credential_read(read).await + self.provider.acquire(permit).await } } @@ -491,8 +485,8 @@ async fn reobserve_operator( } let observation = attempt.observation_request()?; let response = io + .provider .action_read( - &lease, observation.url(), observation.headers(), observation.maximum_response_bytes(), @@ -1492,7 +1486,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/8"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/9"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1621,7 +1615,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/8", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/9", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 94835c4e6..f7b831070 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "09e170f1cb91fba85bb2ba35d6d062e8a74b5365cf0663e696903098c5f4e9c0"; + "a0efba33c1a45d444d66aa21a5f407be9f744e811a6bb9183b523cd61ba02f73"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index b30ce72ed..764e4edea 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/8`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/9`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/8"; +const SCHEMA: &str = "auths.gateway-attempt/9"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -702,11 +702,11 @@ enum ProtocolState { } mod acquisition; -pub(crate) use acquisition::AcquisitionEntryPermit; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, }; +pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; trait JournalProtocol: Clone + Sized { fn wrap(self) -> ProtocolState; @@ -2492,6 +2492,9 @@ impl ClaimedGatewayAttempt { let mut attempt = self.attempt; let dependencies = validation.dependencies(); let counters = attempt.record.counters()?; + let prerequisites = approved + .prerequisite_plans() + .map_err(|_| GatewayAttemptError::InvalidTransition)?; let mut keys = vec![(GatewayRecordKind::Attempt, attempt.key)]; keys.extend_from_slice(&dependencies); keys.extend(counters.iter().map(|counter| match counter.kind { @@ -2507,6 +2510,11 @@ impl ClaimedGatewayAttempt { GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.counter, counter.slot)), ), })); + let counter_end = keys.len(); + keys.extend(acquisition::prerequisite_dependencies( + attempt.key, + &prerequisites, + )?); let mut committed = None; attempt.store.fenced_replace(&keys, &mut |snapshots| { if snapshots.len() != keys.len() @@ -2545,7 +2553,14 @@ impl ClaimedGatewayAttempt { .ok_or(GatewayAttemptError::InvalidTransition)? .bound .as_ref(), - &snapshots[dependency_end..], + &snapshots[dependency_end..counter_end], + now, + )?; + acquisition::validate_prerequisites( + attempt.key, + approved.effect().binding(), + &prerequisites, + &snapshots[counter_end..], now, )?; let mut next = current.clone(); @@ -2554,7 +2569,7 @@ impl ClaimedGatewayAttempt { authorization_started_at, now, pre_entry.clone(), - &snapshots[1..dependency_end], + &snapshots[1..], )?; next.state.stage = GatewayAttemptStage::EntryGranted; if !valid_transition(¤t, &next)? { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index a2bf0a8ca..01b2cdc46 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -3,7 +3,9 @@ //! the same adapter fence. No stored grant can recreate a read permit. use super::*; -use crate::effect::{RecoveryCapacity, RecoveryPlan}; +use crate::effect::{ + AcquisitionCapacity, AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, +}; mod recovery; pub(super) use recovery::RecoveryEvidenceLink; @@ -51,7 +53,7 @@ pub enum AcquisitionStage { #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub(super) struct AcquisitionState { - plan: RecoveryPlan, + plan: AcquisitionPlan, allocation: Option, phase: AcquisitionPhase, } @@ -178,7 +180,7 @@ impl JournalProtocol for AcquisitionState { } impl AcquisitionResponse { - fn body(&self, capacity: &RecoveryCapacity) -> Result, GatewayAttemptError> { + fn body(&self, capacity: &AcquisitionCapacity) -> Result, GatewayAttemptError> { if self.body_b64.len() > MAX_EVIDENCE_BYTES.div_ceil(3) * 4 { return Err(GatewayAttemptError::Corrupt); } @@ -249,7 +251,7 @@ struct Allocation { impl Allocation { fn new( - plan: &RecoveryPlan, + plan: &AcquisitionPlan, key: GatewayAttemptKey, slot: u64, ) -> Result { @@ -271,7 +273,7 @@ impl Allocation { } } -fn allocation_key(capacity: &RecoveryCapacity, slot: u64) -> GatewayAttemptKey { +fn allocation_key(capacity: &AcquisitionCapacity, slot: u64) -> GatewayAttemptKey { GatewayAttemptKey(crate::bounds::count_slot_key(&capacity.count_key, slot)) } @@ -289,7 +291,85 @@ pub struct ReservedAcquisition { source_key: GatewayAttemptKey, } +pub(crate) struct PrerequisiteResponse { + pub(crate) response: crate::transport::ProviderResponse, + pub(crate) received_at: u64, + pub(crate) observed_at: u64, +} + +impl Record { + fn prerequisite_response(&self, now: u64) -> Result { + if !matches!(self.state.plan, AcquisitionPlan::Prerequisite(_)) { + return Err(GatewayAttemptError::BindingConflict); + } + let AcquisitionPhase::ResponseRecorded { response } = &self.state.phase else { + return Err(GatewayAttemptError::InvalidTransition); + }; + // The response can describe state sampled before receipt. Use the + // grant's earlier time for evidence freshness; preserve receipt time + // separately rather than refreshing either during replay. + let observed_at = self + .entry + .as_ref() + .ok_or(GatewayAttemptError::Corrupt)? + .granted_at; + if now < response.received_at + || !now + .checked_sub(observed_at) + .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + { + return Err(GatewayAttemptError::InvalidTransition); + } + let capacity = self + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)?; + Ok(PrerequisiteResponse { + response: crate::transport::ProviderResponse { + status: response.status, + version_ok: response.version_ok, + body: response.body(&capacity)?, + }, + received_at: response.received_at, + observed_at, + }) + } +} + impl GatewayAttempts { + pub(crate) async fn read_prerequisite( + &self, + approved: &ApprovedEffect, + kind: PrerequisiteKind, + now: u64, + ) -> Result { + let (plan, _) = approved + .prerequisite(kind) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let (namespace, operation, _, _) = binding.journal_identity(); + let parent = self.key( + &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, + &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, + )?; + let key = prerequisite_key(parent, plan.index()); + let store = Arc::clone(&self.store); + let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&bytes)?; + if record.validate_header()? != *binding + || record.state.plan != AcquisitionPlan::Prerequisite(plan) + { + return Err(GatewayAttemptError::BindingConflict); + } + record.prerequisite_response(now) + } + /// Returns retained facts for this exact approved read, without any I/O /// outside the journal. A stored grant projects unknown, never a permit. /// @@ -343,9 +423,33 @@ impl GatewayAttempts { let target = approved .recovery_target() .ok_or(GatewayAttemptError::InvalidTransition)?; - let plan = target - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?; + let plan = AcquisitionPlan::Recovery( + target + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ); + self.claim_acquisition(approved, plan, evaluated_at).await + } + + pub(crate) async fn claim_prerequisite( + &self, + approved: &ApprovedEffect, + kind: PrerequisiteKind, + evaluated_at: u64, + ) -> Result { + let (plan, _) = approved + .prerequisite(kind) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + self.claim_acquisition(approved, AcquisitionPlan::Prerequisite(plan), evaluated_at) + .await + } + + async fn claim_acquisition( + &self, + approved: &ApprovedEffect, + plan: AcquisitionPlan, + evaluated_at: u64, + ) -> Result { let binding = approved.effect().binding(); let capacity = plan .validate(binding) @@ -363,6 +467,11 @@ impl GatewayAttempts { let source_operation = LogicalOperationId::parse(source.journal_identity().1) .map_err(|_| GatewayAttemptError::Corrupt)?; let source_key = self.key(&namespace, &source_operation)?; + let key = match &plan { + AcquisitionPlan::Recovery(_) => key, + AcquisitionPlan::Prerequisite(plan) => prerequisite_key(source_key, plan.index()), + }; + let expected_plan = plan.clone(); let base = Record::new( binding, approved.approval(), @@ -433,11 +542,12 @@ impl GatewayAttempts { .await? .ok_or(GatewayAttemptError::Unavailable)?; let record: Record = decode_as(&bytes)?; - if record.binding_canonical.as_bytes() - != binding - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .as_slice() + if record.state.plan != expected_plan + || record.binding_canonical.as_bytes() + != binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() { return Err(GatewayAttemptError::BindingConflict); } @@ -476,13 +586,31 @@ impl ReservedAcquisition { validation: crate::entry::EntryValidation, authorization_started_at: u64, ) -> Result<(GrantedAcquisition, AcquisitionEntryPermit), GatewayAttemptError> { - let target = approved - .recovery_target() - .ok_or(GatewayAttemptError::InvalidTransition)?; - let request = target.closed_request().clone(); - let plan = target - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?; + let (plan, request) = match &self.attempt.record.state.plan { + AcquisitionPlan::Recovery(_) => { + let target = approved + .recovery_target() + .ok_or(GatewayAttemptError::InvalidTransition)?; + ( + AcquisitionPlan::Recovery( + target + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Recovery(target.closed_request().clone()), + ) + } + AcquisitionPlan::Prerequisite(plan) => { + let kind = plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?; + let (plan, read) = approved + .prerequisite(kind) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + ( + AcquisitionPlan::Prerequisite(plan), + AcquisitionRequest::Prerequisite(read), + ) + } + }; blocking(move || { let mut attempt = self.attempt; let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; @@ -530,11 +658,23 @@ impl ReservedAcquisition { .as_deref() .ok_or(GatewayAttemptError::Corrupt)?, )?; - let source_target = source.recovery_target()?; - if source_target - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)? - != plan + let source_matches = match &plan { + AcquisitionPlan::Recovery(plan) => { + source + .recovery_target()? + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)? + == *plan + } + AcquisitionPlan::Prerequisite(plan) => { + source.state.stage == GatewayAttemptStage::Reserved + && source.entry.is_none() + && source.validate_header()? + == plan.source().map_err(|_| GatewayAttemptError::Corrupt)? + && attempt.key == prerequisite_key(self.source_key, plan.index()) + } + }; + if !source_matches || snapshots[2].as_deref() != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) { @@ -574,13 +714,18 @@ impl ReservedAcquisition { } } +pub(crate) enum AcquisitionRequest { + Recovery(ClosedObservationRequest), + Prerequisite(ClosedPrerequisiteRead), +} + pub(crate) struct AcquisitionEntryPermit { _approved: Arc, - request: ClosedObservationRequest, + request: AcquisitionRequest, } impl AcquisitionEntryPermit { - pub(crate) fn request(&self) -> &ClosedObservationRequest { + pub(crate) fn request(&self) -> &AcquisitionRequest { &self.request } } @@ -625,3 +770,62 @@ impl GrantedAcquisition { self.attempt.advance(next).await?.record.snapshot() } } + +/// Component identity deliberately excludes the effect digest: changing the +/// approval under the same logical operation and ordinal must conflict. +pub(super) fn prerequisite_key(parent: GatewayAttemptKey, index: u8) -> GatewayAttemptKey { + let mut hash = Sha256::new(); + hash.update(b"auths.gateway-prerequisite-key/1\0"); + hash.update(parent.as_bytes()); + hash.update([index]); + GatewayAttemptKey(hash.finalize().into()) +} + +/// Final mutation entry observes exactly these child records and permanent +/// allocations under the same writer fence as its authority and mutation slots. +pub(super) fn prerequisite_dependencies( + parent: GatewayAttemptKey, + plans: &[crate::effect::PrerequisitePlan], +) -> Result, GatewayAttemptError> { + let mut keys = Vec::with_capacity(plans.len() * 2); + for plan in plans { + let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; + keys.push(( + GatewayRecordKind::Attempt, + prerequisite_key(parent, plan.index()), + )); + keys.push(( + GatewayRecordKind::EffectAllocation, + allocation_key(&capacity, 0), + )); + } + Ok(keys) +} + +pub(super) fn validate_prerequisites( + parent: GatewayAttemptKey, + binding: &EffectBinding, + plans: &[crate::effect::PrerequisitePlan], + snapshots: &[Option>], + now: u64, +) -> Result<(), GatewayAttemptError> { + if snapshots.len() != plans.len() * 2 { + return Err(GatewayAttemptError::Corrupt); + } + for (plan, rows) in plans.iter().zip(snapshots.chunks_exact(2)) { + let record: Record = + decode_as(rows[0].as_deref().ok_or(GatewayAttemptError::Corrupt)?)?; + let expected = AcquisitionPlan::Prerequisite(plan.clone()); + let key = prerequisite_key(parent, plan.index()); + if record.validate_header()? != *binding + || record.state.plan != expected + || record.state.allocation != Some(0) + || rows[1].as_deref() + != Some(canonical(&Allocation::new(&expected, key, 0)?)?.as_slice()) + { + return Err(GatewayAttemptError::BindingConflict); + } + record.prerequisite_response(now)?; + } + Ok(()) +} diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index b1d6d08b3..82b3fd54b 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -288,6 +288,9 @@ impl GatewayAttempts { .load(GatewayRecordKind::Attempt, &read_key)? .ok_or(GatewayAttemptError::Unavailable)?; let read: Record = decode_as(&bytes)?; + let AcquisitionPlan::Recovery(recovery_plan) = &read.state.plan else { + return Err(GatewayAttemptError::BindingConflict); + }; let binding = read.validate_header()?; let capacity = read .state @@ -320,13 +323,13 @@ impl GatewayAttempts { .as_deref() .ok_or(GatewayAttemptError::Unavailable)?, )?; - if source.binding_canonical != read.state.plan.source_binding + if source.binding_canonical != recovery_plan.source_binding || !policy.contains(&source.validate_header()?) || source .recovery_target_data()? .journal_plan() .map_err(|_| GatewayAttemptError::Corrupt)? - != read.state.plan + != *recovery_plan { return Err(GatewayAttemptError::BindingConflict); } diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index a0260e750..f2cf5ea99 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -9,7 +9,7 @@ //! installed transport and credential store; the tests supply a counting //! provider double through the same driver. -use crate::effect::ApprovedEffect; +use crate::effect::{ApprovedEffect, PrerequisiteKind}; use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered}; use crate::pre_entry::{self, PreEntryObservation, SelectedRequirement}; use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES}; @@ -18,8 +18,8 @@ use crate::transport::{ GatewayTransportError, ProviderPort, ProviderResponse, WriteTransportOutcome, }; use crate::{ - ClaimedGatewayAttempt, ClosedCredentialRead, CompiledRecipe, GatewayAttemptError, - GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, RequestHeader, + ClaimedGatewayAttempt, CompiledRecipe, GatewayAttemptError, GatewayAttempts, GatewayObserver, + GatewayPreEntry, GatewayRelativeBasis, }; use auths_gateway_kernel::order::{ AccountResult, CeilingRead, ClaimResult, DeniedResult, PreEntryResult, Refusal, ResponseRecord, @@ -107,21 +107,11 @@ pub(crate) trait SubmitIo { permit: crate::store::ProviderEntryPermit, ) -> Result; - /// Performs one bounded GET of an action read or observation under - /// `lease`. - async fn action_read( + /// Consumes one durably acknowledged permit for an exact compiled read. + async fn acquire( &self, lease: &Self::Lease, - url: &str, - headers: &[RequestHeader], - maximum_response_bytes: usize, - ) -> Option; - - /// Performs one credential read under `lease`. - async fn credential_read( - &self, - lease: &Self::Lease, - read: &ClosedCredentialRead, + permit: crate::store::AcquisitionEntryPermit, ) -> Option; } @@ -569,47 +559,98 @@ impl Run<'_, I> { } } + async fn acquire_prerequisite( + &self, + kind: PrerequisiteKind, + ) -> Option { + let lease = self.lease.as_ref()?; + let approved = self.verified.as_ref()?; + let started = self.io.clock()?; + match self + .cx + .attempts + .claim_prerequisite(approved, kind, started) + .await + .ok()? + { + crate::AcquisitionClaim::Reserved(reserved) => { + let validation = self.io.entry_validation().ok()?; + let (granted, permit) = reserved + .grant_entry(std::sync::Arc::clone(approved), validation, started) + .await + .ok()?; + match self.io.acquire(lease, permit).await { + Some(response) => { + let received_at = self.io.clock()?; + granted + .record_response( + response.status, + response.version_ok, + &response.body, + received_at, + ) + .await + .ok()?; + } + None => { + let _ = granted.record_unknown().await; + return None; + } + } + } + crate::AcquisitionClaim::Existing(_) => {} + } + // Only acknowledged, retained evidence is usable. Replays keep the + // original receipt time and cannot create another provider invocation. + let now = self.io.clock()?; + let recorded = self + .cx + .attempts + .read_prerequisite(approved, kind, now) + .await + .ok()?; + (recorded.observed_at <= recorded.received_at && recorded.received_at <= now) + .then_some(recorded) + } + async fn read_account(&self) -> AccountResult { - let (Some(lease), Some(pointer)) = ( - &self.lease, - self.guard - .as_ref() - .and_then(|guard| guard.account_pointer.as_deref()), - ) else { - return AccountResult::Unavailable; - }; - let Ok(reads) = self.cx.recipe.credential_reads() else { - return AccountResult::Unavailable; - }; - let Some(read) = reads.account() else { + let Some(pointer) = self + .guard + .as_ref() + .and_then(|guard| guard.account_pointer.as_deref()) + else { return AccountResult::Unavailable; }; - let response = self.io.credential_read(lease, read).await; - account_result(response.as_ref(), pointer, self.io.account_commitment()) + let acquired = self.acquire_prerequisite(PrerequisiteKind::Account).await; + account_result( + acquired.as_ref().map(|acquired| &acquired.response), + pointer, + self.io.account_commitment(), + ) } async fn denied_read(&self, index: usize) -> DeniedResult { - let (Some(lease), Some(refused)) = ( - &self.lease, - self.guard - .as_ref() - .and_then(|guard| guard.denied_refused.get(index)), - ) else { - return DeniedResult::Unavailable; - }; - let Ok(reads) = self.cx.recipe.credential_reads() else { + let Some(refused) = self + .guard + .as_ref() + .and_then(|guard| guard.denied_refused.get(index)) + else { return DeniedResult::Unavailable; }; - let Some(read) = reads.denied().get(index) else { + let Ok(index) = u8::try_from(index) else { return DeniedResult::Unavailable; }; - let response = self.io.credential_read(lease, read).await; - denied_result(response.as_ref(), refused) + let acquired = self + .acquire_prerequisite(PrerequisiteKind::DeniedCapability(index)) + .await; + denied_result( + acquired.as_ref().map(|acquired| &acquired.response), + refused, + ) } async fn pre_entry_read(&mut self) -> PreEntryResult { - let (Some(lease), Some(verified), Some(observer), Some(pointers)) = ( - &self.lease, + let (Some(verified), Some(observer), Some(pointers)) = ( self.verified.as_deref().and_then(ApprovedEffect::command), self.cx.observer, self.cx.recipe.pre_entry_pointers(), @@ -619,18 +660,11 @@ impl Run<'_, I> { let Some(read) = verified.request.pre_entry_read() else { return PreEntryResult::Unavailable; }; - let Some(observed_at) = self.io.clock() else { + let Some(acquired) = self.acquire_prerequisite(PrerequisiteKind::PreEntry).await else { return PreEntryResult::Unavailable; }; - let response = self - .io - .action_read( - lease, - read.url(), - read.headers(), - read.maximum_response_bytes(), - ) - .await; + let observed_at = acquired.observed_at; + let response = Some(acquired.response); let Some(observations) = response .as_ref() .and_then(ProviderResponse::usable_body) @@ -654,28 +688,20 @@ impl Run<'_, I> { } async fn ceiling_read(&mut self) -> CeilingRead { - let (Some(lease), Some(verified), Some(ceiling)) = ( - &self.lease, + let (Some(verified), Some(ceiling)) = ( self.verified.as_deref().and_then(ApprovedEffect::command), &self.ceiling, ) else { return CeilingRead::Unavailable; }; - let Some(read) = verified.request.relative_ceiling_read() else { - return CeilingRead::Unavailable; - }; - let Some(read_at) = self.io.clock() else { + let Some(acquired) = self + .acquire_prerequisite(PrerequisiteKind::RelativeCeiling) + .await + else { return CeilingRead::Unavailable; }; - let response = self - .io - .action_read( - lease, - read.url(), - read.headers(), - read.maximum_response_bytes(), - ) - .await; + let read_at = acquired.observed_at; + let response = Some(acquired.response); let Some(body) = response.as_ref().and_then(ProviderResponse::usable_body) else { return CeilingRead::Unavailable; }; diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 2921a2d81..8db4296c6 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -82,6 +82,28 @@ impl ProviderResponse { /// is the pinned HTTPS transport holding one credential lease; tests supply a /// counting provider. No method may retry a write. pub(crate) trait ProviderPort { + /// Shared sealed acquisition path, including counting test providers. + async fn acquire( + &self, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + match permit.request() { + crate::store::AcquisitionRequest::Recovery(read) => { + self.action_read(read.url(), read.headers(), read.maximum_response_bytes()) + .await + } + crate::store::AcquisitionRequest::Prerequisite( + crate::effect::ClosedPrerequisiteRead::Action(read), + ) => { + self.action_read(read.url(), read.headers(), read.maximum_response_bytes()) + .await + } + crate::store::AcquisitionRequest::Prerequisite( + crate::effect::ClosedPrerequisiteRead::Credential(read), + ) => self.credential_read(read).await, + } + } + /// Sends one closed write after a durable claim. async fn write( &self, @@ -345,21 +367,39 @@ impl GatewayHttpTransport { /// Consumes one newly acknowledged acquisition grant and sends its exact /// native request once. No caller supplies replacement URL or byte limits. - pub(crate) async fn recovery_read( + pub(crate) async fn acquire( &self, permit: crate::store::AcquisitionEntryPermit, lease: &StoredSecretLease, ) -> Option { let secret = lease.expose(Instant::now()).ok()?; - let request = permit.request(); - self.read( - reqwest::Method::GET, - request.url(), - request.headers(), - request.maximum_response_bytes(), - secret, - ) - .await + match permit.request() { + crate::store::AcquisitionRequest::Recovery(request) => { + self.read( + reqwest::Method::GET, + request.url(), + request.headers(), + request.maximum_response_bytes(), + secret, + ) + .await + } + crate::store::AcquisitionRequest::Prerequisite( + crate::effect::ClosedPrerequisiteRead::Action(read), + ) => { + self.read( + reqwest::Method::GET, + read.url(), + read.headers(), + read.maximum_response_bytes(), + secret, + ) + .await + } + crate::store::AcquisitionRequest::Prerequisite( + crate::effect::ClosedPrerequisiteRead::Credential(read), + ) => self.credential_read(read, secret).await, + } } /// One bounded read with `secret`: the complete response of any status, From c31031ab3cd2e7cf36304bebf9a3f67fe34be73f Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 08:11:56 +0000 Subject: [PATCH 031/136] fix(gateway): validate prerequisite evidence under entry fence --- .../gateway/prerequisite-compilation.json | 70 ++-- .../gateway/prerequisite-evidence.json | 83 ++++ .../gateway/prerequisite-guard-evidence.json | 66 +++ ...017-bound-effect-and-recovery-ownership.md | 34 ++ docs/plans/0074-implementation-status.md | 36 +- .../0009-bound-effect-and-recovery.md | 19 + ...ound-effects-and-recovery-state-machine.md | 11 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/effect_native_tests.rs | 6 +- .../src/effect_prerequisite_tests.rs | 384 +++++++++++++++++- product/runtime/auths-gateway/src/engine.rs | 8 + product/runtime/auths-gateway/src/entry.rs | 159 +++++++- .../runtime/auths-gateway/src/pre_entry.rs | 43 +- product/runtime/auths-gateway/src/recipe.rs | 1 + .../auths-gateway/src/recipe/response.rs | 2 +- .../auths-gateway/src/recipe/runtime.rs | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 10 +- .../auths-gateway/src/store/acquisition.rs | 13 +- product/runtime/auths-gateway/src/submit.rs | 5 +- 20 files changed, 901 insertions(+), 55 deletions(-) create mode 100644 bindings/fixtures/gateway/prerequisite-evidence.json create mode 100644 bindings/fixtures/gateway/prerequisite-guard-evidence.json diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index bb024c3f0..5cb13f13d 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -4,9 +4,9 @@ "cases": [ { "recipe": "stripe", - "effect_id_hex": "23aedb7108ab99cce78b9d277ff6481c6d4cea7b7c1c6c9bd517dd65699205d8", - "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[26,73,19,136,248,164,84,124,124,160,26,95,131,145,254,51,149,52,226,250,193,121,47,235,25,58,236,203,68,7,156,165],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[105,123,247,191,43,181,123,82,239,98,30,109,135,125,148,61,27,139,24,89,201,103,200,246,127,233,174,153,52,236,25,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[35,174,219,113,8,171,153,204,231,139,157,39,127,246,72,28,109,76,234,123,124,28,108,155,213,23,221,101,105,146,5,216],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"G3PVyIcv8g1uAusqVNgOnwUUElXyhNrtG280JQcsrmHZXJJl8LXTHulP76epBQ_34DYTUoxeyDQcXUbE03jQAA\"}", + "effect_id_hex": "9ad8532b61afb71e84a27b4da7add7997bd37d9f8c27cbe9e20513d6909b4691", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[154,216,83,43,97,175,183,30,132,162,123,77,167,173,215,153,123,211,125,159,140,39,203,233,226,5,19,214,144,155,70,145],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"klmrSXldy6zVyiKHg42MizkQRz1Z38To_vS-QCGhpiXH49WymGAwBRLqFgyhwr7Gw_yBKHelJSLdp7Fixk0TBQ\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -16,38 +16,38 @@ "purpose": { "commitment_domain": "auths.gateway-account/1", "expected_account_commitment": [ - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4, - 4 + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 ], "json_pointer": "/id", "kind": "account" diff --git a/bindings/fixtures/gateway/prerequisite-evidence.json b/bindings/fixtures/gateway/prerequisite-evidence.json new file mode 100644 index 000000000..59f3108dc --- /dev/null +++ b/bindings/fixtures/gateway/prerequisite-evidence.json @@ -0,0 +1,83 @@ +{ + "schema": "auths.prerequisite-evidence-fixture/1", + "scope": "native signed authority and observation substitutions against the installed entry predicate; no adapter lock, process, custody or provider execution claim", + "selected_maximum_age_seconds": 2, + "acquisition_maximum_age_seconds": 30, + "cases": [ + { + "case": "exact", + "accepted": true, + "evidence_age_seconds": 1 + }, + { + "case": "age-limit", + "accepted": true, + "evidence_age_seconds": 2 + }, + { + "case": "selected-age-exceeded", + "accepted": false, + "evidence_age_seconds": 3 + }, + { + "case": "wrong-facts", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "condition-false", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "refreshed-time", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "wrong-subject", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "wrong-observer", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "signature-changed", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "missing-observation", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "extra-observation", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "duplicate-provider-member", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "wrong-status", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "wrong-version", + "accepted": false, + "evidence_age_seconds": 1 + }, + { + "case": "unrelated-ceiling-basis", + "accepted": false, + "evidence_age_seconds": 1 + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-guard-evidence.json b/bindings/fixtures/gateway/prerequisite-guard-evidence.json new file mode 100644 index 000000000..3400098e6 --- /dev/null +++ b/bindings/fixtures/gateway/prerequisite-guard-evidence.json @@ -0,0 +1,66 @@ +{ + "schema": "auths.prerequisite-guard-evidence-fixture/1", + "scope": "native signed Stripe effect and synthetic response/checkpoint substitutions against the installed entry predicate; no installed transport or adapter race claim", + "cases": [ + { + "case": "exact", + "accepted": true + }, + { + "case": "account-mismatch", + "accepted": false + }, + { + "case": "duplicate-account", + "accepted": false + }, + { + "case": "capability-excess", + "accepted": false + }, + { + "case": "denied-version", + "accepted": false + }, + { + "case": "currency-mismatch", + "accepted": false + }, + { + "case": "above-ceiling", + "accepted": false + }, + { + "case": "wrong-basis", + "accepted": false + }, + { + "case": "wrong-digest", + "accepted": false + }, + { + "case": "refreshed-basis-time", + "accepted": false + }, + { + "case": "missing-basis", + "accepted": false + }, + { + "case": "duplicate-basis", + "accepted": false + }, + { + "case": "wrong-order", + "accepted": false + }, + { + "case": "missing-read", + "accepted": false + }, + { + "case": "unrelated-observation", + "accepted": false + } + ] +} \ No newline at end of file diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index e76e96e82..a84b58994 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -479,3 +479,37 @@ ordered initial admission, all application/onboarding reads and disclosure still need completion. The file fixture uses native compilation but explicit-time oracle grants and synthetic responses; it is not provider transport, installed native entry or PostgreSQL qualification. + + +## Final prerequisite evidence validation + +The installed mutation fence now reuses the existing account, denied-capability, +relative-ceiling and selected-observation predicates on the exact retained child +responses. The acquisition validator returns typed, bounded evidence only after +checking its parent binding, plan, allocation, recorded grant and original times. +The installed entry validator runs these predicates after full native authority +validation and before publishing the mutation grant, at the same sampled time. + +For pre-entry observations, the existing canonical signature verifier checks the +pinned observer. Every signed subject, fact set and observation time must match +the exact acquired response projection and its conservative grant time. The +selected requirements are resolved again from the approved native command and +current pinned trust, then evaluated with their own maximum ages and anchor +validity. The 30-second acquisition ceiling cannot override a tighter native +requirement. No observer signing, custody or provider I/O occurs under the fence. +The existing four-observation limit and bounded canonical decoder bound this +additional signature work. The selected gateway observer identity is now included in the installed +configuration commitment as well as checked against native observer trust. + +Relative-ceiling checkpoints must match the retained response's basis, digest +and original grant time, and still satisfy the original ratio and bound values. +Extra observation or basis checkpoint data is refused when the compiled plan +has no corresponding prerequisite. Account, ceiling and pre-entry JSON now use +the same bounded duplicate-rejecting response decoder as recovery observations. + +The native predicate fixtures cover canonical signature substitution, subject, +observer, fact and timestamp mismatch, tighter age boundaries, missing/extra +observations, account mismatch, capability excess, bound currency/ratio changes, +checkpoint substitution and duplicate JSON. They use signed native effects and +synthetic provider bodies, not an installed transaction or transport. Independent +process lock-wait histories and both adapter fault/race suites remain required. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 6e86f7b75..c87b3ede4 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -599,6 +599,40 @@ closure regeneration passed after that correction (one artifact-generation test) policy bounds, disclosure/ACK, Python-owner removal, installed UI/bindings, formal/performance and final CI. No A01–A22 criterion closes at this checkpoint. +## Final prerequisite evidence checkpoint + +- Installed mutation entry now evaluates the required response purposes under + the existing writer fence after native revalidation and acquisition membership + checks. It reuses the existing account/denied, recipe ceiling/ratio and native + selected-observation predicates; no second evaluator or transport owner. +- Signed pre-entry observations must verify canonically against the pinned + observer and match the exact acquired subject, facts and original grant time. + Selected native ages and anchor validity are evaluated at the fenced time; + the acquisition's 30-second ceiling cannot relax them. The installed + configuration commitment now includes the gateway's selected observer. +- Relative-ceiling basis, response digest and time must match the retained read, + and original argument, ratio and binding checks still apply. Missing or extra + checkpoint evidence is refused. Account, ceiling and pre-entry JSON share + recovery's bounded duplicate-rejecting decoder. +- New native predicate artifacts cover 15 Airtable evidence cases and 15 Stripe + guard/checkpoint cases. They include canonical invalid signatures, changed + signer/subject/facts/time, selected-age limit/limit-plus-one, account/currency + mismatch, excess capability, altered basis/digest/time, missing/extra evidence + and duplicate JSON members. Stripe compilation now uses a known synthetic + account commitment for a genuine matching comparison in this test corpus. +- The exact prerequisite compilation/entry/guard generator, signed-observation + predicate generator and semantic-closure generator passed. The new signature + case decodes and re-encodes a canonical observation with altered signature + bytes, so it specifically exercises signature refusal. Construction caught + test-import/parser-visibility issues, corrected before generation passed. + No broad local suite or hosted CI was inspected. +- These are native signed effects and synthetic response/predicate results, not + installed lock/process/provider or PostgreSQL evidence. The test-only store + grant oracle intentionally remains separate from installed native entry. + No A01–A22 acceptance case closes. Ordered admission, remaining read routes, + replacement credentials/read bounds, disclosure/ACK and Python removal, + authenticated UI/bindings, full faults/formal/performance and CI remain open. + ## Phase gates | Phase | State | Outstanding gate | @@ -629,7 +663,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A10 | Timeout/denial/response/state-match distinction | Pending / no / no | Native projection | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | -| A13 | Lock wait and independent evidence expiries | Partial / narrow prerequisite cases / file fixture only | Lock-wait races and tighter selected observer freshness pending | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and signed-observation cases / narrow file and native predicate fixtures | Installed lock-wait, independent expiry and adapter races pending | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index a433b59ab..0db468569 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -291,3 +291,22 @@ and responses are synthetic; no provider calls occur. The Airtable compilation case still has no native pre-entry requirement and does not establish installed mutation eligibility. Differential semantic evaluation, actual transport, process faults, PostgreSQL and tighter observer freshness remain exit gates. + + +## Prerequisite evidence at entry + +The final gate does not add an alternate response evaluator: it calls the same +account/denied predicates, recipe ceiling reader, ratio kernel, signed observation +verifier, requirement selection and native freshness/condition predicates already +used by the maintained paths. Journal membership provides the response and its +original time; the installed gate checks the resulting evidence under the writer +fence. Existing synthetic store oracles explicitly omit installed authority and +remain test-only. + +`prerequisite-evidence.json` adds 15 native signed Airtable cases, including a +2-second selected freshness bound within the 30-second acquisition ceiling. +`prerequisite-guard-evidence.json` adds 15 Stripe response/checkpoint cases. The +positive Stripe input now has a known synthetic account commitment, allowing an +actual matching account check rather than an unopenable placeholder. These are +executed predicate fixtures; their scope excludes installed process/transport, +transaction lock waits, PostgreSQL and full differential qualification. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 4d84bb195..5c82c4ae1 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -238,6 +238,17 @@ recorded, fresh responses. Receipt time is immutable, and evidence age uses the earlier grant time conservatively. These requirements do not waive tighter native evidence freshness or independently authorized later observation. +Final mutation entry must also evaluate each prerequisite's actual purpose against +those retained responses. Signed pre-entry observations must have valid canonical +signatures from the pinned observer and exactly match the retained subject, +projected facts and original conservative time. Reevaluate the selected native +requirements and anchor validity at the fenced entry time. Relative-ceiling +checkpoints must preserve the response's basis, digest and time, and satisfy the +original bound values and ratio. Extraneous checkpoint evidence cannot substitute +for a missing prerequisite. The selected gateway observer identity is part of the +installed configuration commitment. All JSON prerequisite interpretations reject +duplicate members through the shared bounded response decoder. + Independent recovery compilation uses the reserved native MCP tool `auths_gateway_recovery_read_v1`; a mutation recipe cannot claim that name. Its `auths.gateway-recovery-read/1` contract binds the retained source effect diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 47e3eb928..ddd8f2e94 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"d380a949ccf22c7b4d05db9c921719e5f4b4d7a2ab2520153b531953c912e5d5"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"c435456ef257b81614cc2258cb60e84b00e49ca74d7324c56ea339f86dbd20c8"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"fad4d80dae9665f6754ffd3121a595ce70917f169b0c466b6fa50e08929e2476"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"931d37313ac3316128281d038c9cd7c407db37fd6ca414f866b03bb2c613cc00"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"06ea78ca140468bfaba17d9ab04912ad68673954c3203c98fed28272ff2a00c0"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"df2e3cc1c9b7b8aa022b6773a0d084f9f0af077583054350ef96bf87f0fd27b7"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"bd26f36d7ddff467c133fb72f4dbe5402a24c8bc34b60d185c9ef3ed2ad812ea"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"c286f0d15f974402822c0810d8e97f98411dc1c557755cc23e540d85e2bb42d9"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"f0d2cb3ad839636a4e381cf1beaa3001627e2278bc03ce3711cbeb6e837174ae"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"117fb3cdf6caf3ef5f0d5fd22595d5736c97625b534b179db70852813d4e1ae8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"1fa57647bade5fc4b759c3596f5de84829a6bf93243a63783dc4b45f184291eb"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"ba96306f7a10ae2d522da8584525e76efd36a8540d59c7a91df4b99aa29af15b"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"3690807ab1dee53a946a6584143bc8414aa81fc1f0ed86b8cd9b4c92ed318117"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"21f22262cccb12f789974516e4669a21c72b8fd630ed7c750f81f772ee8c3d42"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"1f06014ffd5307f17fbd841d6b03e6e96ea253e0a5b501d83f64a927dd052938"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"90c9f047cda366cb2c905f2ebb424770b0a4c273b9bde17ae518c214001ad959"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"f0d2cb3ad839636a4e381cf1beaa3001627e2278bc03ce3711cbeb6e837174ae"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d3cda2003b56dcebfb2664183b86ea7b70c08f3d1d4c44e6dd02fc14292b8a2c"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"928b6cab20bf48cbc8b3c856eeeb3fa2d5730c418d61984a7ff8e4b3fcc6b258"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"5eb6cdba2fa1034aa9a61c0ac79dc3619e382cba90c77341d4b3f6f6abf6078e"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"3690807ab1dee53a946a6584143bc8414aa81fc1f0ed86b8cd9b4c92ed318117"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 0f05f037f..ef42d3883 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -819,6 +819,10 @@ async fn exercise_recovery_refinement( } fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { + connection_account(recipe, [4; 32]) +} + +fn connection_account(recipe: &CompiledRecipe, account: [u8; 32]) -> ConnectionRecord { ConnectionRecord::new( ProviderKind::parse("airtable").expect("provider"), ConnectionAlias::parse("synthetic").expect("alias"), @@ -829,7 +833,7 @@ fn connection(recipe: &CompiledRecipe) -> ConnectionRecord { .expect("descriptor") .to_bytes() .expect("descriptor bytes"), - [4; 32], + account, [5; 32], std::num::NonZeroU64::MIN, ConnectionState::Active, diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 260058b3a..e393682d0 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -44,7 +44,14 @@ async fn native_prerequisite_compilation_fixture_is_current() { let call = McpToolCall::new(recipe.review().service(), recipe.review().tool(), arguments) .expect("call"); let context = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("trust"); - let connection = connection(&recipe); + let connection = if base == "stripe" { + connection_account( + &recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ) + } else { + connection(&recipe) + }; let grant = if base == "stripe" { let bound = crate::ArgumentCeilingPolicy::new("amount", 1_000, 3_600, 10) .expect("bound") @@ -203,6 +210,9 @@ async fn native_prerequisite_compilation_fixture_is_current() { .expect("same native compilation and plan"); let approved = std::sync::Arc::new(approved); journals.push(journal_witness(&approved, &policy, base).await); + if base == "stripe" { + guard_evidence_fixture(&approved, &installed); + } cases.push(json!({ "recipe": base, "effect_id_hex": hex::encode(approved.effect().binding().id().as_bytes()), @@ -396,3 +406,375 @@ async fn journal_witness( } json!({ "recipe": recipe, "histories": histories }) } + +/// Exercises the exact evidence predicate called inside the installed writer +/// fence, using native signed authority and signed observations. This corpus +/// does not claim an installed adapter race or provider transport execution. +#[test] +#[allow( + clippy::too_many_lines, + reason = "one signed evidence corpus retains its substitutions together" +)] +fn native_prerequisite_evidence_fixture_is_current() { + use crate::effect::PrerequisiteKind; + use crate::store::PrerequisiteResponse; + use crate::transport::ProviderResponse; + let corpus: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" + )) + .expect("recipes"); + let scenarios: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/attempt-scenarios-v3.json" + )) + .expect("scenarios"); + let recipe = CompiledRecipe::compile( + &serde_json::to_vec(&corpus["bases"]["airtable-pre-entry"]["recipe"]).expect("recipe"), + &serde_json::to_vec(&corpus["bases"]["airtable-pre-entry"]["lock"]).expect("lock"), + ) + .expect("compiled"); + let root = signer(h::ROOT_SEED); + let agent = signer(0x22); + let observer = crate::GatewayObserver::from_test_seed(h::OBSERVER_SEED); + let mut arguments = scenarios["defaults"]["airtable-pre-entry"]["arguments"] + .as_object() + .expect("arguments") + .clone(); + arguments.insert( + "operator_namespace".to_owned(), + json!(recipe.namespace().as_str()), + ); + arguments.insert("recipe_digest".to_owned(), json!(recipe.digest_hex())); + let call = McpToolCall::new(recipe.service(), recipe.review().tool(), arguments.clone()) + .expect("call"); + let context = h::context_for_tool(&root, observer.principal(), NOW, &call).expect("trust"); + let original = read_back_requirement(); + let requirement = ObservationRequirement::new( + original.observer_anchor().clone(), + original.schema().clone(), + original.subject().clone(), + 2, + original.conditions().to_vec(), + ) + .expect("two second requirement"); + let grant = h::grant_for_tool( + &root, + &agent.principal, + Some(requirement), + window(NOW - 3_600, NOW + 3_600), + &call, + ) + .expect("grant"); + let subject = arguments["record_uri"].as_str().expect("subject"); + let expected = arguments["expected"].clone(); + let initial = observer + .sign( + READ_BACK_SCHEMA, + subject, + NOW, + crate::observer::read_back_facts(&expected, None).expect("facts"), + ) + .expect("authority evidence"); + let submission = submission_for_call(&root, &agent, &grant, &call, &[initial.bytes().to_vec()]); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = EffectPolicy::new("prerequisite-evidence".to_owned(), 1, public).expect("policy"); + let connection = connection(&recipe); + let installed = policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) + .expect("native effect"); + let signing = effect.approval_request(NOW, NOW + 60).expect("approval"); + let signature = key + .sign(&signing.signing_message().expect("message")) + .to_bytes(); + let approved = effect + .approve(signing.with_signature(signature), &public, NOW) + .expect("approved"); + let read = approved + .command() + .expect("command") + .request + .pre_entry_read() + .expect("pre-entry read"); + let pointers = recipe.pre_entry_pointers().expect("pointers"); + let body = serde_json::to_vec(&json!({"fields": {"DemoStatus": expected}})).expect("body"); + let sign = |body: &[u8], at| { + crate::pre_entry::sign_observations(&observer, read, pointers, body, at) + .expect("signed response") + .into_iter() + .map(|value| value.bytes) + .collect::>() + }; + let exact = crate::GatewayPreEntry { + observations: sign(&body, NOW), + basis: None, + }; + let mut cases = Vec::new(); + for case in [ + "exact", + "age-limit", + "selected-age-exceeded", + "wrong-facts", + "condition-false", + "refreshed-time", + "wrong-subject", + "wrong-observer", + "signature-changed", + "missing-observation", + "extra-observation", + "duplicate-provider-member", + "wrong-status", + "wrong-version", + "unrelated-ceiling-basis", + ] { + let mut checkpoint = exact.clone(); + let mut response = ProviderResponse { + status: 200, + version_ok: true, + body: body.clone(), + }; + let mut at = NOW + 1; + match case { + "age-limit" => at = NOW + 2, + "selected-age-exceeded" => at = NOW + 3, + "wrong-facts" | "condition-false" => { + let other = if expected == "Pending" { + "Approved" + } else { + "Pending" + }; + response.body = serde_json::to_vec(&json!({"fields": {"DemoStatus": other}})) + .expect("other body"); + if case == "condition-false" { + checkpoint.observations = sign(&response.body, NOW); + } + } + "refreshed-time" => checkpoint.observations = sign(&body, NOW + 1), + "wrong-subject" => { + checkpoint.observations = vec![ + observer + .sign( + READ_BACK_SCHEMA, + "https://api.airtable.com/unrelated#field", + NOW, + crate::observer::read_back_facts(&expected, None).expect("facts"), + ) + .expect("wrong subject signature") + .bytes() + .to_vec(), + ] + } + "wrong-observer" => { + checkpoint.observations = vec![ + crate::GatewayObserver::from_test_seed(77) + .sign( + READ_BACK_SCHEMA, + subject, + NOW, + crate::observer::read_back_facts(&expected, None).expect("facts"), + ) + .expect("other signature") + .bytes() + .to_vec(), + ] + } + "signature-changed" => { + let signed = auths_codec::decode_signed_observation( + &checkpoint.observations[0], + &VerifierLimits::default(), + ) + .expect("canonical signature input"); + let mut bytes = signed.signature().signature().as_slice().to_vec(); + bytes[0] ^= 1; + let substituted = SignedObservation::new( + signed.statement().clone(), + SignatureEnvelope::new( + signed.signature().descriptor().clone(), + auths_model::SignatureBytes::new(bytes).expect("signature bytes"), + ), + signed.evidence().to_vec(), + ) + .expect("substituted signature"); + checkpoint.observations[0] = auths_codec::encode_signed_observation(&substituted) + .expect("canonical invalid signature"); + } + "missing-observation" => checkpoint.observations.clear(), + "extra-observation" => checkpoint + .observations + .push(checkpoint.observations[0].clone()), + "duplicate-provider-member" => { + response.body = + br#"{"fields":{"DemoStatus":"Pending","DemoStatus":"Approved"}}"#.to_vec() + } + "wrong-status" => response.status = 403, + "wrong-version" => response.version_ok = false, + "unrelated-ceiling-basis" => { + checkpoint.basis = Some(crate::GatewayRelativeBasis { + value: 1, + response_digest: [0; 32], + read_at: NOW, + }) + } + _ => {} + } + let acquired = [PrerequisiteResponse { + kind: PrerequisiteKind::PreEntry, + response, + observed_at: NOW, + received_at: NOW + 1, + }]; + let accepted = crate::entry::validate_prerequisite_evidence( + &approved, + &installed, + Some(observer.principal()), + &checkpoint, + &acquired, + at, + ) + .is_ok(); + assert_eq!(accepted, matches!(case, "exact" | "age-limit"), "{case}"); + cases.push(json!({"case": case, "accepted": accepted, "evidence_age_seconds": at - NOW})); + } + let bytes = serde_json::to_vec_pretty(&json!({ + "schema": "auths.prerequisite-evidence-fixture/1", + "scope": "native signed authority and observation substitutions against the installed entry predicate; no adapter lock, process, custody or provider execution claim", + "selected_maximum_age_seconds": 2, + "acquisition_maximum_age_seconds": 30, + "cases": cases, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/prerequisite-evidence.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} + +#[allow( + clippy::too_many_lines, + reason = "one native guard corpus retains exact response and checkpoint substitutions" +)] +fn guard_evidence_fixture( + approved: &crate::effect::ApprovedEffect, + installed: &EffectInstallation<'_>, +) { + use crate::effect::PrerequisiteKind; + use crate::store::PrerequisiteResponse; + use crate::transport::ProviderResponse; + use sha2::{Digest as _, Sha256}; + let mut cases = Vec::new(); + for case in [ + "exact", + "account-mismatch", + "duplicate-account", + "capability-excess", + "denied-version", + "currency-mismatch", + "above-ceiling", + "wrong-basis", + "wrong-digest", + "refreshed-basis-time", + "missing-basis", + "duplicate-basis", + "wrong-order", + "missing-read", + "unrelated-observation", + ] { + let mut acquired = approved + .prerequisite_plans() + .expect("plans") + .iter() + .map(|plan| { + let kind = plan.kind().expect("kind"); + let (status, body) = match kind { + PrerequisiteKind::Account => (200, br#"{"id":"acct_TESTACCOUNT01"}"#.to_vec()), + PrerequisiteKind::DeniedCapability(_) => (403, Vec::new()), + PrerequisiteKind::RelativeCeiling => ( + 200, + br#"{"amount_received":1000,"currency":"usd"}"#.to_vec(), + ), + _ => panic!("Stripe prerequisite"), + }; + PrerequisiteResponse { + kind, + response: ProviderResponse { + status, + version_ok: true, + body, + }, + observed_at: NOW, + received_at: NOW + 1, + } + }) + .collect::>(); + assert_eq!(acquired.len(), 4); + let digest = Sha256::digest(&acquired[3].response.body).into(); + let mut checkpoint = crate::GatewayPreEntry { + observations: Vec::new(), + basis: Some(crate::GatewayRelativeBasis { + value: 1000, + response_digest: digest, + read_at: NOW, + }), + }; + match case { + "account-mismatch" => acquired[0].response.body = br#"{"id":"acct_WRONG"}"#.to_vec(), + "duplicate-account" => { + acquired[0].response.body = + br#"{"id":"acct_WRONG","id":"acct_TESTACCOUNT01"}"#.to_vec() + } + "capability-excess" => acquired[1].response.status = 200, + "denied-version" => acquired[2].response.version_ok = false, + "currency-mismatch" => { + acquired[3].response.body = br#"{"amount_received":1000,"currency":"eur"}"#.to_vec() + } + "above-ceiling" => { + acquired[3].response.body = br#"{"amount_received":900,"currency":"usd"}"#.to_vec(); + let basis = checkpoint.basis.as_mut().expect("basis"); + basis.value = 900; + basis.response_digest = Sha256::digest(&acquired[3].response.body).into(); + } + "wrong-basis" => checkpoint.basis.as_mut().expect("basis").value = 2000, + "wrong-digest" => checkpoint.basis.as_mut().expect("basis").response_digest = [1; 32], + "refreshed-basis-time" => checkpoint.basis.as_mut().expect("basis").read_at = NOW + 1, + "missing-basis" => checkpoint.basis = None, + "duplicate-basis" => { + acquired[3].response.body = + br#"{"amount_received":0,"amount_received":1000,"currency":"usd"}"#.to_vec() + } + "wrong-order" => acquired.swap(0, 1), + "missing-read" => { + acquired.pop(); + } + "unrelated-observation" => checkpoint.observations.push(vec![0]), + _ => {} + } + let accepted = crate::entry::validate_prerequisite_evidence( + approved, + installed, + None, + &checkpoint, + &acquired, + NOW + 1, + ) + .is_ok(); + assert_eq!(accepted, case == "exact", "{case}"); + cases.push(json!({"case": case, "accepted": accepted})); + } + let bytes = serde_json::to_vec_pretty(&json!({ + "schema": "auths.prerequisite-guard-evidence-fixture/1", + "scope": "native signed Stripe effect and synthetic response/checkpoint substitutions against the installed entry predicate; no installed transport or adapter race claim", + "cases": cases, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/prerequisite-guard-evidence.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 8f38bfdec..5eb54256e 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -479,6 +479,9 @@ impl GatewayEngine { self.profile.version(), self.qualification.contract_digest()?, crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, + self.observer + .as_ref() + .map(|observer| observer.principal().as_str()), ), )?; let key = self @@ -1810,6 +1813,11 @@ impl SubmitIo for EngineIo<'_> { crate::entry::InstalledEntry { recipe: self.engine.recipe.clone(), trust: self.engine.trusted_context.clone(), + observer: self + .engine + .observer + .as_ref() + .map(|observer| observer.principal().clone()), policy: self.engine.effect_policy.clone(), configuration: self.engine.shared_configuration()?, connection: prepared.loaded.clone(), diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index 165049753..014b4aee0 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -6,7 +6,7 @@ use crate::configuration::SharedConfiguration; use crate::effect::{ApprovedEffect, EffectPolicy}; use crate::{CompiledRecipe, GatewayAttemptKey, GatewayRecordKind, LoadedConnection}; use auths_connections::ConnectionProfile; -use auths_model::TrustedContext; +use auths_model::{PrincipalId, TrustedContext}; use std::{ sync::Arc, time::{Duration, Instant}, @@ -15,6 +15,7 @@ use std::{ pub(crate) struct InstalledEntry { pub(crate) recipe: CompiledRecipe, pub(crate) trust: TrustedContext, + pub(crate) observer: Option, pub(crate) policy: EffectPolicy, pub(crate) configuration: SharedConfiguration, pub(crate) connection: LoadedConnection, @@ -37,6 +38,35 @@ pub(crate) enum EntryValidation { } impl EntryValidation { + /// Runs only after exact native authority and acquisition membership have + /// been validated under the same fence. No signing, custody or provider I/O. + pub(crate) fn validate_prerequisite_evidence( + &self, + approved: &ApprovedEffect, + pre_entry: &crate::GatewayPreEntry, + acquired: &[crate::store::PrerequisiteResponse], + now: u64, + ) -> Result<(), &'static str> { + match self { + Self::Installed(entry) => validate_prerequisite_evidence( + approved, + &entry.policy.installation( + &entry.recipe, + &entry.trust, + entry.connection.record(), + entry.qualification.policy(), + entry.configuration.candidate(), + ), + entry.observer.as_ref(), + pre_entry, + acquired, + now, + ), + #[cfg(any(test, feature = "testkit-harness"))] + Self::Oracle { .. } => Ok(()), + } + } + pub(crate) fn dependencies(&self) -> Vec<(GatewayRecordKind, GatewayAttemptKey)> { match self { Self::Installed(entry) => { @@ -144,3 +174,130 @@ impl EntryValidation { } } } + +/// Reuses the recipe's existing response predicates and native selected +/// observation requirements. Inputs are bounded, retained acquisition evidence; +/// callers cannot replace them with a newly fetched or re-timestamped response. +#[allow( + clippy::too_many_lines, + reason = "closed prerequisite alternatives preserve distinct existing predicates at one entry gate" +)] +pub(crate) fn validate_prerequisite_evidence( + approved: &ApprovedEffect, + installed: &crate::effect::EffectInstallation<'_>, + observer: Option<&PrincipalId>, + pre_entry: &crate::GatewayPreEntry, + acquired: &[crate::store::PrerequisiteResponse], + now: u64, +) -> Result<(), &'static str> { + use crate::effect::PrerequisiteKind; + use auths_gateway_kernel::order::{AccountResult, DeniedResult, PreEntryResult}; + use sha2::{Digest as _, Sha256}; + let invalid = "gateway.entry.prerequisite-evidence"; + let command = approved.command().ok_or(invalid)?; + let plans = approved.prerequisite_plans().map_err(|_| invalid)?; + if acquired.len() != plans.len() { + return Err(invalid); + } + let mut saw_observations = false; + let mut saw_basis = false; + for (plan, evidence) in plans.iter().zip(acquired) { + if plan.kind().map_err(|_| invalid)? != evidence.kind + || evidence.observed_at > evidence.received_at + || evidence.received_at > now + || !now + .checked_sub(evidence.observed_at) + .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + { + return Err(invalid); + } + match evidence.kind { + PrerequisiteKind::Account => { + let guard = installed.recipe.guard_checks().ok_or(invalid)?; + let pointer = guard.account_pointer.as_deref().ok_or(invalid)?; + if crate::submit::account_result( + Some(&evidence.response), + pointer, + Some(*installed.connection.account_commitment()), + ) != AccountResult::Equal + { + return Err(invalid); + } + } + PrerequisiteKind::DeniedCapability(index) => { + let guard = installed.recipe.guard_checks().ok_or(invalid)?; + let refused = guard + .denied_refused + .get(usize::from(index)) + .ok_or(invalid)?; + if crate::submit::denied_result(Some(&evidence.response), refused) + != DeniedResult::Refused + { + return Err(invalid); + } + } + PrerequisiteKind::PreEntry => { + let observer = observer.ok_or(invalid)?; + let read = command.request.pre_entry_read().ok_or(invalid)?; + let pointers = installed.recipe.pre_entry_pointers().ok_or(invalid)?; + let selected = crate::pre_entry::select( + &command.requirements, + &command.canonical_action, + installed.context, + Some(observer), + read, + pointers, + |namespace, subject| { + crate::engine::resource_covers(installed.context, namespace, subject) + }, + ) + .map_err(|_| invalid)?; + let observations = crate::pre_entry::verify_recorded( + observer, + read, + pointers, + evidence.response.usable_body().ok_or(invalid)?, + evidence.observed_at, + &pre_entry.observations, + ) + .ok_or(invalid)?; + if crate::pre_entry::evaluate(&selected, &observations, now) + != PreEntryResult::Satisfied + { + return Err(invalid); + } + saw_observations = true; + } + PrerequisiteKind::RelativeCeiling => { + let ceiling = installed.recipe.ceiling_check().ok_or(invalid)?; + let body = evidence.response.usable_body().ok_or(invalid)?; + let argument = ceiling.argument_value(&command.arguments).ok_or(invalid)?; + let crate::recipe::CeilingReading::Read { + basis, + binds_equal: true, + } = ceiling.read(body, &command.arguments) + else { + return Err(invalid); + }; + let retained = pre_entry.basis.as_ref().ok_or(invalid)?; + if !auths_gateway_kernel::ratio::relative_ceiling_admits( + argument, + basis, + ceiling.basis_points, + ) || retained.value != basis + || retained.response_digest != <[u8; 32]>::from(Sha256::digest(body)) + || retained.read_at != evidence.observed_at + { + return Err(invalid); + } + saw_basis = true; + } + } + } + if saw_observations == pre_entry.observations.is_empty() + || saw_basis != pre_entry.basis.is_some() + { + return Err(invalid); + } + Ok(()) +} diff --git a/product/runtime/auths-gateway/src/pre_entry.rs b/product/runtime/auths-gateway/src/pre_entry.rs index d1d3de024..7ac02ad6a 100644 --- a/product/runtime/auths-gateway/src/pre_entry.rs +++ b/product/runtime/auths-gateway/src/pre_entry.rs @@ -20,7 +20,6 @@ use auths_model::{ }; use auths_ports::ProfilePolicy as _; use auths_profile_mcp::McpArgumentsPolicy; -use serde_json::Value; /// One selected requirement, resolved against the verified action. #[derive(Clone, Debug)] @@ -152,7 +151,7 @@ pub(crate) fn sign_observations( if body.len() > read.maximum_response_bytes() { return None; } - let document: Value = serde_json::from_slice(body).ok()?; + let document = crate::recipe::parse_provider_response(body)?; pointers .iter() .map(|pointer| { @@ -223,3 +222,43 @@ pub(crate) fn evaluate( PreEntryResult::Unavailable } } + +/// Verifies the retained signatures and ties every fact to the exact acquired +/// response and original conservative observation time. No key access or I/O. +pub(crate) fn verify_recorded( + observer: &PrincipalId, + read: &ClosedActionRead, + pointers: &[String], + body: &[u8], + observed_at: u64, + encoded: &[Vec], +) -> Option> { + if body.len() > read.maximum_response_bytes() || pointers.len() != encoded.len() { + return None; + } + let document = crate::recipe::parse_provider_response(body)?; + pointers + .iter() + .zip(encoded) + .map(|(pointer, bytes)| { + let signed = crate::observer::verify_signed(bytes, observer, READ_BACK_SCHEMA)?; + let statement = signed.statement(); + let facts = + ObservationFacts::new(read_back_facts(document.pointer(pointer)?, None).ok()?) + .ok()?; + let subject = read.subject(pointer); + if statement.subject().as_str() != subject + || statement.observed_at().get() != observed_at + || statement.facts() != &facts + { + return None; + } + Some(PreEntryObservation { + subject, + observed_at, + facts, + bytes: bytes.clone(), + }) + }) + .collect() +} diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index a7e319427..6a8ea3a05 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -23,6 +23,7 @@ pub use auths_gateway_kernel::{construct, recovery}; mod effect_review; mod lower; mod response; +pub(crate) use response::parse as parse_provider_response; mod review; #[cfg(any(test, feature = "testkit-harness"))] pub(crate) use effect_review::synthetic_review; diff --git a/product/runtime/auths-gateway/src/recipe/response.rs b/product/runtime/auths-gateway/src/recipe/response.rs index c18c65be3..c346a4d7f 100644 --- a/product/runtime/auths-gateway/src/recipe/response.rs +++ b/product/runtime/auths-gateway/src/recipe/response.rs @@ -74,7 +74,7 @@ impl<'de> Visitor<'de> for UniqueVisitor { } } -pub(super) fn parse(bytes: &[u8]) -> Option { +pub(crate) fn parse(bytes: &[u8]) -> Option { if bytes.len() > 65_536 { return None; } diff --git a/product/runtime/auths-gateway/src/recipe/runtime.rs b/product/runtime/auths-gateway/src/recipe/runtime.rs index d9e1287ad..c11873e70 100644 --- a/product/runtime/auths-gateway/src/recipe/runtime.rs +++ b/product/runtime/auths-gateway/src/recipe/runtime.rs @@ -77,7 +77,7 @@ pub(crate) enum CeilingReading { impl CeilingCheck { /// Reads the basis and binds from a complete 2xx JSON response body. pub(crate) fn read(&self, body: &[u8], arguments: &Map) -> CeilingReading { - let Ok(document) = serde_json::from_slice::(body) else { + let Some(document) = super::parse_provider_response(body) else { return CeilingReading::Unavailable; }; let Some(value) = json_integer(&document, &self.json_pointer) else { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index f7b831070..ba0ba2fe6 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "a0efba33c1a45d444d66aa21a5f407be9f744e811a6bb9183b523cd61ba02f73"; + "5d81fddb0a06139dfca50d741115852e4c6796d8f680b59c497ae3af75f4fdfb"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 764e4edea..58d90bdb1 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2556,13 +2556,21 @@ impl ClaimedGatewayAttempt { &snapshots[dependency_end..counter_end], now, )?; - acquisition::validate_prerequisites( + let acquired = acquisition::validate_prerequisites( attempt.key, approved.effect().binding(), &prerequisites, &snapshots[counter_end..], now, )?; + let evidence = pre_entry + .as_ref() + .map(PreEntryWire::decode) + .transpose()? + .unwrap_or_default(); + validation + .validate_prerequisite_evidence(&approved, &evidence, &acquired, now) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; let mut next = current.clone(); next.record_grant( &approved, diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 01b2cdc46..d5f71b8a6 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -292,6 +292,7 @@ pub struct ReservedAcquisition { } pub(crate) struct PrerequisiteResponse { + pub(crate) kind: PrerequisiteKind, pub(crate) response: crate::transport::ProviderResponse, pub(crate) received_at: u64, pub(crate) observed_at: u64, @@ -299,9 +300,9 @@ pub(crate) struct PrerequisiteResponse { impl Record { fn prerequisite_response(&self, now: u64) -> Result { - if !matches!(self.state.plan, AcquisitionPlan::Prerequisite(_)) { + let AcquisitionPlan::Prerequisite(plan) = &self.state.plan else { return Err(GatewayAttemptError::BindingConflict); - } + }; let AcquisitionPhase::ResponseRecorded { response } = &self.state.phase else { return Err(GatewayAttemptError::InvalidTransition); }; @@ -326,6 +327,7 @@ impl Record { .capacity() .map_err(|_| GatewayAttemptError::Corrupt)?; Ok(PrerequisiteResponse { + kind: plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?, response: crate::transport::ProviderResponse { status: response.status, version_ok: response.version_ok, @@ -808,10 +810,11 @@ pub(super) fn validate_prerequisites( plans: &[crate::effect::PrerequisitePlan], snapshots: &[Option>], now: u64, -) -> Result<(), GatewayAttemptError> { +) -> Result, GatewayAttemptError> { if snapshots.len() != plans.len() * 2 { return Err(GatewayAttemptError::Corrupt); } + let mut evidence = Vec::with_capacity(plans.len()); for (plan, rows) in plans.iter().zip(snapshots.chunks_exact(2)) { let record: Record = decode_as(rows[0].as_deref().ok_or(GatewayAttemptError::Corrupt)?)?; @@ -825,7 +828,7 @@ pub(super) fn validate_prerequisites( { return Err(GatewayAttemptError::BindingConflict); } - record.prerequisite_response(now)?; + evidence.push(record.prerequisite_response(now)?); } - Ok(()) + Ok(evidence) } diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index f2cf5ea99..9f8ce4f89 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -174,10 +174,7 @@ pub(crate) fn account_commitment(label: &str) -> [u8; 32] { /// names at `pointer`: a JSON string of 1–256 bytes. pub(crate) fn account_label(response: Option<&ProviderResponse>, pointer: &str) -> Option { let body = response?.usable_body()?; - match serde_json::from_slice::(body) - .ok()? - .pointer(pointer)? - { + match crate::recipe::parse_provider_response(body)?.pointer(pointer)? { Value::String(label) if !label.is_empty() && label.len() <= MAX_ACCOUNT_BYTES => { Some(label.clone()) } From e6e29bb317012944d02ee02a8db1351d1a2775f1 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 08:43:00 +0000 Subject: [PATCH 032/136] fix(gateway): fence initial admission and capacity charges --- .../fixtures/gateway/effect-admission.json | 29 ++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 43 +++ docs/plans/0074-implementation-status.md | 42 ++- .../0009-bound-effect-and-recovery.md | 18 + ...ound-effects-and-recovery-state-machine.md | 17 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/effect_native_tests.rs | 78 +++- .../src/effect_prerequisite_tests.rs | 27 +- product/runtime/auths-gateway/src/engine.rs | 66 ++-- .../runtime/auths-gateway/src/entry_tests.rs | 351 +++++++++++++++++- .../auths-gateway/src/property_tests.rs | 2 +- .../runtime/auths-gateway/src/recipe/tests.rs | 6 +- .../auths-gateway/src/scenario_tests.rs | 59 ++- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 306 +++++++++++++-- .../auths-gateway/src/store/acquisition.rs | 170 ++++++--- product/runtime/auths-gateway/src/submit.rs | 16 +- .../runtime/auths-gateway/src/transport.rs | 6 +- .../auths-stores/src/gateway_attempt.rs | 140 +++++-- 20 files changed, 1225 insertions(+), 157 deletions(-) create mode 100644 bindings/fixtures/gateway/effect-admission.json diff --git a/bindings/fixtures/gateway/effect-admission.json b/bindings/fixtures/gateway/effect-admission.json new file mode 100644 index 000000000..6d27a7fa6 --- /dev/null +++ b/bindings/fixtures/gateway/effect-admission.json @@ -0,0 +1,29 @@ +{ + "schema": "auths.effect-admission-fixture/1", + "scope": "file adapter and explicit-time approval oracle; no installed authority or transport claim", + "mechanism": { + "dependency_refusal_atomic": true, + "missing_dependency_refused": true, + "first_record_stamped": true, + "allocation_unchanged": true, + "replay_skips_decision": true, + "capacity_collision_atomic": true, + "overlapping_set_refused": true + }, + "dependency_order": { + "writer_commits_before_admission_decision": true, + "decision_observes_changed_dependency": true, + "refusal_leaves_no_claim_or_charge": true + }, + "history": { + "backend": "file", + "authorization_started_at": 1790000000, + "admitted_at": 1790000002, + "capacity_records": 2, + "expired_admission_persists_nothing": true, + "reopen_preserves_bytes": true, + "expired_entry_refused": true, + "charges_retained": true, + "provider_calls": 0 + } +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index cb903e32b..b4eb5cf6e 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1631,6 +1631,8 @@ effect-review = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", ] effect-entry = [ + "product/runtime/auths-gateway/src/entry_tests.rs#native_admission_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_admission_checks_authority_before_atomic_charges", "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", "product/runtime/auths-gateway/src/entry_tests.rs#postgres_grant_has_one_winner_and_no_restart_permit", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index a84b58994..6e804f869 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -513,3 +513,46 @@ observations, account mismatch, capability excess, bound currency/ratio changes, checkpoint substitution and duplicate JSON. They use signed native effects and synthetic provider bodies, not an installed transaction or transport. Independent process lock-wait histories and both adapter fault/race suites remain required. + +## Ordered initial admission design + +Initial effect admission uses an extension of the existing insert-once batch +mechanism. Under the same file lock or PostgreSQL advisory transaction lock, +the adapter checks the proposed keys for conflicts, reads a bounded dependency +set, invokes one native decision and publishes the claim and all capacity rows +atomically. The decision may replace only the first record's opaque bytes; +keys, kinds, expiries and remaining capacity rows stay fixed. Existing keys +return their original conflict index without invoking the admission decision. +The combined insertion/dependency set retains the existing 64-record limit, +and the same two-second fenced decision deadline applies. No nested store, +credential or provider I/O is permitted in the decision. + +The native decision reuses final-entry authority/configuration validation, +sampling time after the writer fence is held. A new record's `evaluated_at` is +that admission time, not the earlier candidate compilation time. All current +approval, native proof, configuration, connection and qualification constraints +must hold before a charge is published. Subsequent entry remains a separate +fresh check and one-use permit. Equal replay returns immutable history and does +not rerun admission or charge again. + +Counter frontiers remain bounded candidate selection outside the fence. The +insert transaction confirms target vacancy; immutable sum predecessors are +included in the dependency snapshot and their validated cumulative amounts must +match the proposed charge. Full native recompilation rejects a changed window +before publication, so expired-slot collection cannot authorize an old-window +admission. Exhausted claims are also recorded only after the same ordered +checks. Acquisition admission additionally fences the eligible source record. + + +Mutation admission has at most one claim, 34 capacity rows, 17 sum predecessors +and three native dependencies: 55 records within the existing 64-record bound. +The later entry boundary retains its independent 52-record maximum. Retained +history is checked before constructing a new candidate so an expired current +approval cannot hide an existing reservation; that handle still requires fresh +entry validation. Runtime grant timestamps are sampled after admission rather +than reused from the earlier candidate evaluation. + +`effect-admission.json` constructs real file-store ordering and atomicity +histories with an explicit-time approval oracle. It does not establish installed +native revocation, PostgreSQL execution or process fault qualification. The same +adapter conformance source is available for the hosted PostgreSQL fixture. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c87b3ede4..7371f86f6 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -633,13 +633,51 @@ closure regeneration passed after that correction (one artifact-generation test) replacement credentials/read bounds, disclosure/ACK and Python removal, authenticated UI/bindings, full faults/formal/performance and CI remain open. +## Ordered initial admission checkpoint + +- Mutation, independent recovery and prerequisite claims now validate native + authority/approval and current connection/configuration/qualification under + the same writer fence as their atomic claim and capacity insert. The adapter + decision can stamp only the first record's bytes; other batch fields remain + fixed. Initial admission time is sampled inside the fence. +- Count/sum frontier discovery remains bounded candidate selection. Insertion + checks target vacancy and validates immutable sum predecessors under the + fence. Acquisition admission checks the eligible source in the same snapshot. + Mutation admission uses at most 55 of the existing 64 records. The existing + two-second lock/decision bounds and file rollback manifest remain in use. +- Runtime callers now supply installed validation before claim publication; + recovery preparation precedes admission and is reused for entry. Transport + grant timestamps are sampled after admission, while the original monotonic + turn deadline remains enforced. No admission result itself grants transport. +- The new fixture caught expiry being checked while constructing a replacement + candidate before reading existing history. Replay now loads retained history + first, preserving the original reservation and charges after approval expiry; + a later grant still requires eligible current approval and native authority. +- `effect-admission.json` covers real file batch atomicity, missing/changed + dependencies, a dependency writer ordered before admission, collision/replay + suppression of the decision, admission time, expired-approval refusal without + writes, retained count/sum charges and expired-entry refusal. Native authority + uses an explicit-time approval oracle; dependency bytes are synthetic. The + same conformance source is authored for PostgreSQL, not executed locally. +- Required artifact construction passed: new native admission, prerequisite + compilation/entry/guard, independent recovery, mutation entry/fuzz seeds and + replay projection (one exact generator each). Construction also caught and + corrected test Arc/zeroizing-buffer type mismatches. Final semantic closure + is regenerated with this checkpoint. No broad local suite or hosted CI was + observed, and no A01–A22 gate closes. +- Remaining implementation: application/onboarding reads, safe credential + replacement and read-policy bounds, controlled disclosure/authenticated ACK, + Python-owner removal and authenticated UI/bindings. Complete installed + authority/adapter/process faults, differential/formal/performance and final + hosted evidence remain required. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | -| P2 | Mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | +| P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | | P3 | Recovery and prerequisite acquisition routes wired | Application/onboarding read cutovers, disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | @@ -654,7 +692,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file fixtures including prerequisite charges | Full adapter concurrency and all units pending | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission and prerequisite charge fixtures | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 0db468569..92839a1d6 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -310,3 +310,21 @@ positive Stripe input now has a known synthetic account commitment, allowing an actual matching account check rather than an unopenable placeholder. These are executed predicate fixtures; their scope excludes installed process/transport, transaction lock waits, PostgreSQL and full differential qualification. + + +## Ordered initial admission + +Mutation count/sum claims and recovery/prerequisite acquisitions now use one +bounded snapshot-and-insert mechanism under the existing writer fence. The +adapter owns atomicity only; the gateway reuses its native entry validator to +establish authority before publishing any claim or charge. Mutation sum +predecessors and acquisition source eligibility remain typed, distinct checks. +No schema, allocation algebra, retry owner or transport reconstruction is added. + +The file artifact `effect-admission.json` covers expired-approval refusal with +no claim/capacity writes, admission-time stamping, immutable replay after expiry, +retained count/sum charges, missing/changed dependencies, batch collisions and a +writer-before-admission dependency order. Authority uses the explicit-time +approval oracle; opaque dependency bytes exercise adapter ordering, not native +revocation semantics. The same conformance source is authored for PostgreSQL. +Installed authority races, process faults and performance remain required. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 5c82c4ae1..85f8c362f 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -392,6 +392,23 @@ Re-run the full native verifier, or use a mechanically justified equivalent depe Connection, trust, recipe, policy, qualification and admission epoch changes must be ordered with entry or fenced under a demonstrated version protocol. A mutable value checked before waiting for the lock is insufficient. Exact human approval must remain eligible at entry. If durable consent has a distinct validity/revocation contract, make that a separate mode with explicit evidence; never discard approval dependencies accidentally. +Initial admission also orders fresh native authority, approval, configuration, +connection and qualification with publication of the claim and its charges. +The file and PostgreSQL adapters use the common writer fence for one insert +batch plus bounded dependency reads. The decision can replace only the first +record's bytes; allocation keys, kinds, amounts and expiries remain fixed. +Persisted admission time is sampled inside that fence. A replay returns retained +history without a new admission decision or charge and confers no entry permit. + +Count/sum frontiers may be selected outside the fence only as candidates. The +transaction checks every target's vacancy and validates immutable sum +predecessors against the proposed cumulative charges. Native recompilation must +refuse a changed window before publication. Acquisition admission additionally +checks its eligible source under the same fence. The combined insertion and +read set is at most 64 records (at most 55 for mutation admission); the existing +two-second lock-wait and decision bounds apply. Store failure or ambiguous +acknowledgement cannot publish an executable capability. + At the entry grant's serialization point, the atomic decision requires current native authority, eligible approval, current configuration and revocation state, an intact sufficient reservation with conserved accounting, and no previous diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index ddd8f2e94..752377f51 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"21f22262cccb12f789974516e4669a21c72b8fd630ed7c750f81f772ee8c3d42"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"1f06014ffd5307f17fbd841d6b03e6e96ea253e0a5b501d83f64a927dd052938"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"90c9f047cda366cb2c905f2ebb424770b0a4c273b9bde17ae518c214001ad959"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"2c45d87bf5d958e988ec31a2044275f0d703d89c591b3b599b04ee6894476fca"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"319a7c87f98c8153c055f99e4f1685eacbe513e52f237c05b2c6f47f95ed5b5b"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"2ff6bf1a8ed8bdca2923d8116c1da1e88aa85b0c7415e6ae4029c3ea060cee5a"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"f0d2cb3ad839636a4e381cf1beaa3001627e2278bc03ce3711cbeb6e837174ae"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d3cda2003b56dcebfb2664183b86ea7b70c08f3d1d4c44e6dd02fc14292b8a2c"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"928b6cab20bf48cbc8b3c856eeeb3fa2d5730c418d61984a7ff8e4b3fcc6b258"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"5eb6cdba2fa1034aa9a61c0ac79dc3619e382cba90c77341d4b3f6f6abf6078e"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"3690807ab1dee53a946a6584143bc8414aa81fc1f0ed86b8cd9b4c92ed318117"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"2b125c5a3b6266276124cd95aec4cedbf66fe7ae92dd6918f007d9940dc8e61d"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"7a56da89947cde6dfa30e5f7f7459dc9ae0bceec824da2d0fac909752c043cbd"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"83367b3ce047bec872c16f29550a82524ff707f10f596fe0e83455b8844c182c"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"10a69f27a0bb27dfe8522e94b80d9ef9281250463863d092afbf8a7e0242083f"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5508c30098625683df3c9288c6cd794015a46765cd5ce2d8c57004d578b5dc1d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"20a5703919a5e94c5d99766cdc7c7f52f2a1e3d07deaf6204e7acd6bcff1192b"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"74abfc3e8d3fd66ee4d8f846185b7e7aa818e0e336330b40be60068add3a40e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"6f09d396c7a2783f77fa9b9036b43b51c38b559ed86c45d591ff81b65a518c59"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index ef42d3883..caa597849 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -90,8 +90,14 @@ async fn native_recovery_acquisition_fixture_is_current() { .join("journal"); let store = Arc::new(crate::FileGatewayAttemptStore::open(&root_path).expect("file journal")); let attempts = crate::GatewayAttempts::new(store, policy.clone()).expect("attempts"); - let crate::store::BoundedClaim::Claimed(claim) = - attempts.claim_bounded(&source, NOW).await.expect("claim") + let crate::store::BoundedClaim::Claimed(claim) = attempts + .claim_bounded( + &source, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await + .expect("claim") else { panic!("expected source claim"); }; @@ -191,9 +197,11 @@ async fn native_recovery_acquisition_fixture_is_current() { let signature = key .sign(&request.signing_message().expect("read message")) .to_bytes(); - let approved = effect - .approve(request.with_signature(signature), &public, NOW + 2) - .expect("read approval"); + let approved = Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW + 2) + .expect("read approval"), + ); approved .validate_for_entry(&read_installation, NOW + 3) .expect("fresh read validation"); @@ -205,7 +213,13 @@ async fn native_recovery_acquisition_fixture_is_current() { ); assert!( matches!( - attempts.claim_bounded(&approved, NOW + 3).await, + attempts + .claim_bounded( + &approved, + NOW + 3, + crate::entry::EntryValidation::Oracle { now: NOW + 3 } + ) + .await, Err(crate::GatewayAttemptError::InvalidTransition) ), "mutation admission rejects acquisition" @@ -278,7 +292,7 @@ async fn native_recovery_acquisition_fixture_is_current() { std::fs::write(&path, &bytes).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), bytes); - let mut reads = vec![Arc::new(approved)]; + let mut reads = vec![approved]; for index in 2..=17 { let call = target .authorization_call( @@ -397,7 +411,11 @@ async fn exercise_recovery_journal( use std::sync::Arc; let first = Arc::clone(&reads[0]); let AcquisitionClaim::Reserved(reserved) = attempts - .claim_recovery(&first, NOW + 2) + .claim_recovery( + &first, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) .await .expect("reserve read") else { @@ -407,7 +425,11 @@ async fn exercise_recovery_journal( assert_eq!(reserved_view.stage, AcquisitionStage::Reserved); assert_eq!(reserved_view.reserved_calls, 1); let AcquisitionClaim::Reserved(stale) = attempts - .claim_recovery(&first, NOW + 2) + .claim_recovery( + &first, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) .await .expect("reopen equal read") else { @@ -443,7 +465,11 @@ async fn exercise_recovery_journal( ) .expect("attempt owner"); let AcquisitionClaim::Existing(replay) = reopened - .claim_recovery(&first, NOW + 3) + .claim_recovery( + &first, + NOW + 3, + crate::entry::EntryValidation::Oracle { now: NOW + 3 }, + ) .await .expect("replay after permit loss") else { @@ -468,7 +494,11 @@ async fn exercise_recovery_journal( ( index, attempts - .claim_recovery(&approved, NOW + 2) + .claim_recovery( + &approved, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) .await .expect("race admission"), ) @@ -510,7 +540,11 @@ async fn exercise_recovery_journal( assert_eq!(response.reserved_calls, 1); assert_eq!(response.reserved_bytes, reserved_view.reserved_bytes); let AcquisitionClaim::Existing(history) = reopened - .claim_recovery(&reads[index], NOW + 4) + .claim_recovery( + &reads[index], + NOW + 4, + crate::entry::EntryValidation::Oracle { now: NOW + 4 }, + ) .await .expect("response replay") else { @@ -635,7 +669,11 @@ async fn exercise_recovery_refinement( let operation = LogicalOperationId::parse(read.effect().binding().journal_identity().1) .expect("read operation"); let AcquisitionClaim::Reserved(reserved) = attempts - .claim_recovery(read, NOW + 2) + .claim_recovery( + read, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) .await .expect("resume") else { @@ -776,7 +814,11 @@ async fn exercise_recovery_refinement( assert!( matches!( attempts - .claim_recovery(read, NOW + 4) + .claim_recovery( + read, + NOW + 4, + crate::entry::EntryValidation::Oracle { now: NOW + 4 } + ) .await .expect("read replay"), AcquisitionClaim::Existing(_) @@ -785,7 +827,13 @@ async fn exercise_recovery_refinement( ); assert!( matches!( - attempts.claim_bounded(source, NOW).await, + attempts + .claim_bounded( + source, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await, Err(crate::GatewayAttemptError::Replay) ), "no new mutation admission" diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index e393682d0..8d55782eb 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -272,7 +272,11 @@ async fn journal_witness( let store = Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("journal")); let attempts = GatewayAttempts::new(store, policy.clone()).expect("attempts"); let crate::store::BoundedClaim::Claimed(parent) = attempts - .claim_bounded(approved, NOW) + .claim_bounded( + approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) .await .expect("parent claim") else { @@ -291,14 +295,24 @@ async fn journal_witness( serde_json::from_value(corrupted).expect("audit only"); assert!(corrupted.validate(approved.effect().binding()).is_err()); let AcquisitionClaim::Reserved(reserved) = attempts - .claim_prerequisite(approved, kind, NOW) + .claim_prerequisite( + approved, + kind, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) .await .expect("read claim") else { panic!("reserved") }; let AcquisitionClaim::Reserved(stale) = attempts - .claim_prerequisite(approved, kind, NOW) + .claim_prerequisite( + approved, + kind, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) .await .expect("equal reservation") else { @@ -364,7 +378,12 @@ async fn journal_witness( ) .expect("reopened attempts"); let AcquisitionClaim::Existing(snapshot) = reopened - .claim_prerequisite(approved, kind, NOW + 2) + .claim_prerequisite( + approved, + kind, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) .await .expect("replay") else { diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 5eb54256e..5a38102d1 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1352,7 +1352,47 @@ impl GatewayEngine { }), }; } - let reserved = match self.attempts.claim_recovery(&approved, now).await { + // Retained terminal history never needs preparation or custody. + if let Some(snapshot) = self + .attempts + .read_recovery(&approved) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => { + not_entered("gateway.effect.operation-conflict") + } + _ => GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }, + })? + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot); + } + let io = EngineIo { + engine: self, + pending: std::sync::Mutex::new(None), + started, + prepared: OnceLock::new(), + #[cfg(unix)] + commissioning: None, + #[cfg(unix)] + commissioned_action: OnceLock::new(), + #[cfg(unix)] + commissioning_refusal: OnceLock::new(), + }; + io.prepare().await.map_err(not_entered)?; + let fresh = io + .clock() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + io.revalidate(&approved, fresh) + .map_err(|_| not_entered("gateway.effect.authority-unavailable"))?; + let validation = io.entry_validation().map_err(not_entered)?; + let reserved = match self + .attempts + .claim_recovery(&approved, now, validation) + .await + { Ok(crate::AcquisitionClaim::Existing(snapshot)) => return Ok(snapshot), Ok(crate::AcquisitionClaim::Reserved(reserved)) => reserved, Err(crate::GatewayAttemptError::BindingConflict) => { @@ -1361,7 +1401,7 @@ impl GatewayEngine { Err(_) => return self.recovery_projection(&approved).await, }; match self - .run_recovery_reservation(*reserved, Arc::clone(&approved), now, started) + .run_recovery_reservation(*reserved, Arc::clone(&approved), &io) .await { Ok(snapshot) => Ok(snapshot), @@ -1459,26 +1499,9 @@ impl GatewayEngine { &self, reserved: crate::ReservedAcquisition, approved: Arc, - now: u64, - started: Instant, + io: &EngineIo<'_>, ) -> Result { - let io = EngineIo { - engine: self, - pending: std::sync::Mutex::new(None), - started, - prepared: OnceLock::new(), - #[cfg(unix)] - commissioning: None, - #[cfg(unix)] - commissioned_action: OnceLock::new(), - #[cfg(unix)] - commissioning_refusal: OnceLock::new(), - }; - io.prepare().await?; - let fresh = io.clock().ok_or("gateway.verify.clock-unavailable")?; - io.revalidate(&approved, fresh) - .map_err(|_| "gateway.effect.authority-unavailable")?; - let _flight = submit::InFlight::enter(&io); + let _flight = submit::InFlight::enter(io); let lease = io.lease().await.ok_or("gateway.credential.unavailable")?; if self .recipe @@ -1489,6 +1512,7 @@ impl GatewayEngine { return Err("gateway.credential.mode-guard"); } let validation = io.entry_validation()?; + let now = io.clock().ok_or("gateway.verify.clock-unavailable")?; let (granted, permit) = reserved .grant_entry(approved, validation, now) .await diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index 83fc30b49..e4fea48a9 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -173,7 +173,11 @@ async fn reservation_restart(backend: Backend) -> serde_json::Value { ); assert_eq!(approved.effect().binding(), renewed.effect().binding()); let BoundedClaim::Claimed(claim) = restarted - .claim_bounded(&renewed, RESUMED_AT) + .claim_bounded( + &renewed, + RESUMED_AT, + crate::entry::EntryValidation::Oracle { now: RESUMED_AT }, + ) .await .expect("reopen") else { @@ -274,7 +278,13 @@ async fn reservation_restart(backend: Backend) -> serde_json::Value { "stale reservation cannot grant again" ); assert!(matches!( - restarted.claim_bounded(&renewed, RESUMED_AT).await, + restarted + .claim_bounded( + &renewed, + RESUMED_AT, + crate::entry::EntryValidation::Oracle { now: RESUMED_AT } + ) + .await, Err(GatewayAttemptError::Replay) )); for ((kind, key), before) in slot_keys.iter().zip(&slots_before) { @@ -316,7 +326,14 @@ async fn reserved( attempts: &GatewayAttempts, approved: &Arc, ) -> ClaimedGatewayAttempt { - let BoundedClaim::Claimed(claim) = attempts.claim_bounded(approved, NOW).await.expect("claim") + let BoundedClaim::Claimed(claim) = attempts + .claim_bounded( + approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await + .expect("claim") else { panic!("claim refused") }; @@ -530,7 +547,14 @@ async fn grant_conformance(backend: Backend) { .expect("retained"); assert_eq!(snapshot.stage(), GatewayAttemptStage::Unknown); assert!(matches!( - store.attempts().claim_bounded(&approved, NOW).await, + store + .attempts() + .claim_bounded( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await, Err(GatewayAttemptError::Replay) )); } @@ -546,3 +570,322 @@ async fn postgres_grant_has_one_winner_and_no_restart_permit() { assert!(postgres_configured()); grant_conformance(Backend::Postgres).await; } + +/// Real adapter history with an explicit-time approval oracle. This establishes +/// atomic persistence and original timestamps, not installed resource authority. +async fn admission_conformance(backend: Backend) -> serde_json::Value { + let store = TestAttempts::open(backend); + let approved = bounded_approval(); + let command = approved.command().expect("mutation"); + let bound = command.bound.as_ref().expect("capacity"); + let slots = bound + .counts + .iter() + .map(|counter| { + ( + GatewayRecordKind::CountSlot, + crate::bounds::count_slot_key(&counter.key, 0), + ) + }) + .chain(bound.sums.iter().map(|counter| { + ( + GatewayRecordKind::SumSlot, + crate::bounds::sum_slot_key(&counter.key, 0), + ) + })) + .collect::>(); + // The original approval expires at NOW + 5. Refusal cannot consume an ID + // or either capacity unit, even though frontier selection already ran. + assert!( + store + .attempts() + .claim_bounded( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW + 6 } + ) + .await + .is_err() + ); + assert!( + store + .attempts() + .read_effect(&approved) + .await + .expect("read") + .is_none() + ); + for (kind, key) in &slots { + assert!(slot_bytes(&store, *kind, *key).await.is_none()); + } + let BoundedClaim::Claimed(claim) = store + .attempts() + .claim_bounded( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) + .await + .expect("admission") + else { + panic!("reserved"); + }; + assert_eq!(claim.attempt.record.evaluated_at, NOW + 2); + assert!(claim.attempt.record.entry.is_none()); + let original = claim.attempt.stored.clone(); + let mut allocated = Vec::new(); + for (kind, key) in &slots { + allocated.push(slot_bytes(&store, *kind, *key).await.expect("charged")); + } + // Reopening does not validate expired admission again or alter its facts. + // It still cannot grant entry with that expired approval. + let BoundedClaim::Claimed(reopened) = store + .reopen() + .claim_bounded( + &approved, + NOW + 6, + crate::entry::EntryValidation::Oracle { now: NOW + 6 }, + ) + .await + .expect("reopen") + else { + panic!("reopened"); + }; + assert_eq!(reopened.attempt.stored, original); + assert!( + reopened + .grant_entry( + Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: NOW + 6 }, + NOW + 6, + &crate::GatewayPreEntry::default() + ) + .await + .is_err() + ); + for ((kind, key), bytes) in slots.iter().zip(allocated) { + assert_eq!(slot_bytes(&store, *kind, *key).await, Some(bytes)); + } + serde_json::json!({ + "backend": backend.label(), "authorization_started_at": NOW, + "admitted_at": NOW + 2, "capacity_records": slots.len(), + "expired_admission_persists_nothing": true, "reopen_preserves_bytes": true, + "expired_entry_refused": true, "charges_retained": true, "provider_calls": 0, + }) +} + +fn admission_batch_contract(store: &dyn GatewayAttemptStore) -> serde_json::Value { + let entry = |kind, id, bytes: &[u8]| GatewayRecordEntry { + kind, + key: GatewayAttemptKey([id; 32]), + record: bytes.to_vec(), + expires_at: None, + }; + let dependency = entry(GatewayRecordKind::EffectConfiguration, 190, b"current"); + store.insert(&dependency).expect("dependency"); + let entries = [ + entry(GatewayRecordKind::Attempt, 191, b"initial"), + entry(GatewayRecordKind::EffectAllocation, 192, b"charge"), + ]; + let dependencies = [(dependency.kind, dependency.key)]; + let missing = [(dependency.kind, GatewayAttemptKey([193; 32]))]; + assert!( + store + .fenced_insert_all(&entries, &missing, &mut |snapshots| { + assert_eq!(snapshots, &[None]); + Err(GatewayAttemptError::InvalidTransition) + }) + .is_err() + ); + assert!( + store + .fenced_insert_all(&entries, &dependencies, &mut |snapshots| { + assert_eq!(snapshots, &[Some(b"current".to_vec())]); + Err(GatewayAttemptError::InvalidTransition) + }) + .is_err() + ); + for row in &entries { + assert!(store.load(row.kind, &row.key).expect("read").is_none()); + } + assert_eq!( + store + .fenced_insert_all(&entries, &dependencies, &mut |snapshots| { + assert_eq!(snapshots, &[Some(b"current".to_vec())]); + Ok(b"admitted".to_vec()) + }) + .expect("insert"), + GatewayInsert::Inserted + ); + assert_eq!( + store.load(entries[0].kind, &entries[0].key).expect("claim"), + Some(b"admitted".to_vec()) + ); + assert_eq!( + store + .load(entries[1].kind, &entries[1].key) + .expect("charge"), + Some(b"charge".to_vec()) + ); + assert_eq!( + store + .fenced_insert_all(&entries, &dependencies, &mut |_| panic!("replay decision")) + .expect("replay"), + GatewayInsert::Exists { index: 0 } + ); + let competing = [ + entry(GatewayRecordKind::Attempt, 194, b"other"), + entries[1].clone(), + ]; + assert_eq!( + store + .fenced_insert_all(&competing, &dependencies, &mut |_| panic!( + "occupied capacity" + )) + .expect("collision"), + GatewayInsert::Exists { index: 1 } + ); + assert!( + store + .load(competing[0].kind, &competing[0].key) + .expect("other") + .is_none() + ); + assert!( + store + .fenced_insert_all( + &competing, + &[(competing[0].kind, competing[0].key)], + &mut |_| panic!("overlapping set") + ) + .is_err() + ); + serde_json::json!({"dependency_refusal_atomic": true, "missing_dependency_refused": true, + "first_record_stamped": true, "allocation_unchanged": true, + "replay_skips_decision": true, "capacity_collision_atomic": true, + "overlapping_set_refused": true}) +} + +/// A writer holds the common fence while admission starts. The decision must +/// observe the writer's committed dependency, never its earlier value. +fn admission_dependency_order(store: Arc) -> serde_json::Value { + use std::sync::mpsc; + use std::time::Duration; + let dependency = ( + GatewayRecordKind::EffectConfiguration, + GatewayAttemptKey([195; 32]), + ); + store + .insert(&GatewayRecordEntry { + kind: dependency.0, + key: dependency.1, + record: b"current".to_vec(), + expires_at: None, + }) + .expect("dependency"); + let (locked_tx, locked_rx) = mpsc::channel(); + let (release_tx, release_rx) = mpsc::channel(); + let writer_store = Arc::clone(&store); + let writer = std::thread::spawn(move || { + writer_store.fenced_replace(&[dependency], &mut |snapshots| { + assert_eq!(snapshots, &[Some(b"current".to_vec())]); + locked_tx.send(()).expect("locked"); + release_rx + .recv_timeout(Duration::from_secs(1)) + .expect("release writer"); + Ok(b"revoked".to_vec()) + }) + }); + locked_rx + .recv_timeout(Duration::from_secs(1)) + .expect("writer locked"); + let (started_tx, started_rx) = mpsc::channel(); + let admission_store = Arc::clone(&store); + let claim_key = GatewayAttemptKey([196; 32]); + let charge_key = GatewayAttemptKey([197; 32]); + let admission = std::thread::spawn(move || { + let entries = [ + GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key: claim_key, + record: b"claim".to_vec(), + expires_at: None, + }, + GatewayRecordEntry { + kind: GatewayRecordKind::EffectAllocation, + key: charge_key, + record: b"charge".to_vec(), + expires_at: None, + }, + ]; + started_tx.send(()).expect("admission started"); + admission_store.fenced_insert_all(&entries, &[dependency], &mut |snapshots| { + assert_eq!(snapshots, &[Some(b"revoked".to_vec())]); + Err(GatewayAttemptError::InvalidTransition) + }) + }); + started_rx + .recv_timeout(Duration::from_secs(1)) + .expect("admission start"); + release_tx.send(()).expect("release"); + writer.join().expect("writer").expect("updated dependency"); + assert!(matches!( + admission.join().expect("admission"), + Err(GatewayAttemptError::InvalidTransition) + )); + assert!( + store + .load(GatewayRecordKind::Attempt, &claim_key) + .expect("claim") + .is_none() + ); + assert!( + store + .load(GatewayRecordKind::EffectAllocation, &charge_key) + .expect("charge") + .is_none() + ); + serde_json::json!({"writer_commits_before_admission_decision": true, + "decision_observes_changed_dependency": true, "refusal_leaves_no_claim_or_charge": true}) +} + +#[tokio::test] +async fn native_admission_fixture_is_current() { + let store = TestAttempts::open(Backend::File); + let raw = store.raw(); + let (mechanism, dependency_order) = tokio::task::spawn_blocking(move || { + ( + admission_batch_contract(&*raw), + admission_dependency_order(raw), + ) + }) + .await + .expect("mechanism history"); + let fixture = serde_json::to_vec_pretty(&serde_json::json!({ + "schema": "auths.effect-admission-fixture/1", + "scope": "file adapter and explicit-time approval oracle; no installed authority or transport claim", + "mechanism": mechanism, "dependency_order": dependency_order, + "history": admission_conformance(Backend::File).await, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/effect-admission.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} + +#[tokio::test] +#[ignore = "requires the TLS PostgreSQL fixture"] +async fn postgres_admission_checks_authority_before_atomic_charges() { + assert!(postgres_configured()); + admission_conformance(Backend::Postgres).await; + let store = TestAttempts::open(Backend::Postgres); + let raw = store.raw(); + tokio::task::spawn_blocking(move || { + admission_batch_contract(&*raw); + admission_dependency_order(raw); + }) + .await + .expect("contract"); +} diff --git a/product/runtime/auths-gateway/src/property_tests.rs b/product/runtime/auths-gateway/src/property_tests.rs index 2a74dab4e..9ec82796e 100644 --- a/product/runtime/auths-gateway/src/property_tests.rs +++ b/product/runtime/auths-gateway/src/property_tests.rs @@ -305,7 +305,7 @@ proptest! { let values = arguments(&format!("op-{operation}"), "recTEST0000000001", "Approved"); let command = crate::scenario_tests::admitted(&recipe, &values, [operation; 32], Vec::new(), 60, Vec::new(), 1_790_000_000).expect("command"); let approved = Arc::new(crate::effect::approve_driver_fixture(command, digest, 1_790_000_000, None).expect("approval")); - match runtime.block_on(attempts.claim_bounded(&approved, 1_790_000_000)) { + match runtime.block_on(attempts.claim_bounded(&approved, 1_790_000_000, crate::entry::EntryValidation::Oracle { now: 1_790_000_000 })) { Ok(crate::store::BoundedClaim::Claimed(claim)) => { held.insert(operation, (*claim, approved)); } Err(GatewayAttemptError::Replay) => {} other => prop_assert!(matches!(other, Err(GatewayAttemptError::Replay)), "unexpected claim result"), diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index eb221bea0..0d3bdaf13 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -779,7 +779,11 @@ async fn response_and_observation_are_distinct_durable_stages() { .expect("approval"), ); let crate::store::BoundedClaim::Claimed(claim) = store - .claim_bounded(&approved, 1_790_000_000) + .claim_bounded( + &approved, + 1_790_000_000, + crate::entry::EntryValidation::Oracle { now: 1_790_000_000 }, + ) .await .expect("claim") else { diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index a0be2eeb9..5659c8faf 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -105,6 +105,28 @@ impl RecordingStore { } impl GatewayAttemptStore for RecordingStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut crate::GatewayFenceDecision<'_>, + ) -> Result { + let mut admitted = None; + let inserted = self + .inner + .fenced_insert_all(entries, dependencies, &mut |snapshots| { + let next = decide(snapshots)?; + admitted = Some(next.clone()); + Ok(next) + })?; + if inserted == GatewayInsert::Inserted + && let Some(record) = admitted + { + self.record(&record); + } + Ok(inserted) + } + fn fenced_replace( &self, keys: &[(GatewayRecordKind, GatewayAttemptKey)], @@ -1832,11 +1854,20 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { let mut record = Record::open("airtable", backend); let command = record.airtable(ORIGINAL, "Approved"); let approve = |command, digest, at| { - approve_driver_fixture(command, digest, at, None).expect("oracle approval") + Arc::new(approve_driver_fixture(command, digest, at, None).expect("oracle approval")) }; let first = approve(command.clone(), *record.recipe.digest(), NOW); let attempts = record.store.attempts(); - assert!(attempts.claim_bounded(&first, NOW).await.is_ok()); + assert!( + attempts + .claim_bounded( + &first, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_ok() + ); let key = GatewayAttemptKey::for_operation( &crate::effect::fixture_policy().expect("policy"), command.request.namespace(), @@ -1854,7 +1885,13 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { let renewed = approve(command.clone(), *record.recipe.digest(), NOW + 1); assert!( matches!( - attempts.claim_bounded(&renewed, NOW + 1).await, + attempts + .claim_bounded( + &renewed, + NOW + 1, + crate::entry::EntryValidation::Oracle { now: NOW + 1 } + ) + .await, Ok(crate::store::BoundedClaim::Claimed(_)) ), "renewing approval reopens the reservation without replacing its bytes" @@ -1871,7 +1908,13 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { ), ] { assert!(matches!( - attempts.claim_bounded(&changed, NOW).await, + attempts + .claim_bounded( + &changed, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await, Err(GatewayAttemptError::BindingConflict) )); } @@ -1903,7 +1946,13 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { ); assert!( matches!( - scoped.claim_bounded(&first, NOW).await, + scoped + .claim_bounded( + &first, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await, Err(GatewayAttemptError::BindingConflict) ), "foreign binding cannot enter the new scope" diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index ba0ba2fe6..98c57bf40 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "5d81fddb0a06139dfca50d741115852e4c6796d8f680b59c497ae3af75f4fdfb"; + "8ef59e4230c04557571750125161e6d96d32aa0891ca7afb52fb1ae868baae68"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 58d90bdb1..eaf9a59ac 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -1391,6 +1391,21 @@ fn fence_keys( /// sweeps of expired slots only, and fail-closed reads that never report /// unreadable state as absent. pub trait GatewayAttemptStore: Send + Sync { + /// Atomically inserts a fixed batch after a native decision over dependencies + /// under the common writer fence. The decision replaces only the first + /// record's bytes. Existing keys return without a decision or new charges. + /// + /// # Errors + /// Refuses overlapping/oversized sets, missing/corrupt dependencies as + /// interpreted by the decision, failed authorization, deadlines or ambiguous + /// durability. The combined read/write set is at most 64 records. + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result; + /// Reads the bounded set while excluding every participating writer, calls /// `decide` once, and durably replaces the first record. This is a storage /// mechanism; the gateway owns validation and the one-use permit. @@ -1740,6 +1755,18 @@ impl FileGatewayAttemptStore { &self, entries: &[GatewayRecordEntry], crash: Option, + ) -> Result { + validate_batch(entries)?; + let _lock = self.exclusive()?; + self.insert_batch_locked(entries, crash, None) + } + + /// The caller holds the writer fence, including crash-batch recovery. + fn insert_batch_locked( + &self, + entries: &[GatewayRecordEntry], + crash: Option, + started: Option, ) -> Result { validate_batch(entries)?; let files = entries @@ -1751,7 +1778,6 @@ impl FileGatewayAttemptStore { )) }) .collect::, GatewayAttemptError>>()?; - let _lock = self.exclusive()?; for (index, (name, _)) in files.iter().enumerate() { if self.root.join(name).exists() { return Ok(GatewayInsert::Exists { index }); @@ -1767,6 +1793,7 @@ impl FileGatewayAttemptStore { }) .collect(), })?; + admission_deadline(started)?; self.pending(&batch)? .persist_noclobber(self.root.join(BATCH_FILE)) .map_err(|_| GatewayAttemptError::Unavailable)?; @@ -1779,6 +1806,7 @@ impl FileGatewayAttemptStore { sync_directory(&self.root)?; return Ok(GatewayInsert::Inserted); } + admission_deadline(started)?; self.pending(bytes)? .persist_noclobber(self.root.join(name)) .map_err(|_| GatewayAttemptError::Unavailable)?; @@ -1787,6 +1815,7 @@ impl FileGatewayAttemptStore { if crash == Some(BatchCrash::BeforeBatchDelete) { return Ok(GatewayInsert::Inserted); } + admission_deadline(started)?; fs::remove_file(self.root.join(BATCH_FILE)) .map_err(|_| GatewayAttemptError::Unavailable)?; sync_directory(&self.root)?; @@ -1827,7 +1856,49 @@ fn valid_file_name(name: &str) -> bool { }) } +fn admission_deadline(started: Option) -> Result<(), GatewayAttemptError> { + if started.is_some_and(|started| started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE) { + return Err(GatewayAttemptError::Unavailable); + } + Ok(()) +} + impl GatewayAttemptStore for FileGatewayAttemptStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + validate_batch(entries)?; + let mut keys: Vec<_> = entries + .iter() + .map(|entry| (entry.kind, entry.key)) + .collect(); + keys.extend_from_slice(dependencies); + fence_keys(&keys)?; + let _lock = self.exclusive()?; + let started = Some(Instant::now()); + for (index, entry) in entries.iter().enumerate() { + admission_deadline(started)?; + if self.load_locked(entry.kind, &entry.key)?.is_some() { + return Ok(GatewayInsert::Exists { index }); + } + } + let snapshots = dependencies + .iter() + .map(|(kind, key)| { + admission_deadline(started)?; + self.load_locked(*kind, key) + }) + .collect::, GatewayAttemptError>>()?; + admission_deadline(started)?; + let next = decide(&snapshots)?; + let mut entries = entries.to_vec(); + entries[0].record = next; + self.insert_batch_locked(&entries, None, started) + } + fn fenced_replace( &self, keys: &[(GatewayRecordKind, GatewayAttemptKey)], @@ -2019,6 +2090,26 @@ impl FileGatewayAttemptStore { } impl GatewayAttemptStore for PostgresGatewayAttemptStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + let mechanism: Vec<_> = entries.iter().map(GatewayRecordEntry::mechanism).collect(); + let dependencies: Vec<_> = dependencies + .iter() + .map(|(kind, key)| (*kind, key.0)) + .collect(); + match self + .store()? + .fenced_gateway_insert(&mechanism, &dependencies, decide)? + { + GatewayRecordInsert::Inserted => Ok(GatewayInsert::Inserted), + GatewayRecordInsert::Exists { index } => Ok(GatewayInsert::Exists { index }), + } + } + fn fenced_replace( &self, keys: &[(GatewayRecordKind, GatewayAttemptKey)], @@ -2198,6 +2289,7 @@ impl GatewayAttempts { .await } + #[cfg(any(test, feature = "testkit-harness"))] async fn claim_binding( &self, request: &ClosedProviderRequest, @@ -3024,18 +3116,22 @@ fn store_exhausted( key: GatewayAttemptKey, base: &Record, code: &'static str, + admission: &Admission, ) -> Result { let mut record = base.clone(); record.state.stage = GatewayAttemptStage::NotEntered; record.state.refusal = Some(code.to_owned()); record.snapshot(false)?; - store.insert(&GatewayRecordEntry { + let entries = [GatewayRecordEntry { kind: GatewayRecordKind::Attempt, key, record: encode(&record)?, expires_at: None, - })?; - Ok(Reserved::Exhausted(code)) + }]; + match insert_claim(store, &mut record, &entries, admission, None, &[], &[])? { + GatewayInsert::Inserted => Ok(Reserved::Exhausted(code)), + GatewayInsert::Exists { .. } => Err(GatewayAttemptError::Replay), + } } /// The claim record with the reserved slots, and the batch that inserts it @@ -3145,6 +3241,7 @@ fn reserve_with_claim( key: GatewayAttemptKey, base: &Record, bound: &crate::bounds::BoundAdmission, + admission: &Admission, ) -> Result { use crate::bounds::{count_slot_key, sum_slot_key}; use auths_bounded_policy::kernel::{chain_counts_admit, chain_sums_admit}; @@ -3194,16 +3291,30 @@ fn reserve_with_claim( .zip(&bound.sums) .all(|(slot, counter)| *slot < counter.slots); if !chain_counts_admit(&counts, &count_capacities) || !sum_slots_left { - return store_exhausted(store, key, base, "gateway.policy.window-exhausted"); + return store_exhausted( + store, + key, + base, + "gateway.policy.window-exhausted", + admission, + ); } if !chain_sums_admit(&totals, bound.argument, &sum_capacities) { - return store_exhausted(store, key, base, "gateway.policy.sum-exhausted"); - } - let (record, stored, entries) = claim_batch(key, base, bound, &counts, &sums, &totals)?; - match store.insert_all(&entries)? { + return store_exhausted(store, key, base, "gateway.policy.sum-exhausted", admission); + } + let (mut record, _, entries) = claim_batch(key, base, bound, &counts, &sums, &totals)?; + match insert_claim( + store, + &mut record, + &entries, + admission, + Some(bound), + &sums, + &totals, + )? { GatewayInsert::Inserted => { return Ok(Reserved::Claimed { - stored, + stored: encode(&record)?, record: Box::new(record), }); } @@ -3230,6 +3341,106 @@ fn reserve_with_claim( Ok(Reserved::Contended) } +/// Current native authority captured before custody and sampled again only +/// inside the adapter writer fence. It never grants transport entry. +struct Admission { + approved: Arc, + validation: crate::entry::EntryValidation, + authorization_started_at: u64, +} + +impl Admission { + fn dependencies(&self) -> Vec<(GatewayRecordKind, GatewayAttemptKey)> { + self.validation.dependencies() + } + + fn stamp( + &self, + record: &mut Record, + snapshots: &[Option>], + ) -> Result<(), GatewayAttemptError> { + if record.revision != 1 + || record.entry.is_some() + || record.validate_header()? != *self.approved.effect().binding() + { + return Err(GatewayAttemptError::InvalidTransition); + } + let now = self + .validation + .validate(&self.approved, snapshots, self.authorization_started_at) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + record.evaluated_at = now; + S::validate(record) + } +} + +/// Capacity candidates are chosen outside the lock, but target vacancy and +/// immutable sum predecessors are checked with current authority before insert. +fn insert_claim( + store: &dyn GatewayAttemptStore, + record: &mut Record, + entries: &[GatewayRecordEntry], + admission: &Admission, + bound: Option<&crate::bounds::BoundAdmission>, + sums: &[u64], + totals: &[u64], +) -> Result { + let mut dependencies = admission.dependencies(); + let native_end = dependencies.len(); + if let Some(bound) = bound { + if sums.len() != bound.sums.len() || totals.len() != sums.len() { + return Err(GatewayAttemptError::Corrupt); + } + for (counter, slot) in bound.sums.iter().zip(sums) { + if let Some(previous) = slot.checked_sub(1) { + dependencies.push(( + GatewayRecordKind::SumSlot, + GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.key, previous)), + )); + } + } + } else if !sums.is_empty() || !totals.is_empty() { + return Err(GatewayAttemptError::Corrupt); + } + store.fenced_insert_all(entries, &dependencies, &mut |snapshots| { + if snapshots.len() != dependencies.len() { + return Err(GatewayAttemptError::Corrupt); + } + admission.stamp(record, &snapshots[..native_end])?; + if let Some(bound) = bound { + let mut predecessors = snapshots[native_end..].iter(); + for ((counter, slot), total) in bound.sums.iter().zip(sums).zip(totals) { + match slot.checked_sub(1) { + None if *total != 0 => return Err(GatewayAttemptError::Corrupt), + None => {} + Some(previous) => { + let bytes = predecessors + .next() + .and_then(|bytes| bytes.as_deref()) + .ok_or(GatewayAttemptError::Corrupt)?; + let row: SumSlotRecord = serde_json::from_slice(bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if canonical(&row)? != bytes + || row.schema != SUM_SLOT_SCHEMA + || row.counter != hex::encode(counter.key) + || row.slot != previous + || row.amount > row.cumulative + || row.cumulative != *total + || row.window_seconds != bound.window_seconds + || row.window_index != bound.window_index + || row.window_end != bound.window_end + || row.cumulative > counter.capacity + { + return Err(GatewayAttemptError::Corrupt); + } + } + } + } + } + encode(record) + }) +} + impl GatewayAttempts { /// Claims one logical ID together with one slot of every count and sum /// counter `bound` names, in one all-or-none batch, before credential @@ -3242,10 +3453,14 @@ impl GatewayAttempts { /// `BindingConflict`. Reopening itself never authorizes provider entry. pub(crate) async fn claim_bounded( &self, - approved: &ApprovedEffect, + approved: &Arc, evaluated_at: u64, + validation: crate::entry::EntryValidation, ) -> Result { - match self.claim_new_bounded(approved, evaluated_at).await { + match self + .claim_new_bounded(approved, evaluated_at, validation) + .await + { Err(GatewayAttemptError::Replay) => { let request = &approved .command() @@ -3285,8 +3500,9 @@ impl GatewayAttempts { async fn claim_new_bounded( &self, - approved: &ApprovedEffect, + approved: &Arc, evaluated_at: u64, + validation: crate::entry::EntryValidation, ) -> Result { let command = approved .command() @@ -3296,24 +3512,64 @@ impl GatewayAttempts { if !self.policy.contains(binding) { return Err(GatewayAttemptError::BindingConflict); } - let Some(bound) = command.bound.as_ref() else { - return self - .claim_binding(request, binding, approved.approval(), evaluated_at) - .await - .map(|claim| BoundedClaim::Claimed(Box::new(claim))); - }; let key = self.key(request.namespace(), request.operation_id())?; - let base = claim_record(request, binding, approved.approval(), evaluated_at)?; + let expected = String::from_utf8( + binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; let store = Arc::clone(&self.store); - let bound = bound.clone(); - let reserved = blocking( - move || match reserve_with_claim(&*store, key, &base, &bound) { + let bound = command.bound.clone(); + let admission = Admission { + approved: Arc::clone(approved), + validation, + authorization_started_at: evaluated_at, + }; + let reserved = blocking(move || { + // History precedes candidate admission. Expiry cannot erase replay + // or turn an existing reservation into a new charged operation. + if store.load(GatewayRecordKind::Attempt, &key)?.is_some() { + return Err(existing_binding(&*store, key, &expected)); + } + let base = claim_record( + &admission + .approved + .command() + .ok_or(GatewayAttemptError::InvalidTransition)? + .request, + admission.approved.effect().binding(), + admission.approved.approval(), + evaluated_at, + )?; + let result = match &bound { + Some(bound) => reserve_with_claim(&*store, key, &base, bound, &admission), + None => { + let mut record = base.clone(); + let entries = [GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + match insert_claim(&*store, &mut record, &entries, &admission, None, &[], &[])? + { + GatewayInsert::Inserted => Ok(Reserved::Claimed { + stored: encode(&record)?, + record: Box::new(record), + }), + GatewayInsert::Exists { .. } => Err(GatewayAttemptError::Replay), + } + } + }; + match result { Err(GatewayAttemptError::Replay) => { Err(existing_binding(&*store, key, &base.binding_canonical)) } result => result, - }, - ) + } + }) .await?; Ok(match reserved { Reserved::Claimed { stored, record } => { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index d5f71b8a6..20fd62f07 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -417,10 +417,11 @@ impl GatewayAttempts { /// # Errors /// Refuses non-acquisitions, changed source/partition, invalid approval and /// corrupt or unavailable state. No error can return a transport permit. - pub async fn claim_recovery( + pub(crate) async fn claim_recovery( &self, - approved: &ApprovedEffect, + approved: &Arc, evaluated_at: u64, + validation: crate::entry::EntryValidation, ) -> Result { let target = approved .recovery_target() @@ -430,27 +431,35 @@ impl GatewayAttempts { .journal_plan() .map_err(|_| GatewayAttemptError::Corrupt)?, ); - self.claim_acquisition(approved, plan, evaluated_at).await + self.claim_acquisition(approved, plan, evaluated_at, validation) + .await } pub(crate) async fn claim_prerequisite( &self, - approved: &ApprovedEffect, + approved: &Arc, kind: PrerequisiteKind, evaluated_at: u64, + validation: crate::entry::EntryValidation, ) -> Result { let (plan, _) = approved .prerequisite(kind) .map_err(|_| GatewayAttemptError::BindingConflict)?; - self.claim_acquisition(approved, AcquisitionPlan::Prerequisite(plan), evaluated_at) - .await + self.claim_acquisition( + approved, + AcquisitionPlan::Prerequisite(plan), + evaluated_at, + validation, + ) + .await } async fn claim_acquisition( &self, - approved: &ApprovedEffect, + approved: &Arc, plan: AcquisitionPlan, evaluated_at: u64, + validation: crate::entry::EntryValidation, ) -> Result { let binding = approved.effect().binding(); let capacity = plan @@ -474,19 +483,36 @@ impl GatewayAttempts { AcquisitionPlan::Prerequisite(plan) => prerequisite_key(source_key, plan.index()), }; let expected_plan = plan.clone(); - let base = Record::new( - binding, - approved.approval(), - evaluated_at, - AcquisitionState { - plan, - allocation: None, - phase: AcquisitionPhase::Reserved, - }, - )?; - base.validate_header()?; + let expected = String::from_utf8( + binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; let store = Arc::clone(&self.store); + let admission = Admission { + approved: Arc::clone(approved), + validation, + authorization_started_at: evaluated_at, + }; + let mut dependencies = vec![(GatewayRecordKind::Attempt, source_key)]; + dependencies.extend(admission.dependencies()); let reserved = blocking(move || { + if store.load(GatewayRecordKind::Attempt, &key)?.is_some() { + return Err(existing_binding(&*store, key, &expected)); + } + let base = Record::new( + admission.approved.effect().binding(), + admission.approved.approval(), + evaluated_at, + AcquisitionState { + plan, + allocation: None, + phase: AcquisitionPhase::Reserved, + }, + )?; + base.validate_header()?; for slot in 0..capacity.attempts { let mut record = base.clone(); record.state.allocation = Some(slot); @@ -507,8 +533,19 @@ impl GatewayAttempts { expires_at: None, }, ]; - match store.insert_all(&entries)? { - GatewayInsert::Inserted => return Ok((record, stored)), + match insert_acquisition( + &*store, + &mut record, + &entries, + &dependencies, + &admission, + source_key, + key, + )? { + GatewayInsert::Inserted => { + let stored = encode(&record)?; + return Ok((record, stored)); + } GatewayInsert::Exists { index: 0 } => { return Err(existing_binding(&*store, key, &base.binding_canonical)); } @@ -522,17 +559,28 @@ impl GatewayAttempts { }; AcquisitionState::validate(&record)?; let stored = encode(&record)?; - match store.insert(&GatewayRecordEntry { + let entries = [GatewayRecordEntry { kind: GatewayRecordKind::Attempt, key, - record: stored.clone(), + record: stored, expires_at: None, - }) { - Ok(()) => Ok((record, stored)), - Err(GatewayAttemptError::Replay) => { + }]; + match insert_acquisition( + &*store, + &mut record, + &entries, + &dependencies, + &admission, + source_key, + key, + )? { + GatewayInsert::Inserted => { + let stored = encode(&record)?; + Ok((record, stored)) + } + GatewayInsert::Exists { .. } => { Err(existing_binding(&*store, key, &record.binding_canonical)) } - Err(error) => Err(error), } }) .await; @@ -660,22 +708,7 @@ impl ReservedAcquisition { .as_deref() .ok_or(GatewayAttemptError::Corrupt)?, )?; - let source_matches = match &plan { - AcquisitionPlan::Recovery(plan) => { - source - .recovery_target()? - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)? - == *plan - } - AcquisitionPlan::Prerequisite(plan) => { - source.state.stage == GatewayAttemptStage::Reserved - && source.entry.is_none() - && source.validate_header()? - == plan.source().map_err(|_| GatewayAttemptError::Corrupt)? - && attempt.key == prerequisite_key(self.source_key, plan.index()) - } - }; + let source_matches = eligible_source(&plan, &source, self.source_key, attempt.key)?; if !source_matches || snapshots[2].as_deref() != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) @@ -832,3 +865,56 @@ pub(super) fn validate_prerequisites( } Ok(evidence) } + +fn eligible_source( + plan: &AcquisitionPlan, + source: &Record, + source_key: GatewayAttemptKey, + key: GatewayAttemptKey, +) -> Result { + Ok(match plan { + AcquisitionPlan::Recovery(plan) => { + source + .recovery_target()? + .journal_plan() + .map_err(|_| GatewayAttemptError::Corrupt)? + == *plan + } + AcquisitionPlan::Prerequisite(plan) => { + source.state.stage == GatewayAttemptStage::Reserved + && source.entry.is_none() + && source.validate_header()? + == plan.source().map_err(|_| GatewayAttemptError::Corrupt)? + && key == prerequisite_key(source_key, plan.index()) + } + }) +} + +fn insert_acquisition( + store: &dyn GatewayAttemptStore, + record: &mut Record, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + admission: &Admission, + source_key: GatewayAttemptKey, + key: GatewayAttemptKey, +) -> Result { + store.fenced_insert_all(entries, dependencies, &mut |snapshots| { + if snapshots.len() != dependencies.len() || snapshots.is_empty() { + return Err(GatewayAttemptError::Corrupt); + } + let source = decode( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if !eligible_source(&record.state.plan, &source, source_key, key)? { + return Err(GatewayAttemptError::InvalidTransition); + } + admission.stamp(record, &snapshots[1..])?; + if record.evaluated_at < source.evaluated_at { + return Err(GatewayAttemptError::InvalidTransition); + } + encode(record) + }) +} diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 9f8ce4f89..38b7597f9 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -511,10 +511,13 @@ impl Run<'_, I> { let Some(approved) = self.verified.as_ref() else { return ClaimResult::Unavailable; }; + let Ok(validation) = self.io.entry_validation() else { + return ClaimResult::Unavailable; + }; match self .cx .attempts - .claim_bounded(approved, self.evaluated_at) + .claim_bounded(approved, self.evaluated_at, validation) .await { Ok(BoundedClaim::Claimed(claim)) => { @@ -563,17 +566,19 @@ impl Run<'_, I> { let lease = self.lease.as_ref()?; let approved = self.verified.as_ref()?; let started = self.io.clock()?; + let validation = self.io.entry_validation().ok()?; match self .cx .attempts - .claim_prerequisite(approved, kind, started) + .claim_prerequisite(approved, kind, started, validation) .await .ok()? { crate::AcquisitionClaim::Reserved(reserved) => { let validation = self.io.entry_validation().ok()?; + let entry_started = self.io.clock()?; let (granted, permit) = reserved - .grant_entry(std::sync::Arc::clone(approved), validation, started) + .grant_entry(std::sync::Arc::clone(approved), validation, entry_started) .await .ok()?; match self.io.acquire(lease, permit).await { @@ -723,6 +728,9 @@ impl Run<'_, I> { let Some(approved) = &self.verified else { return false; }; + let Some(entry_started) = self.io.clock() else { + return false; + }; let Some(claim) = self.claim.take() else { return false; }; @@ -730,7 +738,7 @@ impl Run<'_, I> { .grant_entry( std::sync::Arc::clone(approved), validation, - self.evaluated_at, + entry_started, &self.pre_entry, ) .await diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 8db4296c6..76a6d6423 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -709,7 +709,11 @@ mod tests { crate::store_testkit::TestAttempts::open(crate::store_testkit::Backend::File); let crate::store::BoundedClaim::Claimed(claim) = attempts .attempts() - .claim_bounded(&approved, 1000) + .claim_bounded( + &approved, + 1000, + crate::entry::EntryValidation::Oracle { now: 1000 }, + ) .await .expect("claim") else { diff --git a/product/stores/auths-stores/src/gateway_attempt.rs b/product/stores/auths-stores/src/gateway_attempt.rs index 6cf900f53..ee0195622 100644 --- a/product/stores/auths-stores/src/gateway_attempt.rs +++ b/product/stores/auths-stores/src/gateway_attempt.rs @@ -207,7 +207,113 @@ pub enum GatewayRecordInsert { }, } +fn decision_deadline(started: Option) -> Result<(), StoreError> { + if started.is_some_and(|started| started.elapsed() >= GATEWAY_FENCE_DEADLINE) { + return Err(StoreError::Timeout); + } + Ok(()) +} + +fn insert_rows( + sql: &mut Transaction<'_>, + entries: &[GatewayRecordEntry], + started: Option, +) -> Result { + let mut order: Vec = (0..entries.len()).collect(); + order.sort_unstable_by_key(|index| entries[*index].key); + for index in order { + decision_deadline(started)?; + let entry = &entries[index]; + let digest: [u8; 32] = Sha256::digest(&entry.record).into(); + let expires_at = entry + .expires_at + .map(i64::try_from) + .transpose() + .map_err(|_| StoreError::LimitExceeded)?; + let inserted = sql + .query_opt( + "INSERT INTO auths_gateway_records + (record_key, record_kind, expires_at, record_bytes, record_sha256) + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (record_key) DO NOTHING + RETURNING record_key", + &[ + &&entry.key[..], + &entry.kind.as_str(), + &expires_at, + &entry.record, + &&digest[..], + ], + ) + .map_err(|error| map_postgres_error(&error))?; + if inserted.is_none() { + return Ok(GatewayRecordInsert::Exists { index }); + } + } + decision_deadline(started)?; + Ok(GatewayRecordInsert::Inserted) +} + impl PostgresLifecycleStore { + /// Inserts one immutable batch after one native decision over dependencies + /// under the common writer fence. Only the first record's bytes may change. + /// Conflicting keys return without invoking `decide`; no automatic retry. + /// + /// # Errors + /// Refuses invalid/overlapping read and write sets, unavailable/corrupt + /// snapshots, failed decisions, deadlines and ambiguous commit acknowledgement. + pub fn fenced_gateway_insert>( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, [u8; 32])], + decide: impl FnOnce(&[Option>]) -> Result, E>, + ) -> Result { + validate_gateway_batch(entries)?; + let mut keys: Vec<_> = entries + .iter() + .map(|entry| (entry.kind, entry.key)) + .collect(); + keys.extend_from_slice(dependencies); + validate_gateway_fence(&keys)?; + let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; + let mut sql = client + .build_transaction() + .isolation_level(IsolationLevel::ReadCommitted) + .start() + .map_err(|error| map_postgres_error(&error))?; + sql.batch_execute(&format!("SET LOCAL statement_timeout = '{}ms'; SET LOCAL idle_in_transaction_session_timeout = '{}ms'", self.gateway_statement_timeout.as_millis(), self.gateway_idle_timeout.as_millis())) + .map_err(|error| map_postgres_error(&error))?; + writer_fence(&mut sql, self.gateway_lock_timeout)?; + let started = Instant::now(); + for (index, entry) in entries.iter().enumerate() { + decision_deadline(Some(started))?; + if load_record(&mut sql, entry.kind, &entry.key)?.is_some() { + sql.rollback().map_err(|error| map_postgres_error(&error))?; + return Ok(GatewayRecordInsert::Exists { index }); + } + } + let snapshots = dependencies + .iter() + .map(|(kind, key)| { + decision_deadline(Some(started))?; + load_record(&mut sql, *kind, key) + }) + .collect::, StoreError>>()?; + decision_deadline(Some(started))?; + let next = decide(&snapshots)?; + bounded(&next)?; + let mut entries = entries.to_vec(); + entries[0].record = next; + let result = insert_rows(&mut sql, &entries, Some(started))?; + if let GatewayRecordInsert::Exists { .. } = result { + sql.rollback().map_err(|error| map_postgres_error(&error))?; + return Ok(result); + } + decision_deadline(Some(started))?; + sql.commit().map_err(|error| map_postgres_error(&error))?; + Ok(result) + } + /// Inserts every entry, or none when any key already exists. Rows are /// inserted in ascending key order inside one transaction, so two /// concurrent batches cannot deadlock. @@ -221,8 +327,6 @@ impl PostgresLifecycleStore { entries: &[GatewayRecordEntry], ) -> Result { validate_gateway_batch(entries)?; - let mut order: Vec = (0..entries.len()).collect(); - order.sort_unstable_by_key(|index| entries[*index].key); let mut client = self.pool.get().map_err(|_| StoreError::PoolExhausted)?; let mut sql = client .build_transaction() @@ -230,34 +334,10 @@ impl PostgresLifecycleStore { .start() .map_err(|error| map_postgres_error(&error))?; writer_fence(&mut sql, self.gateway_lock_timeout)?; - for index in order { - let entry = &entries[index]; - let digest: [u8; 32] = Sha256::digest(&entry.record).into(); - let expires_at = entry - .expires_at - .map(i64::try_from) - .transpose() - .map_err(|_| StoreError::LimitExceeded)?; - let inserted = sql - .query_opt( - "INSERT INTO auths_gateway_records - (record_key, record_kind, expires_at, record_bytes, record_sha256) - VALUES ($1, $2, $3, $4, $5) - ON CONFLICT (record_key) DO NOTHING - RETURNING record_key", - &[ - &&entry.key[..], - &entry.kind.as_str(), - &expires_at, - &entry.record, - &&digest[..], - ], - ) - .map_err(|error| map_postgres_error(&error))?; - if inserted.is_none() { - sql.rollback().map_err(|error| map_postgres_error(&error))?; - return Ok(GatewayRecordInsert::Exists { index }); - } + let result = insert_rows(&mut sql, entries, None)?; + if let GatewayRecordInsert::Exists { .. } = result { + sql.rollback().map_err(|error| map_postgres_error(&error))?; + return Ok(result); } sql.commit().map_err(|error| map_postgres_error(&error))?; Ok(GatewayRecordInsert::Inserted) From 2eb6d734e1795e6d713320873e9e1f43555c78a0 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 09:05:11 +0000 Subject: [PATCH 033/136] feat(gateway)!: require approved application recovery reads --- .../gateway/application-recovery-cli.json | 21 ++ .../gateway/application-recovery-frame.json | 122 ++++++++ bindings/python/README.md | 12 +- bindings/python/docs/INTEGRATION_RECIPES.md | 12 +- .../external/gateway_observation_consumer.py | 16 +- bindings/python/python/auths/gateway.py | 92 +++--- bindings/python/tests/test_gateway_client.py | 86 +++--- bindings/typescript/README.md | 10 +- bindings/typescript/docs/api-contract.md | 12 +- bindings/typescript/src/gateway.ts | 70 ++--- .../packed-gateway-observation.test.js | 5 +- .../test/unit/gateway-client.test.js | 80 +++--- compliance.toml | 8 +- ...017-bound-effect-and-recovery-ownership.md | 20 ++ docs/plans/0074-implementation-status.md | 36 ++- docs/product/SELF_HOSTED_CLAIM_LEDGER.md | 8 +- .../0009-bound-effect-and-recovery.md | 19 ++ ...ound-effects-and-recovery-state-machine.md | 9 + .../observe-pre-entry | 2 +- ...min-reobserve => obsolete-admin-reobserve} | 0 .../obsolete-read-back | 1 + .../target_gateway_app_frame/obsolete-submit | 1 + .../corpus/target_gateway_app_frame/recover | 1 + .../corpus/target_gateway_app_frame/submit | 2 +- .../fuzz_targets/target_gateway_app_frame.rs | 6 +- .../auths-gateway/fuzz/tests/corpus.rs | 2 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/app.rs | 267 +++++++++++++++++- .../auths-gateway/src/bin/auths-gateway.rs | 76 ++++- product/runtime/auths-gateway/src/effect.rs | 4 +- product/runtime/auths-gateway/src/engine.rs | 55 +--- product/runtime/auths-gateway/src/harness.rs | 78 +++-- .../auths-gateway/src/observed_tests.rs | 6 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 4 +- product/runtime/auths-gateway/src/submit.rs | 7 +- .../tests/application_recovery_cli.rs | 105 +++++++ xtask/src/fuzz.rs | 19 +- 38 files changed, 944 insertions(+), 334 deletions(-) create mode 100644 bindings/fixtures/gateway/application-recovery-cli.json create mode 100644 bindings/fixtures/gateway/application-recovery-frame.json rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/{admin-reobserve => obsolete-admin-reobserve} (100%) create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-submit create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover create mode 100644 product/runtime/auths-gateway/tests/application_recovery_cli.rs diff --git a/bindings/fixtures/gateway/application-recovery-cli.json b/bindings/fixtures/gateway/application-recovery-cli.json new file mode 100644 index 000000000..f95779746 --- /dev/null +++ b/bindings/fixtures/gateway/application-recovery-cli.json @@ -0,0 +1,21 @@ +{ + "schema": "auths.application-recovery-cli-fixture/1", + "scope": "production CLI and real Unix socket with refusal server; no installed engine/provider claim", + "request": { + "schema": "auths.gateway-recover/1", + "source_operation": "source-1", + "submission": { + "schema": "auths.gateway-submit/2", + "proof_b64": "AA", + "action_b64": "AA", + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0" + } + }, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.acquisition.binding" + } + } +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json new file mode 100644 index 000000000..9a49356f0 --- /dev/null +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -0,0 +1,122 @@ +{ + "schema": "auths.application-recovery-frame-fixture/1", + "scope": "real Unix socket and bounded decoder with counting refusal oracle; no installed native authority or provider entry claim", + "request": { + "schema": "auths.gateway-recover/1", + "source_operation": "source-1", + "submission": { + "schema": "auths.gateway-submit/2", + "proof_b64": "AA", + "action_b64": "AA", + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0" + } + }, + "cases": [ + { + "case": "bounded-envelope", + "recovery_dispatches": 1, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.acquisition.binding" + } + } + }, + { + "case": "obsolete-recovery-schema", + "recovery_dispatches": 0, + "response": { + "outcome": "refused", + "result": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "case": "obsolete-submit-schema", + "recovery_dispatches": 0, + "response": { + "outcome": "refused", + "result": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "case": "invalid-operation", + "recovery_dispatches": 0, + "response": { + "outcome": "refused", + "result": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "case": "null-approval", + "recovery_dispatches": 0, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "case": "invalid-approval", + "recovery_dispatches": 0, + "response": { + "outcome": "refused", + "result": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-encoding" + } + } + }, + { + "case": "oversized-approval", + "recovery_dispatches": 0, + "response": { + "outcome": "refused", + "result": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "case": "missing-approval", + "recovery_dispatches": 0, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "case": "transport-substitution", + "recovery_dispatches": 0, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "case": "auths.gateway-observe/2", + "recovery_dispatches": 0, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "case": "auths.gateway-observe/3", + "recovery_dispatches": 0, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + } + ] +} \ No newline at end of file diff --git a/bindings/python/README.md b/bindings/python/README.md index 97745be0c..ff88d3de2 100644 --- a/bindings/python/README.md +++ b/bindings/python/README.md @@ -37,13 +37,15 @@ print(result.outcome) There is no Auths application token, remote executor URL, or provider credential in application code. The gateway endpoint is an -operator-provisioned local socket. Every result is one closed dataclass: +operator-provisioned local socket. Every mutation result is one closed dataclass: `GatewayDenied`, `GatewayIndeterminate`, `GatewayNotEntered`, `GatewayUnknown`, `GatewayResponseRecorded`, `GatewayObserved`, or -`GatewayObservedByProvider`. The gateway can also sign a read-only observation -of a provider field (`observe_read_back`), of an operation's stored outcome -(`observe_outcome`), or return the pre-entry observations it stored for an -operation (`observe_pre_entry`). +`GatewayObservedByProvider`. The gateway also signs local stored outcomes (`observe_outcome`) and returns +stored pre-entry observations (`observe_pre_entry`). Independently approved +provider recovery uses `recover(source_operation, proof=..., action=..., +approval=...)`, returning bounded native recovery-report/refusal JSON bytes. +It returns no provider content or disclosure acknowledgement. The former +unapproved `observe_read_back` route is removed. The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, approvals from any two of three diff --git a/bindings/python/docs/INTEGRATION_RECIPES.md b/bindings/python/docs/INTEGRATION_RECIPES.md index b63be8204..b04365ef1 100644 --- a/bindings/python/docs/INTEGRATION_RECIPES.md +++ b/bindings/python/docs/INTEGRATION_RECIPES.md @@ -21,11 +21,13 @@ operator binds provider credentials to gateway connections. ## Unknown writes -A `GatewayUnknown` result means the provider write may have happened. Do not -retry it. Ask the gateway for the operation's signed outcome with -`observe_outcome`, or read the provider field back through the gateway with -`observe_read_back`. Both return gateway-signed bytes that can be attached to -a later action or kept for an offline audit. +An unknown outcome means the provider write may have happened. Read retained +local history with `observe_outcome`. Acquire new evidence only with a separately +verified read proof/action and exact approval through `recover(source_operation, proof=..., action=..., approval=...)`. Recovery +returns bounded native JSON bytes distinguishing source facts, acquisition +facts and the evidence decision. It does not return provider content, authorize +a write retry, or acknowledge recipient disclosure. Unapproved provider read-back +requests are no longer part of the application protocol. ## Operator and mechanism integration diff --git a/bindings/python/external/gateway_observation_consumer.py b/bindings/python/external/gateway_observation_consumer.py index 350baefa1..a0a2c7a9a 100644 --- a/bindings/python/external/gateway_observation_consumer.py +++ b/bindings/python/external/gateway_observation_consumer.py @@ -6,7 +6,7 @@ argument, as signed by the gateway observer at most 60 seconds before the gateway verifies. -1. Request a read-back observation. +1. Obtain a synthetic observation from the private harness control plane. 2. Attach it to the replacement action. 3. Submit: the write is authorized. 4. Change the record: the stale expectation is refused. The SDK refuses to @@ -121,7 +121,7 @@ def _bytes(text: str) -> bytes: return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)) -async def _control(socket: Path, request: dict[str, object]) -> dict[str, int]: +async def _control_response(socket: Path, request: dict[str, object]) -> dict[str, object]: reader, writer = await asyncio.open_unix_connection(str(socket)) payload = json.dumps(request).encode() writer.write(struct.pack(">I", len(payload)) + payload) @@ -132,7 +132,12 @@ async def _control(socket: Path, request: dict[str, object]) -> dict[str, int]: await writer.wait_closed() if response.get("ok") is not True: raise AssertionError(f"harness refused {request}") - return cast("dict[str, int]", response) + return cast("dict[str, object]", response) + + +async def _control(socket: Path, request: dict[str, object]) -> dict[str, int]: + response = await _control_response(socket, request) + return {key: cast(int, response[key]) for key in ("now", "writes", "reads", "leases")} class Journey: @@ -158,7 +163,10 @@ def command(self, operation: str, expected: Status, replacement: Status) -> SetS ) async def read_back(self) -> GatewaySignedObservation: - result = await self.client.observe_read_back({"record_id": self.record["record_id"]}) + response = await _control_response(self.control, {"command": "reference-read-back", "record_id": self.record["record_id"]}) + wire = cast("dict[str, object]", response["observation"]) + result = GatewaySignedObservation(cast(str, wire["schema"]), cast(str, wire["subject"]), + cast(int, wire["observed_at"]), cast(str, wire["media_type"]), _bytes(cast(str, wire["observation_b64"]))) assert isinstance(result, GatewaySignedObservation), result assert result.subject == self.record["read_back_subject"] return result diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index e84e21802..e8ff89180 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -22,22 +22,18 @@ from typing import Final, Literal, Mapping, Optional, Union, cast _REQUEST_SCHEMA = "auths.gateway-submit/2" -_OBSERVE_SCHEMA = "auths.gateway-observe/2" -_READ_BACK_SCHEMA: Final = "auths.gateway-readback/1" +_OBSERVE_SCHEMA = "auths.gateway-observe/3" _OUTCOME_SCHEMA: Final = "auths.gateway-outcome/2" _OBSERVATION_MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor" _MAX_OBSERVATION_BYTES = 4_096 _MAX_PRE_ENTRY_OBSERVATIONS = 4 _MAX_SUBJECT_BYTES = 1_024 -_MAX_READ_BACK_ARGUMENTS = 16 -_MAX_ARGUMENT_BYTES = 128 _MAX_PROOF_BYTES = 4 * 1024 * 1024 _MAX_ACTION_BYTES = 64 * 1024 # Room for four maximal pre-entry observations in one base64url response. _MAX_RESPONSE_BYTES = 32 * 1024 _ECHO = re.compile(r"auths-e1-[0-9a-f]{64}") _DIGEST = re.compile(r"[0-9a-f]{64}") -_FIELD_NAME = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,63}") _OPERATION_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}") _BASE64URL = re.compile(r"[A-Za-z0-9_-]*") _MAX_U64 = 2**64 - 1 @@ -425,30 +421,24 @@ def _parse_pre_entry_result(raw: bytes, operation_id: str) -> GatewayPreEntryRes ) -def _read_back_request(arguments: Mapping[str, str]) -> dict[str, object]: - if not isinstance(arguments, Mapping) or not ( - 1 <= len(arguments) <= _MAX_READ_BACK_ARGUMENTS - ): - raise ValueError("read-back arguments must be a bounded mapping") - checked: dict[str, str] = {} - for name, value in cast(Mapping[object, object], arguments).items(): - if not isinstance(name, str) or _FIELD_NAME.fullmatch(name) is None: - raise ValueError("read-back argument names must be recipe field names") - if ( - not isinstance(value, str) - or "\x00" in value - or not 1 - <= len(value.encode("utf-8", "surrogatepass")) - <= _MAX_ARGUMENT_BYTES - ): - raise ValueError("read-back argument values must be bounded strings") - checked[name] = value - return {"kind": "read-back", "arguments": checked} +def _submission(proof: bytes, action: bytes, approval: bytes) -> dict[str, str]: + if not isinstance(proof, bytes) or not 1 <= len(proof) <= _MAX_PROOF_BYTES: + raise ValueError("proof must be bounded bytes") + if not isinstance(action, bytes) or not 1 <= len(action) <= _MAX_ACTION_BYTES: + raise ValueError("action must be bounded bytes") + if not isinstance(approval, bytes) or not 1 <= len(approval) <= 4096: + raise ValueError("approval must be bounded native canonical bytes") + return { + "schema": _REQUEST_SCHEMA, + "proof_b64": _encode_base64url(proof), + "action_b64": _encode_base64url(action), + "approval_b64": _encode_base64url(approval), + } class GatewayClient: - """Submit canonical proof, action and exact approval bytes over the local app socket, - or request one read-only gateway-signed observation.""" + """Submit exact approved effects, acquire approved recovery evidence, or + inspect retained local history over the application socket.""" def __init__(self, endpoint: GatewayEndpoint) -> None: if not isinstance(endpoint, GatewayEndpoint): @@ -461,20 +451,8 @@ async def submit(self, *, proof: bytes, action: bytes, approval: bytes) -> Gatew An IPC failure is not a retry signal: the gateway may have entered the provider before the client lost its response. """ - if not isinstance(proof, bytes) or not 1 <= len(proof) <= _MAX_PROOF_BYTES: - raise ValueError("proof must be bounded bytes") - if not isinstance(action, bytes) or not 1 <= len(action) <= _MAX_ACTION_BYTES: - raise ValueError("action must be bounded bytes") - if not isinstance(approval, bytes) or not 1 <= len(approval) <= 4096: - raise ValueError("approval must be bounded native canonical bytes") payload = json.dumps( - { - "schema": _REQUEST_SCHEMA, - "proof_b64": _encode_base64url(proof), - "action_b64": _encode_base64url(action), - "approval_b64": _encode_base64url(approval), - }, - separators=(",", ":"), + _submission(proof, action, approval), separators=(",", ":") ).encode("utf-8") return _parse_result( await self._exchange( @@ -482,21 +460,31 @@ async def submit(self, *, proof: bytes, action: bytes, approval: bytes) -> Gatew ) ) - async def observe_read_back( - self, arguments: Mapping[str, str] - ) -> GatewayObserveResult: - """Ask the gateway to read the recipe's observed field now and sign it. - - ``arguments`` names exactly the recipe observation path's fields (for - example ``{"record_id": "rec..."}``); the gateway derives the URL, - subject, and time itself. The application learns the observed value. + async def recover( + self, source_operation: str, *, proof: bytes, action: bytes, approval: bytes + ) -> bytes: + """Return the bounded native recovery-report/refusal JSON unchanged. - Raises ``ValueError`` for unbounded or non-string arguments and - ``GatewayProtocolError`` when the socket or bounded response is - unavailable or malformed. A refusal is a result, not an exception. + The read requires its own native proof/action and exact approval. The + report separates mutation and acquisition facts and contains no provider + content. A lost reply never authorizes a retry or another provider call. """ - request = _read_back_request(arguments) - return await self._observe(request, _READ_BACK_SCHEMA) + if ( + not isinstance(source_operation, str) + or _OPERATION_ID.fullmatch(source_operation) is None + ): + raise ValueError("operation ID must be a canonical 1-128-byte token") + payload = json.dumps( + { + "schema": "auths.gateway-recover/1", + "source_operation": source_operation, + "submission": _submission(proof, action, approval), + }, + separators=(",", ":"), + ).encode("utf-8") + return await self._exchange( + payload, "gateway recovery exchange unavailable; outcome may be unknown" + ) async def observe_outcome(self, operation_id: str) -> GatewayObserveResult: """Ask the gateway to sign the stored outcome of one logical operation. diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index a449d65a9..9d386230b 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -211,30 +211,23 @@ async def handle( @pytest.mark.skipif( sys.platform == "win32", reason="first gateway deployment is Unix-only" ) -def test_client_requests_read_back_and_returns_signed_bytes(socket_dir) -> None: +def test_client_recovery_carries_exact_native_envelope_and_returns_bytes(socket_dir) -> None: + corpus = json.loads((Path(__file__).resolve().parents[2] / "fixtures/gateway/application-recovery-frame.json").read_text()) + request = corpus["request"] + def decode(field: str) -> bytes: + encoded = request["submission"][field] + return base64.urlsafe_b64decode(encoded + "=" * (-len(encoded) % 4)) async def scenario() -> None: seen: list[dict[str, object]] = [] - server = await _serve_once(socket_dir / "gateway.sock", _signed(), seen) + reply = json.dumps(corpus["cases"][0]["response"]).encode() + server = await _serve_once(socket_dir / "gateway.sock", reply, seen) async with server: client = GatewayClient(GatewayEndpoint(socket_dir / "gateway.sock")) - result = await client.observe_read_back({"record_id": "recTEST0000000001"}) - assert result == GatewaySignedObservation( - "auths.gateway-readback/1", - _SUBJECT, - 1_790_000_000, - _MEDIA_TYPE, - _OBSERVATION, - ) - assert seen == [ - { - "schema": "auths.gateway-observe/2", - "request": { - "kind": "read-back", - "arguments": {"record_id": "recTEST0000000001"}, - }, - } - ] - + result = await client.recover(request["source_operation"], proof=decode("proof_b64"), + action=decode("action_b64"), approval=decode("approval_b64")) + assert result == reply + assert seen == [request] + assert not hasattr(client, "observe_read_back") asyncio.run(scenario()) @@ -258,7 +251,7 @@ async def scenario(reply: bytes) -> tuple[object, list[dict[str, object]]]: ) assert seen == [ { - "schema": "auths.gateway-observe/2", + "schema": "auths.gateway-observe/3", "request": {"kind": "outcome", "operation_id": "step-1"}, } ] @@ -278,28 +271,28 @@ async def scenario(reply: bytes, outcome: Optional[str] = None) -> object: client = GatewayClient(GatewayEndpoint(socket_dir / "gateway.sock")) if outcome is not None: return await client.observe_outcome(outcome) - return await client.observe_read_back({"record_id": "rec1"}) + return await client.observe_outcome("step-1") # A signed read-back is not accepted as the answer to an outcome request. with pytest.raises(GatewayProtocolError): asyncio.run(scenario(_signed(), "step-1")) for hostile in [ - _signed(schema="auths.gateway-outcome/2"), - _signed(media_type="application/cbor"), - _signed(subject=""), - _signed(subject="s" * 1_025), - _signed(observed_at=-1), - _signed(observed_at=True), - _signed(observed_at="1790000000"), - _signed(observation_b64=""), - _signed(observation_b64=_b64(_OBSERVATION) + "="), - _signed(observation_b64=base64.b64encode(b"\xfb\xff").decode()), - _signed(observation_b64="AB"), - _signed(observation_b64="A"), - _signed(observation_b64="QUJD RA"), - _signed(observation_b64=_b64(b"x" * 4_097)), - _signed(confirmed=True), - _signed(observation=_b64(_OBSERVATION)), + _signed(schema="retired"), + _signed(schema="auths.gateway-outcome/2", media_type="application/cbor"), + _signed(schema="auths.gateway-outcome/2", subject=""), + _signed(schema="auths.gateway-outcome/2", subject="s" * 1_025), + _signed(schema="auths.gateway-outcome/2", observed_at=-1), + _signed(schema="auths.gateway-outcome/2", observed_at=True), + _signed(schema="auths.gateway-outcome/2", observed_at="1790000000"), + _signed(schema="auths.gateway-outcome/2", observation_b64=""), + _signed(schema="auths.gateway-outcome/2", observation_b64=_b64(_OBSERVATION) + "="), + _signed(schema="auths.gateway-outcome/2", observation_b64=base64.b64encode(b"\xfb\xff").decode()), + _signed(schema="auths.gateway-outcome/2", observation_b64="AB"), + _signed(schema="auths.gateway-outcome/2", observation_b64="A"), + _signed(schema="auths.gateway-outcome/2", observation_b64="QUJD RA"), + _signed(schema="auths.gateway-outcome/2", observation_b64=_b64(b"x" * 4_097)), + _signed(schema="auths.gateway-outcome/2", confirmed=True), + _signed(schema="auths.gateway-outcome/2", observation=_b64(_OBSERVATION)), b'{"outcome":"refused"}', b'{"outcome":"refused","code":""}', b'{"outcome":"refused","code":"x","reason":"y"}', @@ -338,7 +331,7 @@ def reply(**overrides: object) -> bytes: assert result == GatewayPreEntryObservations("step-1", (_OBSERVATION,)) assert seen == [ { - "schema": "auths.gateway-observe/2", + "schema": "auths.gateway-observe/3", "request": {"kind": "pre-entry", "operation_id": "step-1"}, } ] @@ -363,18 +356,13 @@ def reply(**overrides: object) -> bytes: def test_client_rejects_unbounded_observation_requests(socket_dir) -> None: client = GatewayClient(GatewayEndpoint(socket_dir / "gateway.sock")) - for arguments in [ - {}, - {"record_id": ""}, - {"record_id": "x" * 129}, - {"record_id": "a\x00b"}, - {"record_id": 7}, - {"-record": "rec1"}, - {f"field{index}": "v" for index in range(17)}, - ]: + assert not hasattr(client, "observe_read_back") + for proof, action, approval in [(b"", b"a", b"a"), (b"p", b"", b"a"), (b"p", b"a", b""), (b"p", b"a", b"a" * 4097)]: with pytest.raises(ValueError): - asyncio.run(client.observe_read_back(arguments)) # type: ignore[arg-type] + asyncio.run(client.recover("source-1", proof=proof, action=action, approval=approval)) for operation in ["", "-step", "step 1", "s" * 129, "stép"]: + with pytest.raises(ValueError): + asyncio.run(client.recover(operation, proof=b"p", action=b"a", approval=b"a")) with pytest.raises(ValueError): asyncio.run(client.observe_outcome(operation)) with pytest.raises(ValueError): diff --git a/bindings/typescript/README.md b/bindings/typescript/README.md index 9ced86a87..ce0c84934 100644 --- a/bindings/typescript/README.md +++ b/bindings/typescript/README.md @@ -41,10 +41,12 @@ switch (result.outcome) { There is no Auths application token, remote executor URL, or provider credential in application code. The gateway endpoint is an -operator-provisioned local socket. The gateway can also sign a read-only -observation of a provider field (`observeReadBack`), of an operation's stored -outcome (`observeOutcome`), or return the pre-entry observations it stored for -an operation (`observePreEntry`). +operator-provisioned local socket. The gateway also signs local stored outcomes (`observeOutcome`) and returns +stored pre-entry observations (`observePreEntry`). Independently approved +provider recovery uses `recover(sourceOperation, { proof, action, approval })`, +returning bounded native recovery-report/refusal JSON bytes. It returns no +provider content or disclosure acknowledgement. The former unapproved +`observeReadBack` route is removed. The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, a 2-of-3 approval quorum, gateway diff --git a/bindings/typescript/docs/api-contract.md b/bindings/typescript/docs/api-contract.md index 52efde0cc..8a0f088ea 100644 --- a/bindings/typescript/docs/api-contract.md +++ b/bindings/typescript/docs/api-contract.md @@ -23,11 +23,13 @@ or dynamic plugin. ## Unknown writes -An `unknown` result means the provider write may have happened. Applications -do not retry it blindly: they ask the gateway for the operation's signed -outcome (`observeOutcome`) or read the provider field back through the -gateway (`observeReadBack`). Both return gateway-signed bytes that can be -attached to a later action or kept for audit. +An unknown outcome means the provider write may have happened. Read retained +local history with `observeOutcome`. Acquire new evidence only with a separately +verified read proof/action and exact approval through `recover(sourceOperation, { proof, action, approval })`. Recovery +returns bounded native JSON bytes distinguishing source facts, acquisition +facts and the evidence decision. It does not return provider content, authorize +a write retry, or acknowledge recipient disclosure. Unapproved provider read-back +requests are no longer part of the application protocol. ## Other public utilities diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index de066d8f7..66e02faa6 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -8,14 +8,12 @@ import { createConnection } from "node:net"; import { platform } from "node:os"; const REQUEST_SCHEMA = "auths.gateway-submit/2"; -const OBSERVE_SCHEMA = "auths.gateway-observe/2"; +const OBSERVE_SCHEMA = "auths.gateway-observe/3"; const READ_BACK_SCHEMA = "auths.gateway-readback/1"; const OUTCOME_SCHEMA = "auths.gateway-outcome/2"; const OBSERVATION_MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor"; const MAX_OBSERVATION_BYTES = 4_096; const MAX_SUBJECT_BYTES = 1_024; -const MAX_READ_BACK_ARGUMENTS = 16; -const MAX_ARGUMENT_BYTES = 128; const MAX_PROOF_BYTES = 4 * 1024 * 1024; const MAX_ACTION_BYTES = 64 * 1024; const MAX_APPROVAL_BYTES = 4_096; @@ -29,7 +27,6 @@ const MAX_SOCKET_PATH_BYTES = SUN_PATH_BYTES - 1; const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; const ECHO = /^auths-e1-[0-9a-f]{64}$/; const DIGEST = /^[0-9a-f]{64}$/; -const FIELD_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/; const OPERATION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/; const BASE64URL = /^[A-Za-z0-9_-]*$/; @@ -336,25 +333,18 @@ function parsePreEntryResult(bytes: Uint8Array, operationId: string): GatewayPre }; } -function readBackRequest(argumentsMap: Readonly>): Record { - if (typeof argumentsMap !== "object" || argumentsMap === null || Array.isArray(argumentsMap)) { - throw new TypeError("read-back arguments must be a bounded object"); +function submission(input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Record { + if (!(input.proof instanceof Uint8Array) || input.proof.length < 1 || input.proof.length > MAX_PROOF_BYTES) { + throw new TypeError("proof must be bounded bytes"); } - const entries = Object.entries(argumentsMap as Record); - if (entries.length < 1 || entries.length > MAX_READ_BACK_ARGUMENTS) { - throw new TypeError("read-back arguments must be a bounded object"); + if (!(input.action instanceof Uint8Array) || input.action.length < 1 || input.action.length > MAX_ACTION_BYTES) { + throw new TypeError("action must be bounded bytes"); } - const checked: Record = {}; - for (const [name, value] of entries) { - if (!FIELD_NAME.test(name)) { - throw new TypeError("read-back argument names must be recipe field names"); - } - if (typeof value !== "string" || value.includes("\0") || value.length < 1 || utf8Length(value) > MAX_ARGUMENT_BYTES) { - throw new TypeError("read-back argument values must be bounded strings"); - } - checked[name] = value; + if (!(input.approval instanceof Uint8Array) || input.approval.length < 1 || input.approval.length > MAX_APPROVAL_BYTES) { + throw new TypeError("approval must be bounded native canonical bytes"); } - return { kind: "read-back", arguments: checked }; + return { schema: REQUEST_SCHEMA, proof_b64: encodeBase64Url(input.proof), + action_b64: encodeBase64Url(input.action), approval_b64: encodeBase64Url(input.approval) }; } function concatenate(parts: readonly Uint8Array[], total: number): Uint8Array { @@ -368,8 +358,8 @@ function concatenate(parts: readonly Uint8Array[], total: number): Uint8Array { } /** - * Submit only canonical proof and action bytes, or request one read-only signed - * observation; no credential or raw HTTP API exists. + * Submit exact approved effects, acquire approved recovery evidence, or inspect + * retained local history. No credential or raw HTTP API exists. */ export class GatewayClient { readonly #endpoint: GatewayEndpoint; @@ -382,34 +372,20 @@ export class GatewayClient { } async submit(input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Promise { - if (!(input.proof instanceof Uint8Array) || input.proof.length < 1 || input.proof.length > MAX_PROOF_BYTES) { - throw new TypeError("proof must be bounded bytes"); - } - if (!(input.action instanceof Uint8Array) || input.action.length < 1 || input.action.length > MAX_ACTION_BYTES) { - throw new TypeError("action must be bounded bytes"); - } - if (!(input.approval instanceof Uint8Array) || input.approval.length < 1 || input.approval.length > MAX_APPROVAL_BYTES) { - throw new TypeError("approval must be bounded native canonical bytes"); - } - const payload = new TextEncoder().encode(JSON.stringify({ - schema: REQUEST_SCHEMA, - proof_b64: encodeBase64Url(input.proof), - action_b64: encodeBase64Url(input.action), - approval_b64: encodeBase64Url(input.approval), - })); + const payload = new TextEncoder().encode(JSON.stringify(submission(input))); return this.#exchange(payload, "outcome may be unknown", parseResult); } - /** - * Asks the gateway to read the recipe's observed field now and sign what it read. - * `argumentsMap` names exactly the recipe observation path's fields (for example - * `{ record_id: "rec..." }`); the gateway derives URL, subject, and time itself, and - * the application learns the observed value. Throws `TypeError` for unbounded or - * non-string arguments and `GatewayProtocolError` for an unavailable or malformed - * exchange; a refusal is a result, not an exception. - */ - async observeReadBack(argumentsMap: Readonly>): Promise { - return this.#observe(readBackRequest(argumentsMap), READ_BACK_SCHEMA); + /** Returns bounded native recovery-report/refusal JSON unchanged. The separately + * approved read uses native admission and accounting. No provider content is + * disclosed. A lost response never authorizes a retry. */ + async recover(sourceOperation: string, input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Promise { + if (typeof sourceOperation !== "string" || !OPERATION_ID.test(sourceOperation)) { + throw new TypeError("operation ID must be a canonical 1-128-byte token"); + } + const payload = new TextEncoder().encode(JSON.stringify({ schema: "auths.gateway-recover/1", + source_operation: sourceOperation, submission: submission(input) })); + return this.#exchange(payload, "recovery outcome may be unknown", (bytes) => bytes); } /** diff --git a/bindings/typescript/test/gateway/packed-gateway-observation.test.js b/bindings/typescript/test/gateway/packed-gateway-observation.test.js index 03903a856..a081ea854 100644 --- a/bindings/typescript/test/gateway/packed-gateway-observation.test.js +++ b/bindings/typescript/test/gateway/packed-gateway-observation.test.js @@ -103,7 +103,10 @@ try { record_uri: record.read_back_subject, }); const readBack = async () => { - const observed = await client.observeReadBack({ record_id: record.record_id }); + // Synthetic reference evidence comes from the private test control plane. + const wire = (await control({ command: "reference-read-back", record_id: record.record_id })).observation; + const observed = { outcome: wire.outcome, schema: wire.schema, subject: wire.subject, + observedAt: wire.observed_at, mediaType: wire.media_type, observation: bytes(wire.observation_b64) }; if (observed.outcome !== "signed" || observed.subject !== record.read_back_subject) { throw new Error("read-back refused: " + JSON.stringify(observed)); } diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index dec3b324a..0f34e8376 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -186,23 +186,18 @@ async function observeOnce(reply, request) { } } -const readBack = (client) => client.observeReadBack({ record_id: "recTEST0000000001" }); const outcome = (client) => client.observeOutcome("step-1"); -test("gateway client requests a read-back and returns the signed observation bytes", { skip: process.platform === "win32" }, async () => { - const { result, seen } = await observeOnce(signed(), readBack); - assert.deepEqual(result, { - outcome: "signed", - schema: "auths.gateway-readback/1", - subject: SUBJECT, - observedAt: 1790000000, - mediaType: MEDIA_TYPE, - observation: OBSERVATION, - }); - assert.deepEqual(seen, [{ - schema: "auths.gateway-observe/2", - request: { kind: "read-back", arguments: { record_id: "recTEST0000000001" } }, - }]); +test("gateway recovery carries the native envelope and returns report bytes", { skip: process.platform === "win32" }, async () => { + const corpus = JSON.parse(await readFile(new URL("../../../fixtures/gateway/application-recovery-frame.json", import.meta.url), "utf8")); + const reply = JSON.stringify(corpus.cases[0].response); + const request = corpus.request; + const data = { proof: Buffer.from(request.submission.proof_b64, "base64url"), + action: Buffer.from(request.submission.action_b64, "base64url"), + approval: Buffer.from(request.submission.approval_b64, "base64url") }; + const { result, seen } = await observeOnce(reply, (client) => client.recover(request.source_operation, data)); + assert.equal(new TextDecoder().decode(result), reply); + assert.deepEqual(seen, [request]); }); test("gateway client requests an outcome and surfaces a refusal as a result", { skip: process.platform === "win32" }, async () => { @@ -213,7 +208,7 @@ test("gateway client requests an outcome and surfaces a refusal as a result", { assert.equal(signedOutcome.result.subject, subject); assert.deepEqual(signedOutcome.result.observation, OBSERVATION); assert.deepEqual(signedOutcome.seen, [{ - schema: "auths.gateway-observe/2", + schema: "auths.gateway-observe/3", request: { kind: "outcome", operation_id: "step-1" }, }]); const refused = await observeOnce('{"outcome":"refused","code":"gateway.observer.not-provisioned"}', outcome); @@ -224,22 +219,22 @@ test("gateway client rejects malformed observation frames", { skip: process.plat // A signed read-back is not accepted as the answer to an outcome request. await assert.rejects(observeOnce(signed(), outcome), GatewayProtocolError); for (const hostile of [ - signed({ schema: "auths.gateway-outcome/2" }), - signed({ media_type: "application/cbor" }), - signed({ subject: "" }), - signed({ subject: "s".repeat(1025) }), - signed({ observed_at: -1 }), - signed({ observed_at: 1.5 }), - signed({ observed_at: "1790000000" }), - signed({ observation_b64: "" }), - signed({ observation_b64: `${Buffer.from(OBSERVATION).toString("base64url")}=` }), - signed({ observation_b64: "+/8=" }), - signed({ observation_b64: "AB" }), - signed({ observation_b64: "A" }), - signed({ observation_b64: "QUJD RA" }), - signed({ observation_b64: Buffer.alloc(4097, 1).toString("base64url") }), - signed({ confirmed: true }), - signed({ observation: "AAAA" }), + signed({ schema: "retired" }), + signed({ schema: "auths.gateway-outcome/2", media_type: "application/cbor" }), + signed({ schema: "auths.gateway-outcome/2", subject: "" }), + signed({ schema: "auths.gateway-outcome/2", subject: "s".repeat(1025) }), + signed({ schema: "auths.gateway-outcome/2", observed_at: -1 }), + signed({ schema: "auths.gateway-outcome/2", observed_at: 1.5 }), + signed({ schema: "auths.gateway-outcome/2", observed_at: "1790000000" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: "" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: `${Buffer.from(OBSERVATION).toString("base64url")}=` }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: "+/8=" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: "AB" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: "A" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: "QUJD RA" }), + signed({ schema: "auths.gateway-outcome/2", observation_b64: Buffer.alloc(4097, 1).toString("base64url") }), + signed({ schema: "auths.gateway-outcome/2", confirmed: true }), + signed({ schema: "auths.gateway-outcome/2", observation: "AAAA" }), '{"outcome":"refused"}', '{"outcome":"refused","code":""}', '{"outcome":"refused","code":"x","reason":"y"}', @@ -248,7 +243,7 @@ test("gateway client rejects malformed observation frames", { skip: process.plat "[]", "not json", ]) { - await assert.rejects(observeOnce(hostile, readBack), GatewayProtocolError, hostile.slice(0, 80)); + await assert.rejects(observeOnce(hostile, outcome), GatewayProtocolError, hostile.slice(0, 80)); } }); @@ -262,7 +257,7 @@ test("gateway client requests stored pre-entry observations and refuses malforme }); const { result, seen } = await observeOnce(reply(), preEntry); assert.deepEqual(result, { outcome: "pre-entry", operationId: "step-1", observations: [OBSERVATION] }); - assert.deepEqual(seen, [{ schema: "auths.gateway-observe/2", request: { kind: "pre-entry", operation_id: "step-1" } }]); + assert.deepEqual(seen, [{ schema: "auths.gateway-observe/3", request: { kind: "pre-entry", operation_id: "step-1" } }]); const empty = await observeOnce(reply({ observations_b64: [] }), preEntry); assert.deepEqual(empty.result, { outcome: "pre-entry", operationId: "step-1", observations: [] }); const refused = await observeOnce('{"outcome":"refused","code":"gateway.observer.operation-unknown"}', preEntry); @@ -282,20 +277,13 @@ test("gateway client requests stored pre-entry observations and refuses malforme test("gateway client refuses unbounded observation requests before connecting", async () => { const client = new GatewayClient(new GatewayEndpoint("/tmp/auths-test.sock")); - for (const argumentsMap of [ - {}, - [], - null, - { record_id: "" }, - { record_id: "x".repeat(129) }, - { record_id: "a\0b" }, - { record_id: 7 }, - { "-record": "rec1" }, - Object.fromEntries(Array.from({ length: 17 }, (_, index) => [`field${index}`, "v"])), - ]) { - await assert.rejects(client.observeReadBack(argumentsMap), TypeError); + assert.equal("observeReadBack" in client, false); + for (const data of [{ proof: new Uint8Array(), action: new Uint8Array([1]), approval: new Uint8Array([1]) }, + { proof: new Uint8Array([1]), action: new Uint8Array([1]), approval: new Uint8Array(4097) }]) { + await assert.rejects(client.recover("source-1", data), TypeError); } for (const operation of ["", "-step", "step 1", "s".repeat(129), "stép", 7]) { + await assert.rejects(client.recover(operation, { proof: new Uint8Array([1]), action: new Uint8Array([1]), approval: new Uint8Array([1]) }), TypeError); await assert.rejects(client.observeOutcome(operation), TypeError); await assert.rejects(client.observePreEntry(operation), TypeError); } diff --git a/compliance.toml b/compliance.toml index b4eb5cf6e..4f3759adf 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/8", "auths.gateway-outcome/2", "auths.gateway-observe/2", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/9", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,8 +1600,8 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/8", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/2", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/9", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1621,6 +1621,8 @@ recovery-compilation = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] effect-replay = [ + "product/runtime/auths-gateway/src/app.rs#native_application_recovery_frame_fixture_is_current", + "product/runtime/auths-gateway/tests/application_recovery_cli.rs#native_application_recovery_cli_fixture_is_current", "product/runtime/auths-gateway/src/scenario_tests.rs#native_replay_projection_fixture_is_current", "bindings/python/tests/test_gateway_client.py#test_native_replay_projection_corpus", "bindings/typescript/test/unit/gateway-client.test.js", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 6e804f869..c6d7d56b5 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -556,3 +556,23 @@ than reused from the earlier candidate evaluation. histories with an explicit-time approval oracle. It does not establish installed native revocation, PostgreSQL execution or process fault qualification. The same adapter conformance source is available for the hosted PostgreSQL fixture. + + +## Application recovery cutover + +The application observation socket must not turn caller-supplied recipe path +arguments into unapproved credential-bearing reads. Remove its `read-back` +request and CLI/SDK convenience methods directly. `observe` retains only local +outcome and pre-entry history projections. A new closed application recovery +frame supplies the source operation and the existing bounded native +proof/action/exact-approval envelope; it calls the same engine recovery method +as the operator interface and returns only the native redacted recovery report +or native refusal. It cannot supply a URL, request body, credential or time. +No provider body or newly signed provider value is disclosed by this route. + +The old observation evaluator remains a test-only reference, reachable only +through direct tests and the private synthetic harness control plane. It is +removed from the shared application protocol even in harness builds. General +acquisition/disclosure and the installed approval journey remain separate +unfinished requirements; this cutover must not present a report as disclosure +or a provider response as a successful mutation. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 7371f86f6..79ce207e3 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -671,6 +671,40 @@ closure regeneration passed after that correction (one artifact-generation test) authority/adapter/process faults, differential/formal/performance and final hosted evidence remain required. +## Application recovery route checkpoint + +- Removed the unapproved provider `read-back` request from the production + engine, application protocol, CLI and Python/TypeScript client methods. + Observation `/3` exposes local outcome/pre-entry history only; `/2` is refused. + Application `auths.gateway-recover/1` carries a source operation and the same + bounded native proof/action/exact-approval envelope as operator recovery. +- The application adapter calls `GatewayEngine::recover` directly. It returns + only the native redacted recovery report or native refusal, never provider + response bytes or a newly signed provider field. Existing source eligibility, + native verification, exact approval, capacity, fencing and refinement still + apply. This is not general content acquisition or recipient disclosure. +- CLI `app-recover` and SDK `recover` methods use this frame. Thin clients return + bounded native JSON bytes unchanged; authored parity tests use the native + frame corpus. The old synthetic observation reference now lives only in + direct tests and the private test harness control socket, never the shared + application route. Maintained reference consumers and current docs reflect + that restricted scope. The synthetic submission harness refuses recovery + rather than pretending to implement installed authority. +- Native artifact construction passed: application socket framing/dispatch and + production CLI/socket round trip, including the harness feature build. The + counting/refusal server establishes decoder, routing and exact transport + bytes; it does not establish installed authorization or provider execution. + Retired submit/admin/read-back fuzz seeds are explicit rejection cases, with + current submit/recovery seeds generated from the native envelope. +- Test-only raw claim/approval helpers no longer compile into the standalone + harness when unused. Final source closure is regenerated with this slice. + No broad local suite, language suite or hosted CI was run/observed, and no + A01–A22 acceptance gate closes. +- Remaining: onboarding/rotation reads and recovery ancillary reads, safe + credential replacement, managed read-policy limits, general acquisition and + controlled disclosure/ACK, Python-owner removal, authenticated UI/bindings, + and complete installed/process/PostgreSQL/fault/formal/performance/CI evidence. + ## Phase gates | Phase | State | Outstanding gate | @@ -678,7 +712,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery and prerequisite acquisition routes wired | Application/onboarding read cutovers, disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes wired | Onboarding/rotation and ancillary reads, general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/product/SELF_HOSTED_CLAIM_LEDGER.md b/docs/product/SELF_HOSTED_CLAIM_LEDGER.md index 4c31ffc13..804bb16c7 100644 --- a/docs/product/SELF_HOSTED_CLAIM_LEDGER.md +++ b/docs/product/SELF_HOSTED_CLAIM_LEDGER.md @@ -209,9 +209,11 @@ observation never satisfies; and an observer that is also in the authority chain is refused. **The live Airtable run has not been done**, no hosted CI result is cited here, and no document may yet describe gateway grants as conditioned on observed provider state. The Python and TypeScript gateway -clients expose the observation request (`observe_read_back`/`observe_outcome`, -`observeReadBack`/`observeOutcome`) and return the exact signed bytes and -media type, parsed as a closed result. Both SDKs can now attach a returned +clients expose local outcome/pre-entry history and independently approved +recovery. AP074 removes the unapproved application read-back request. Synthetic +read-back observations for the reference journey now come only from the private +harness control socket; they do not establish managed acquisition or disclosure. +Both SDKs can now attach a returned observation to the next action (`attach_observations`/`attachObservations`, or `observations` on the authoring functions). The descriptors are bound by the action signature, and the SDK's final verification reaches the gateway's diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 92839a1d6..0ae35d6db 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -328,3 +328,22 @@ writer-before-admission dependency order. Authority uses the explicit-time approval oracle; opaque dependency bytes exercise adapter ordering, not native revocation semantics. The same conformance source is authored for PostgreSQL. Installed authority races, process faults and performance remain required. + + +## Application provider-read cutover + +The application `read-back` request previously had neither native proof nor +exact approval and could make credential/account checks and a provider read. +It is removed from production, the shared application frame, CLI and SDKs. +The existing native recovery engine now also serves a closed application frame +with separate proof/action/approval. It preserves source/read distinctions and +returns only the already-defined redacted report. The same bounded decoder and +engine serve operator and application callers; no second decision owner exists. + +`application-recovery-frame.json` constructs real Unix socket decoder/dispatch +histories with a counting refusal oracle, including obsolete schemas, omitted +or malformed approvals, invalid source IDs and transport substitution. +`application-recovery-cli.json` captures the production CLI's exact request and +response over a real socket. These are transport artifacts, not installed proof, +provider, disclosure or end-to-end acceptance evidence. The independent old +observation evaluator remains confined to test-only reference/control paths. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 85f8c362f..1cdd1c8bb 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -107,6 +107,15 @@ available to the agent may bypass these gates or substitute caller-controlled transport bytes. An operator commissioning path must satisfy the same effect binding, approval and entry protocol in addition to its commissioning authority. +The application protocol `auths.gateway-observe/3` accepts only local outcome +and pre-entry history queries. Obsolete observation schemas and the unapproved +`read-back` request are rejected. `auths.gateway-recover/1` supplies a source +operation and the bounded `auths.gateway-submit/2` proof/action/approval envelope +for an independently authorized recovery read. It invokes the same native +engine and returns only a redacted recovery report or native refusal. Neither +route authorizes disclosure of acquired provider content. The former raw read +helper is a test-only reference on the private synthetic harness control plane. + State the deployment threat model: an untrusted agent process is outside the credential, private review, journal and operator boundaries. The trusted host, gateway operator, custody service and configured transport enforce those diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry index 0629d67fd..440d2527a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry @@ -1 +1 @@ -{"schema": "auths.gateway-observe/2", "request": {"kind": "pre-entry", "operation_id": "refund-1"}} \ No newline at end of file +{"schema": "auths.gateway-observe/3", "request": {"kind": "pre-entry", "operation_id": "refund-1"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/admin-reobserve b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-admin-reobserve similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/admin-reobserve rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-admin-reobserve diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back new file mode 100644 index 000000000..ff67e7a27 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back @@ -0,0 +1 @@ +{"schema":"auths.gateway-observe/3","request":{"kind":"read-back","arguments":{"record_id":"recTEST0000000001"}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-submit new file mode 100644 index 000000000..5eada08fd --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-submit @@ -0,0 +1 @@ +{"schema": "auths.gateway-submit/1", "proof_b64": "AA", "action_b64": "AA"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover new file mode 100644 index 000000000..b7c71765d --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover @@ -0,0 +1 @@ +{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit index 5eada08fd..b1d9cc8c4 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit @@ -1 +1 @@ -{"schema": "auths.gateway-submit/1", "proof_b64": "AA", "action_b64": "AA"} \ No newline at end of file +{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs index 1a5208e15..983848a2b 100644 --- a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs +++ b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs @@ -4,7 +4,7 @@ #![no_main] use auths_gateway::admin::{ADMIN_REQUEST_SCHEMA, parse_admin_request}; -use auths_gateway::app::{APP_OBSERVE_SCHEMA, APP_REQUEST_SCHEMA}; +use auths_gateway::app::{APP_OBSERVE_SCHEMA, APP_RECOVERY_SCHEMA, APP_REQUEST_SCHEMA}; use auths_gateway::fuzzing; use libfuzzer_sys::fuzz_target; use serde_json::Value; @@ -23,7 +23,9 @@ fuzz_target!(|data: &[u8]| { if let Some(kind) = fuzzing::app_frame_kind(data) { let expected = match kind { "submit" => APP_REQUEST_SCHEMA, - _ => APP_OBSERVE_SCHEMA, + "observe" => APP_OBSERVE_SCHEMA, + "recover" => APP_RECOVERY_SCHEMA, + _ => panic!("unknown closed application frame"), }; assert_eq!(schema().as_deref(), Some(expected)); } diff --git a/product/runtime/auths-gateway/fuzz/tests/corpus.rs b/product/runtime/auths-gateway/fuzz/tests/corpus.rs index 80d7e45fe..95f1fca4e 100644 --- a/product/runtime/auths-gateway/fuzz/tests/corpus.rs +++ b/product/runtime/auths-gateway/fuzz/tests/corpus.rs @@ -141,6 +141,6 @@ fn frame_seeds_parse_as_their_closed_schemas() { for (name, data) in seeds("target_gateway_app_frame") { let parsed = fuzzing::app_frame_kind(&data).is_some() || auths_gateway::admin::parse_admin_request(&data).is_ok(); - assert!(parsed, "{name}"); + assert_eq!(parsed, !name.starts_with("obsolete-"), "{name}"); } } diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 752377f51..9235f7c67 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"93216bf6958c0e681ac89ccef648d9e9d32336188b04fc3fa0bb331c0d19190f"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"2a7e7e1f28d457734a9da00f954e9a3bf7d5657297596c09236a3e1b559735d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"968d7f8bcbac0792b4ef06863abc4176dbca798e9aa1e31ce9e2ef80ef1176d2"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"7a56da89947cde6dfa30e5f7f7459dc9ae0bceec824da2d0fac909752c043cbd"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"83367b3ce047bec872c16f29550a82524ff707f10f596fe0e83455b8844c182c"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"10a69f27a0bb27dfe8522e94b80d9ef9281250463863d092afbf8a7e0242083f"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"a2875a1d2d24e6b2c08c00360c046cae6a382856cac5a53c63666a42dabf7258"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"2e71e33c9dc31a799a621d0e87886ffe4d9d739635a4505522e0c9b35dd6146b"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5508c30098625683df3c9288c6cd794015a46765cd5ce2d8c57004d578b5dc1d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"20a5703919a5e94c5d99766cdc7c7f52f2a1e3d07deaf6204e7acd6bcff1192b"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"74abfc3e8d3fd66ee4d8f846185b7e7aa818e0e336330b40be60068add3a40e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"6f09d396c7a2783f77fa9b9036b43b51c38b559ed86c45d591ff81b65a518c59"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"d351284a2ab7fb3b2699c2cdaa847bc57be076ccae7fbd6e33dc52c541426818"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"7a56da89947cde6dfa30e5f7f7459dc9ae0bceec824da2d0fac909752c043cbd"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"83367b3ce047bec872c16f29550a82524ff707f10f596fe0e83455b8844c182c"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"428844f4ad3d85daa6cebcb67504f6bb72bddd450f2ca0878a67cb7c36ac8938"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5508c30098625683df3c9288c6cd794015a46765cd5ce2d8c57004d578b5dc1d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"a4e3841f45f460f4941d4b0256d47f2de5dcca6403d5bc8324c156bc1b29a169"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"74abfc3e8d3fd66ee4d8f846185b7e7aa818e0e336330b40be60068add3a40e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"c02d7f4d30c0c756a7c281276e143f57c73a519e888423f7f1c7a89fa9eff1b3"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 6915184d3..88677d8c7 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -1,6 +1,6 @@ //! The application-socket protocol: one length-prefixed JSON frame in, one -//! out. A frame is exactly one of two closed schemas, a proof/action -//! submission or an observation request; anything else is refused without +//! out. Frames carry a proof/action submission, independently approved recovery, +//! or retained local history; anything else is refused without //! reaching the application. use crate::effect::{ExactEffectApproval, MAX_EFFECT_APPROVAL_BYTES}; @@ -18,7 +18,9 @@ use zeroize::{Zeroize as _, Zeroizing}; /// Schema of a proof/action submission frame. pub const APP_REQUEST_SCHEMA: &str = "auths.gateway-submit/2"; /// Schema of an observation request frame. -pub const APP_OBSERVE_SCHEMA: &str = "auths.gateway-observe/2"; +pub const APP_OBSERVE_SCHEMA: &str = "auths.gateway-observe/3"; +/// Independently approved recovery acquisition and evidence refinement. +pub const APP_RECOVERY_SCHEMA: &str = "auths.gateway-recover/1"; /// Largest frame either side accepts. pub const MAX_FRAME_BYTES: usize = 8 * 1024 * 1024; @@ -199,16 +201,62 @@ pub struct AppObservation { pub request: GatewayObserveRequest, } -/// Every application frame is exactly one of the two closed schemas. +/// One separately authorized provider recovery read. The nested submission +/// uses the same bounded canonical decoder as mutation and operator recovery. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppRecovery { + /// Must equal `APP_RECOVERY_SCHEMA`. + pub schema: String, + /// Original retained mutation, never a provider path. + pub source_operation: String, + /// Native read authority and exact approval. + pub submission: AppSubmission, +} + +impl AppRecovery { + /// Decodes transport data only; native compilation still establishes authority. + /// + /// # Errors + /// Refuses obsolete schema, invalid operation and invalid native envelope. + pub fn decode(&self) -> Result { + if self.schema != APP_RECOVERY_SCHEMA + || crate::LogicalOperationId::parse(&self.source_operation).is_err() + { + return Err("gateway.submit.invalid-frame"); + } + self.submission.decode() + } +} + +/// Redacted native facts or a native refusal. No response body or signed +/// provider value is released through this channel. +#[derive(Serialize)] +#[serde(tag = "outcome", rename_all = "kebab-case")] +pub enum AppRecoveryResult { + /// Distinct retained mutation/acquisition facts, not a claim of success. + RecoveryReport { + /// Native redacted source/acquisition projection. + report: crate::GatewayRecoveryReport, + }, + /// Native refusal/indeterminate outcome preserves its stable code. + Refused { + /// Original native stage and refusal code. + result: GatewaySubmitResult, + }, +} + +/// Every application frame selects one closed native operation. #[derive(Deserialize)] #[serde(untagged)] enum AppFrame { Submit(AppSubmission), Observe(AppObservation), + Recover(AppRecovery), } /// Which closed frame `bytes` parse as, schema included: `submit`, -/// `observe`, or `None`. +/// `observe`, `recover`, or `None`. #[cfg(feature = "fuzzing")] pub(crate) fn frame_kind(bytes: &[u8]) -> Option<&'static str> { match serde_json::from_slice::(bytes).ok()? { @@ -218,6 +266,7 @@ pub(crate) fn frame_kind(bytes: &[u8]) -> Option<&'static str> { AppFrame::Observe(observation) => { (observation.schema == APP_OBSERVE_SCHEMA).then_some("observe") } + AppFrame::Recover(recovery) => recovery.decode().ok().map(|_| "recover"), } } @@ -232,7 +281,16 @@ pub trait GatewayApplication { approval: ExactEffectApproval, ) -> impl Future; - /// Signs one read-only observation. + /// Acquires separately approved recovery evidence through the native engine. + fn recover( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> impl Future; + + /// Signs or returns retained local history, without provider I/O. fn observe( &self, request: &GatewayObserveRequest, @@ -249,6 +307,21 @@ impl GatewayApplication for GatewayEngine { GatewayEngine::submit(self, proof, action, approval).await } + async fn recover( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> AppRecoveryResult { + match GatewayEngine::recover(self, source_operation, proof, action, approval).await { + Ok(snapshot) => AppRecoveryResult::RecoveryReport { + report: snapshot.report(), + }, + Err(result) => AppRecoveryResult::Refused { result }, + } + } + async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { GatewayEngine::observe(self, request).await } @@ -313,6 +386,27 @@ async fn submit_frame(submission: AppSubmission, application: &impl GatewayAppli serde_json::to_vec(&result).unwrap_or_default() } +async fn recovery_frame(recovery: AppRecovery, application: &impl GatewayApplication) -> Vec { + let result = match recovery.decode() { + Ok(decoded) => { + application + .recover( + &recovery.source_operation, + &decoded.proof, + &decoded.action, + decoded.approval, + ) + .await + } + Err(code) => AppRecoveryResult::Refused { + result: GatewaySubmitResult::Indeterminate { + code: code.to_owned(), + }, + }, + }; + serde_json::to_vec(&result).unwrap_or_default() +} + async fn observe_frame( observation: AppObservation, application: &impl GatewayApplication, @@ -348,6 +442,7 @@ pub async fn app_session_within( Ok(bytes) => match serde_json::from_slice::(&bytes) { Ok(AppFrame::Submit(submission)) => submit_frame(submission, application).await, Ok(AppFrame::Observe(observation)) => observe_frame(observation, application).await, + Ok(AppFrame::Recover(recovery)) => recovery_frame(recovery, application).await, Err(_) => serde_json::to_vec(&invalid_frame()).unwrap_or_default(), }, Err(_) => serde_json::to_vec(&invalid_frame()).unwrap_or_default(), @@ -401,6 +496,20 @@ mod tests { } } + async fn recover( + &self, + _source: &str, + _proof: &[u8], + _action: &[u8], + _approval: ExactEffectApproval, + ) -> AppRecoveryResult { + AppRecoveryResult::Refused { + result: GatewaySubmitResult::NotEntered { + code: "test.unused".to_owned(), + }, + } + } + async fn observe(&self, _request: &GatewayObserveRequest) -> GatewayObserveResult { GatewayObserveResult::Refused { code: "test.unused".to_owned(), @@ -544,7 +653,8 @@ mod tests { "schema": APP_OBSERVE_SCHEMA, "request": {"kind": "outcome", "operation_id": "step-1"} }); - for frame in [&read_back, &outcome] { + assert!(serde_json::from_value::(read_back.clone()).is_err()); + for frame in [&outcome] { assert!(matches!( serde_json::from_value::(frame.clone()), Ok(AppFrame::Observe(_)) @@ -576,4 +686,147 @@ mod tests { unknown["request"]["kind"] = serde_json::Value::String("write".to_owned()); assert!(serde_json::from_value::(unknown).is_err()); } + + /// Real socket framing/dispatch evidence. The application is a counting + /// refusal oracle; this does not claim installed proof or provider entry. + #[tokio::test] + #[allow( + clippy::too_many_lines, + reason = "one bounded framing corpus keeps mutations and dispatch evidence together" + )] + async fn native_application_recovery_frame_fixture_is_current() { + use std::sync::atomic::AtomicUsize; + struct Counted { + calls: AtomicUsize, + } + impl GatewayApplication for Counted { + async fn submit( + &self, + _: &[u8], + _: &[u8], + _: ExactEffectApproval, + ) -> GatewaySubmitResult { + panic!("wrong route") + } + async fn observe(&self, _: &GatewayObserveRequest) -> GatewayObserveResult { + panic!("provider read used observation route") + } + async fn recover( + &self, + source: &str, + proof: &[u8], + action: &[u8], + _: ExactEffectApproval, + ) -> AppRecoveryResult { + assert_eq!(source, "source-1"); + assert_eq!(proof, &[0]); + assert_eq!(action, &[0]); + self.calls.fetch_add(1, Ordering::SeqCst); + AppRecoveryResult::Refused { + result: GatewaySubmitResult::NotEntered { + code: "gateway.acquisition.binding".to_owned(), + }, + } + } + } + let native: serde_json::Value = serde_json::from_slice(&submission()).expect("submission"); + let valid = serde_json::json!({"schema": APP_RECOVERY_SCHEMA, "source_operation": "source-1", "submission": native}); + let corpus_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("fuzz/corpus/target_gateway_app_frame"); + for (name, frame) in [ + ("recover", valid.clone()), + ("submit", valid["submission"].clone()), + ( + "obsolete-read-back", + serde_json::json!({"schema": APP_OBSERVE_SCHEMA, + "request": {"kind": "read-back", "arguments": {"record_id": "recTEST0000000001"}}}), + ), + ] { + let bytes = serde_json::to_vec(&frame).expect("seed"); + let path = corpus_root.join(name); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("seed"); + } + assert_eq!(std::fs::read(path).expect("seed"), bytes); + } + let mut cases = vec![("bounded-envelope", valid.clone(), true)]; + for (name, pointer, replacement) in [ + ( + "obsolete-recovery-schema", + "/schema", + serde_json::json!("auths.gateway-recover/0"), + ), + ( + "obsolete-submit-schema", + "/submission/schema", + serde_json::json!("auths.gateway-submit/1"), + ), + ( + "invalid-operation", + "/source_operation", + serde_json::json!("../other"), + ), + ( + "null-approval", + "/submission/approval_b64", + serde_json::Value::Null, + ), + ( + "invalid-approval", + "/submission/approval_b64", + serde_json::json!("AA"), + ), + ( + "oversized-approval", + "/submission/approval_b64", + serde_json::json!("A".repeat(MAX_EFFECT_APPROVAL_BYTES * 2)), + ), + ] { + let mut frame = valid.clone(); + *frame.pointer_mut(pointer).expect("field") = replacement; + cases.push((name, frame, false)); + } + let mut missing = valid.clone(); + missing["submission"] + .as_object_mut() + .expect("submission") + .remove("approval_b64"); + cases.push(("missing-approval", missing, false)); + let mut substituted = valid.clone(); + substituted["url"] = serde_json::json!("https://attacker.example"); + cases.push(("transport-substitution", substituted, false)); + for schema in ["auths.gateway-observe/2", APP_OBSERVE_SCHEMA] { + cases.push((schema, serde_json::json!({"schema": schema, "request": {"kind": "read-back", "arguments": {"record_id": "recTEST0000000001"}}}), false)); + } + let mut evidence = Vec::new(); + for (name, frame, dispatched) in cases { + let application = Arc::new(Counted { + calls: AtomicUsize::new(0), + }); + let (mut client, server) = UnixStream::pair().expect("socket pair"); + let held = Arc::clone(&application); + let task = tokio::spawn(async move { app_session(server, &*held).await }); + write_frame(&mut client, &serde_json::to_vec(&frame).expect("frame")) + .await + .expect("write"); + let response: serde_json::Value = + serde_json::from_slice(&read_frame(&mut client).await.expect("response")) + .expect("JSON"); + task.await.expect("server"); + let calls = application.calls.load(Ordering::SeqCst); + assert_eq!(calls, usize::from(dispatched)); + evidence.push(serde_json::json!({"case": name, "recovery_dispatches": calls, "response": response})); + } + let fixture = serde_json::to_vec_pretty(&serde_json::json!({ + "schema": "auths.application-recovery-frame-fixture/1", + "scope": "real Unix socket and bounded decoder with counting refusal oracle; no installed native authority or provider entry claim", + "request": valid, "cases": evidence, + })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/application-recovery-frame.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); + } } diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index a62dd7501..339c86a1f 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -657,13 +657,10 @@ mod unix { }, /// Ask the app socket for one signed observation, or for one /// operation's stored pre-entry observations; never a write. - #[command(group(clap::ArgGroup::new("request").required(true).args(["read_back", "outcome", "pre_entry"])))] + #[command(group(clap::ArgGroup::new("request").required(true).args(["outcome", "pre_entry"])))] Observe { #[arg(long)] app_socket: PathBuf, - /// JSON object naming exactly the recipe observation path fields. - #[arg(long)] - read_back: Option, /// Logical operation ID whose stored outcome to sign. #[arg(long)] outcome: Option, @@ -672,6 +669,19 @@ mod unix { #[arg(long)] pre_entry: Option, }, + /// Acquire/refine separately approved evidence through the application socket. + AppRecover { + #[arg(long)] + app_socket: PathBuf, + #[arg(long)] + source_operation: String, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + }, /// Check offline whether a provider record holds one action's echo /// token. Reads no network and no gateway state; exits 0 only on a /// match, which shows consistency with the action, not authorship. @@ -3148,19 +3158,51 @@ mod unix { Ok(()) } + async fn app_recover( + socket: PathBuf, + source_operation: String, + proof: PathBuf, + action: PathBuf, + approval: PathBuf, + ) -> Result<(), Failure> { + let request = auths_gateway::app::AppRecovery { + schema: auths_gateway::app::APP_RECOVERY_SCHEMA.to_owned(), + source_operation, + submission: AppSubmission { + schema: APP_REQUEST_SCHEMA.to_owned(), + proof_b64: Base64UrlUnpadded::encode_string(&read_bounded( + &proof, + 4 * 1024 * 1024, + )?), + action_b64: Base64UrlUnpadded::encode_string(&read_bounded(&action, 64 * 1024)?), + approval_b64: Base64UrlUnpadded::encode_string(&read_bounded( + &approval, + auths_gateway::effect::MAX_EFFECT_APPROVAL_BYTES, + )?), + }, + }; + request.decode()?; + let bytes = serde_json::to_vec(&request).map_err(|_| "gateway.submit.encoding-failed")?; + let mut stream = connect_app_socket(&socket, "gateway.submit.socket-unavailable").await?; + write_frame(&mut stream, &bytes).await?; + let response = read_frame(&mut stream).await?; + let result: serde_json::Value = + serde_json::from_slice(&response).map_err(|_| "gateway.submit.invalid-response")?; + println!( + "{}", + serde_json::to_string(&result).map_err(|_| "gateway.submit.invalid-response")? + ); + Ok(()) + } + async fn observe( socket: PathBuf, - read_back: Option, outcome: Option, pre_entry: Option, ) -> Result<(), Failure> { - let request = match (read_back, outcome, pre_entry) { - (Some(arguments), None, None) => GatewayObserveRequest::ReadBack { - arguments: serde_json::from_str(&arguments) - .map_err(|_| "gateway.observe.invalid-arguments")?, - }, - (None, Some(operation_id), None) => GatewayObserveRequest::Outcome { operation_id }, - (None, None, Some(operation_id)) => GatewayObserveRequest::PreEntry { operation_id }, + let request = match (outcome, pre_entry) { + (Some(operation_id), None) => GatewayObserveRequest::Outcome { operation_id }, + (None, Some(operation_id)) => GatewayObserveRequest::PreEntry { operation_id }, _ => return Err("gateway.observe.invalid-request".into()), }; let bytes = serde_json::to_vec(&AppObservation { @@ -4331,12 +4373,18 @@ mod unix { } Command::ObserverInit { state_dir } => observer_init(&state_dir), Command::ObserverShow { state_dir } => observer_show(&state_dir), + Command::AppRecover { + app_socket, + source_operation, + proof, + action, + approval, + } => app_recover(app_socket, source_operation, proof, action, approval).await, Command::Observe { app_socket, - read_back, outcome, pre_entry, - } => observe(app_socket, read_back, outcome, pre_entry).await, + } => observe(app_socket, outcome, pre_entry).await, Command::EchoVerify { record, pointer, diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 8899e2fd2..390808a1c 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -186,7 +186,7 @@ impl EffectPolicy { /// Post-verification driver oracle only. It deliberately does not establish /// installed native authority, isolation or a real human review. Production /// builds cannot construct this fixture or select it through an app request. -#[cfg(any(test, feature = "testkit-harness"))] +#[cfg(test)] pub(crate) fn approve_driver_fixture( command: VerifiedCommand, recipe_digest: [u8; 32], @@ -334,7 +334,7 @@ pub(crate) fn store_binding_fixture( } /// Signs synthetic store oracle data with the fixed test-only approver. -#[cfg(any(test, feature = "testkit-harness"))] +#[cfg(test)] pub(crate) fn approval_fixture( binding: &EffectBinding, now: u64, diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 5a38102d1..12534ed53 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -12,8 +12,7 @@ use crate::connection::{ }; use crate::effect::{ApprovedEffect, ExactEffectApproval}; use crate::observer::{ - GatewayObserver, GatewaySignedObservation, OUTCOME_SCHEMA, READ_BACK_SCHEMA, operation_subject, - outcome_facts, read_back_facts, + GatewayObserver, GatewaySignedObservation, OUTCOME_SCHEMA, operation_subject, outcome_facts, }; use crate::recipe::{ENTRY_DEADLINE_SECONDS, GuardChecks}; use crate::submit::{self, SubmitContext, SubmitIo}; @@ -21,9 +20,14 @@ use crate::transport::{ GatewayHttpTransport, GatewayTransportError, LeasedTransport, ProviderPort, ProviderResponse, WriteTransportOutcome, }; +#[cfg(any(test, feature = "testkit-harness"))] use crate::{ - ClosedObservationRequest, ClosedProviderRequest, CompiledRecipe, GatewayAttempts, - GatewayConnectionDescriptor, GatewayEvidenceChannel, GatewayProviderEvidence, + ClosedObservationRequest, + observer::{READ_BACK_SCHEMA, read_back_facts}, +}; +use crate::{ + ClosedProviderRequest, CompiledRecipe, GatewayAttempts, GatewayConnectionDescriptor, + GatewayEvidenceChannel, GatewayProviderEvidence, }; use auths_connections::{ ConnectionAlias, ConnectionCredentialStore, ConnectionProfile, ConnectionRecord, @@ -243,9 +247,6 @@ impl From<&GatewayProviderEvidence> for GatewayEvidenceSummary { #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] pub enum GatewayObserveRequest { - /// Read the recipe's observed field now and sign what was read. - /// `arguments` names exactly the observation path's fields. - ReadBack { arguments: Map }, /// Sign the stored record of one logical operation in this /// installation's namespace. No provider is contacted. Outcome { operation_id: String }, @@ -1710,11 +1711,9 @@ impl GatewayEngine { .map_err(|_| ()) } - /// Signs one observation for the application. A read-back uses the - /// installed connection and credential for exactly one bounded read-only - /// GET built from the approved recipe, after the lease passes every - /// declared credential check; an outcome reads only the local attempt - /// store. Nothing here writes to a provider or to the store. + /// Projects or signs retained local history for the application. This + /// route never leases a credential or contacts a provider. Independently + /// authorized provider evidence uses `recover` and its durable acquisition. pub async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { if let GatewayObserveRequest::PreEntry { operation_id } = request { return observe_pre_entry(&self.attempts, self.recipe.namespace(), operation_id).await; @@ -1739,37 +1738,6 @@ impl GatewayEngine { GatewayObserveRequest::PreEntry { operation_id } => { observe_pre_entry(&self.attempts, self.recipe.namespace(), operation_id).await } - GatewayObserveRequest::ReadBack { arguments } => { - let Ok(target) = self.recipe.read_back_target(arguments) else { - return refused("gateway.observer.invalid-read-back"); - }; - let Ok(prepared) = self.prepare_entry().await else { - return refused("gateway.observer.connection-unavailable"); - }; - let Ok(lease) = self.lease(&prepared).await else { - return refused("gateway.observer.credential-unavailable"); - }; - let port = LeasedTransport { - transport: &prepared.transport, - lease: &lease, - }; - let prefix = self.recipe.guard_checks().is_none_or(|guard| { - lease - .expose(Instant::now()) - .is_ok_and(|secret| guard.admits_secret(secret)) - }); - if !submit::lease_checks( - &self.recipe, - &port, - prefix, - Some(*prepared.loaded.record().account_commitment()), - ) - .await - { - return refused("gateway.observer.credential-guard"); - } - observe_read_back(&target, observer, &port, wall_clock_seconds).await - } } } } @@ -2325,6 +2293,7 @@ pub(crate) async fn observe_pre_entry( /// Performs one read-only observation and signs what it read. The observation /// time is taken before the request is sent, so the signed time is never later /// than the provider state the response reflects. +#[cfg(any(test, feature = "testkit-harness"))] pub(crate) async fn observe_read_back( target: &ClosedObservationRequest, observer: &GatewayObserver, diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 3ac1b4949..fa64019e0 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -920,6 +920,7 @@ impl Harness { /// Runs the engine's submission driver at `now`. A replay never writes /// again. + #[cfg(test)] pub(crate) async fn submit( &self, proof: &[u8], @@ -954,9 +955,7 @@ impl Harness { .await } - /// Mirrors the engine's observation request at `now`: a read-back leases - /// the credential for one read-only GET; an outcome or the pre-entry - /// observations read only the store. + /// Mirrors the engine's local history projection at `now`. pub(crate) async fn observe( &self, request: &GatewayObserveRequest, @@ -976,17 +975,23 @@ impl Harness { GatewayObserveRequest::PreEntry { operation_id } => { observe_pre_entry(&self.store, self.recipe.namespace(), operation_id).await } - GatewayObserveRequest::ReadBack { arguments } => { - let Ok(target) = self.recipe.read_back_target(arguments) else { - return GatewayObserveResult::Refused { - code: "gateway.observer.invalid-read-back".to_owned(), - }; - }; - self.provider.leases.fetch_add(1, Ordering::SeqCst); - observe_read_back(&target, &self.observer, &self.provider, || Some(now)).await - } } } + + /// Synthetic provider reference, never an application-socket operation. + pub(crate) async fn reference_read_back( + &self, + arguments: &Map, + now: u64, + ) -> GatewayObserveResult { + let Ok(target) = self.recipe.read_back_target(arguments) else { + return GatewayObserveResult::Refused { + code: "gateway.observer.invalid-read-back".to_owned(), + }; + }; + self.provider.leases.fetch_add(1, Ordering::SeqCst); + observe_read_back(&target, &self.observer, &self.provider, || Some(now)).await + } } #[cfg(all(unix, feature = "testkit-harness"))] @@ -1051,9 +1056,18 @@ mod process { #[derive(Deserialize)] #[serde(tag = "command", rename_all = "kebab-case", deny_unknown_fields)] enum Control { - SetRecord { record_id: String, status: String }, - AdvanceClock { seconds: u64 }, + SetRecord { + record_id: String, + status: String, + }, + AdvanceClock { + seconds: u64, + }, Counts, + /// Synthetic reference only, isolated from the application protocol. + ReferenceReadBack { + record_id: String, + }, } #[derive(Serialize)] @@ -1063,6 +1077,8 @@ mod process { writes: usize, reads: usize, leases: usize, + #[serde(skip_serializing_if = "Option::is_none")] + observation: Option, } struct Application { @@ -1087,6 +1103,22 @@ mod process { .await } + async fn recover( + &self, + _source: &str, + _proof: &[u8], + _action: &[u8], + _approval: crate::effect::ExactEffectApproval, + ) -> crate::app::AppRecoveryResult { + // This synthetic driver has no installed recovery authority. The + // production engine owns that path; never use a raw-read fallback. + crate::app::AppRecoveryResult::Refused { + result: GatewaySubmitResult::NotEntered { + code: "gateway.acquisition.binding".to_owned(), + }, + } + } + async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { self.harness .observe(request, self.clock.load(Ordering::SeqCst)) @@ -1104,7 +1136,8 @@ mod process { } } - fn control(&self, bytes: &[u8]) -> ControlResponse { + async fn control(&self, bytes: &[u8]) -> ControlResponse { + let mut observation = None; let ok = match serde_json::from_slice::(bytes) { Ok(Control::SetRecord { record_id, status }) => { matches!(status.as_str(), "Approved" | "Pending") @@ -1120,6 +1153,18 @@ mod process { .is_ok() } Ok(Control::Counts) => true, + Ok(Control::ReferenceReadBack { record_id }) => { + let arguments = serde_json::Map::from_iter([( + "record_id".to_owned(), + serde_json::Value::String(record_id), + )]); + observation = Some( + self.harness + .reference_read_back(&arguments, self.clock.load(Ordering::SeqCst)) + .await, + ); + true + } Err(_) => false, }; let counts = self.counts(); @@ -1129,13 +1174,14 @@ mod process { writes: counts.writes, reads: counts.reads, leases: counts.leases, + observation, } } } async fn control_session(mut stream: UnixStream, application: &Application) { if let Ok(bytes) = read_frame(&mut stream).await - && let Ok(response) = serde_json::to_vec(&application.control(&bytes)) + && let Ok(response) = serde_json::to_vec(&application.control(&bytes).await) { let _ = write_frame(&mut stream, &response).await; } diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index ed3aa565e..893936749 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -434,11 +434,7 @@ impl Harness { .as_object() .expect("object") .clone(); - signed_bytes( - self.core - .observe(&GatewayObserveRequest::ReadBack { arguments }, at) - .await, - ) + signed_bytes(self.core.reference_read_back(&arguments, at).await) } async fn outcome(&self, operation: &str, at: u64) -> GatewayObserveResult { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 98c57bf40..530f22f71 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "8ef59e4230c04557571750125161e6d96d32aa0891ca7afb52fb1ae868baae68"; + "b89d136af81d5bd839824593d150d080716ebcbcff7930d8de908d05ad710ba4"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index eaf9a59ac..521db70f6 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2273,7 +2273,7 @@ impl GatewayAttempts { } /// Reference-store oracle only; production admission requires ApprovedEffect. - #[cfg(any(test, feature = "testkit-harness"))] + #[cfg(test)] pub(crate) async fn claim( &self, request: &ClosedProviderRequest, @@ -2289,7 +2289,7 @@ impl GatewayAttempts { .await } - #[cfg(any(test, feature = "testkit-harness"))] + #[cfg(test)] async fn claim_binding( &self, request: &ClosedProviderRequest, diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 38b7597f9..d06b58eda 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -14,9 +14,9 @@ use crate::engine::{GatewaySubmitResult, VerifiedCommand, not_entered}; use crate::pre_entry::{self, PreEntryObservation, SelectedRequirement}; use crate::recipe::{CeilingCheck, CeilingReading, GuardChecks, MAX_ACCOUNT_BYTES}; use crate::store::BoundedClaim; -use crate::transport::{ - GatewayTransportError, ProviderPort, ProviderResponse, WriteTransportOutcome, -}; +#[cfg(test)] +use crate::transport::ProviderPort; +use crate::transport::{GatewayTransportError, ProviderResponse, WriteTransportOutcome}; use crate::{ ClaimedGatewayAttempt, CompiledRecipe, GatewayAttemptError, GatewayAttempts, GatewayObserver, GatewayPreEntry, GatewayRelativeBasis, @@ -846,6 +846,7 @@ fn unavailable_state() -> GatewaySubmitResult { /// The lease-time credential checks of a read outside a submission (an /// observation request): the prefix guard, the account read, and each /// denied read in declaration order, stopping at the first failure. +#[cfg(test)] pub(crate) async fn lease_checks( recipe: &CompiledRecipe, provider: &P, diff --git a/product/runtime/auths-gateway/tests/application_recovery_cli.rs b/product/runtime/auths-gateway/tests/application_recovery_cli.rs new file mode 100644 index 000000000..aa07c2353 --- /dev/null +++ b/product/runtime/auths-gateway/tests/application_recovery_cli.rs @@ -0,0 +1,105 @@ +//! Native CLI/socket artifact construction. No installed authority or provider +//! is represented by this refusal server. +#![cfg(unix)] + +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use std::{ + io::{Read as _, Write as _}, + os::unix::net::UnixListener, + process::Command, +}; + +#[test] +fn native_application_recovery_cli_fixture_is_current() { + let root = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let corpus: serde_json::Value = serde_json::from_slice( + &std::fs::read(root.join("application-recovery-frame.json")).expect("frame fixture"), + ) + .expect("JSON"); + let request = &corpus["request"]; + let expected_response = corpus["cases"][0]["response"].clone(); + let directory = tempfile::Builder::new() + .prefix("auths-recovery-") + .tempdir_in("/tmp") + .expect("directory"); + for (name, field) in [ + ("proof", "proof_b64"), + ("action", "action_b64"), + ("approval", "approval_b64"), + ] { + let bytes = + Base64UrlUnpadded::decode_vec(request["submission"][field].as_str().expect("encoded")) + .expect("bytes"); + std::fs::write(directory.path().join(name), bytes).expect("input"); + } + let socket = directory.path().join("app.sock"); + let listener = UnixListener::bind(&socket).expect("listen"); + // Avoid an indefinitely blocked test if the CLI rejects arguments first. + listener.set_nonblocking(true).expect("nonblocking"); + let reply = expected_response.clone(); + let server = std::thread::spawn(move || { + let until = std::time::Instant::now() + std::time::Duration::from_secs(10); + let mut stream = loop { + match listener.accept() { + Ok((stream, _)) => break stream, + Err(error) + if error.kind() == std::io::ErrorKind::WouldBlock + && std::time::Instant::now() < until => + { + std::thread::sleep(std::time::Duration::from_millis(5)) + } + Err(error) => panic!("CLI did not connect: {error}"), + } + }; + stream + .set_read_timeout(Some(std::time::Duration::from_secs(5))) + .expect("deadline"); + let mut length = [0; 4]; + stream.read_exact(&mut length).expect("length"); + let length = u32::from_be_bytes(length) as usize; + assert!((1..=auths_gateway::app::MAX_FRAME_BYTES).contains(&length)); + let mut bytes = vec![0; length]; + stream.read_exact(&mut bytes).expect("request"); + let frame: serde_json::Value = serde_json::from_slice(&bytes).expect("JSON"); + let bytes = serde_json::to_vec(&reply).expect("reply"); + stream + .write_all(&u32::try_from(bytes.len()).expect("bound").to_be_bytes()) + .expect("length"); + stream.write_all(&bytes).expect("reply"); + frame + }); + let output = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("app-recover") + .arg("--app-socket") + .arg(&socket) + .arg("--source-operation") + .arg("source-1") + .arg("--proof") + .arg(directory.path().join("proof")) + .arg("--action") + .arg(directory.path().join("action")) + .arg("--approval") + .arg(directory.path().join("approval")) + .output() + .expect("CLI"); + assert!( + output.status.success(), + "CLI: {}", + String::from_utf8_lossy(&output.stderr) + ); + let captured = server.join().expect("server"); + assert_eq!(&captured, request); + let response: serde_json::Value = serde_json::from_slice(&output.stdout).expect("CLI response"); + assert_eq!(response, expected_response); + let fixture = serde_json::to_vec_pretty(&serde_json::json!({ + "schema": "auths.application-recovery-cli-fixture/1", + "scope": "production CLI and real Unix socket with refusal server; no installed engine/provider claim", + "request": captured, "response": response, + })).expect("fixture"); + let path = root.join("application-recovery-cli.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} diff --git a/xtask/src/fuzz.rs b/xtask/src/fuzz.rs index 51fddcbd4..769895fc4 100644 --- a/xtask/src/fuzz.rs +++ b/xtask/src/fuzz.rs @@ -842,7 +842,7 @@ fn gateway_seeds(kind: GatewaySeeds) -> Result>, String> { for kind in ["outcome", "pre-entry"] { seeds.push( serde_json::json!({ - "schema": "auths.gateway-observe/2", + "schema": "auths.gateway-observe/3", "request": {"kind": kind, "operation_id": operation}, }) .to_string() @@ -851,16 +851,15 @@ fn gateway_seeds(kind: GatewaySeeds) -> Result>, String> { } } if matches!(kind, GatewaySeeds::AppFrame) { + let recovery = gateway_fixture_json("application-recovery-frame.json")?; + seeds.push(recovery["request"].to_string().into_bytes()); for case in vectors["verdicts"].as_array().into_iter().flatten() { - seeds.push( - serde_json::json!({ - "schema": "auths.gateway-submit/1", - "proof_b64": case["proof_b64"], - "action_b64": case["action_b64"], - }) - .to_string() - .into_bytes(), - ); + // Framing corpus only: native verification must still refuse + // an approval belonging to a different effect. + let mut submission = recovery["request"]["submission"].clone(); + submission["proof_b64"] = case["proof_b64"].clone(); + submission["action_b64"] = case["action_b64"].clone(); + seeds.push(submission.to_string().into_bytes()); } } } From ae5a286702ebb473e44ce6b5d2be11409684b063 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 09:08:14 +0000 Subject: [PATCH 034/136] chore(formal): regenerate qualification artifacts Source-SHA: 2eb6d734e1795e6d713320873e9e1f43555c78a0 Workflow-Run: 40661539619 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 75fbda208..bcad68211 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "c9ac74676348a1f08985b1ced96146edb800e3469dd5640579967b8266764b3a", + "digest": "4bc466118a74f05c0631f7c988e6a38d661b520840957de3895b1f646d6fca44", "files": [ { "path": ".cargo/config.toml", @@ -341,7 +341,7 @@ }, { "path": "xtask/src/fuzz.rs", - "sha256": "d7f5286aa0eccca894b2b8ea4b2d10b8e5261a6c7010ef696403a7550f5225bf" + "sha256": "8de85876a08cb6afa5ea094a0386ae4a9c4916a22fcc7a8909fa87700d61c32f" }, { "path": "xtask/src/kani_harness.rs", From aa966747a43a802a4a13eadc6a1474c30d915538 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 09:30:03 +0000 Subject: [PATCH 035/136] feat(gateway)!: enforce managed recovery read budgets Share fixed-window slot mechanics with mutation admission, reserve recovery policy charges atomically with source capacity, and validate retained membership at entry. Bind compiler /6 reservations and reject obsolete journal /9 state in favor of /10. --- .../gateway/application-recovery-cli.json | 2 +- .../gateway/application-recovery-frame.json | 2 +- .../gateway/attempt-scenarios-v3.json | 2 +- .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 16 +- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/prerequisite-compilation.json | 12 +- .../fixtures/gateway/prerequisite-entry.json | 32 +- .../gateway/recovery-compilation.json | 10 +- .../gateway/recovery-policy-budgets.json | 126 ++++++ .../fixtures/gateway/recovery-refinement.json | 20 + compliance.toml | 6 +- ...017-bound-effect-and-recovery-ownership.md | 27 ++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 42 +- .../0009-bound-effect-and-recovery.md | 18 + ...ound-effects-and-recovery-state-machine.md | 14 +- .../corpus/target_gateway_app_frame/recover | 2 +- .../corpus/target_gateway_app_frame/submit | 2 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6551 -> 6549 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6434 -> 6432 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5712 -> 5711 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5017 -> 5017 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/bounds.rs | 77 +++- product/runtime/auths-gateway/src/effect.rs | 79 +++- .../auths-gateway/src/effect/acquisition.rs | 42 +- .../auths-gateway/src/effect_native_tests.rs | 22 + .../src/effect_prerequisite_tests.rs | 2 +- .../src/effect_read_budget_tests.rs | 328 +++++++++++++++ .../src/pending_vectors/attempts.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 397 ++--------------- .../auths-gateway/src/store/acquisition.rs | 180 +++++--- .../auths-gateway/src/store/capacity.rs | 398 ++++++++++++++++++ 44 files changed, 1396 insertions(+), 500 deletions(-) create mode 100644 bindings/fixtures/gateway/recovery-policy-budgets.json create mode 100644 product/runtime/auths-gateway/src/effect_read_budget_tests.rs create mode 100644 product/runtime/auths-gateway/src/store/capacity.rs diff --git a/bindings/fixtures/gateway/application-recovery-cli.json b/bindings/fixtures/gateway/application-recovery-cli.json index f95779746..83c063295 100644 --- a/bindings/fixtures/gateway/application-recovery-cli.json +++ b/bindings/fixtures/gateway/application-recovery-cli.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ" } }, "response": { diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json index 9a49356f0..180cdc008 100644 --- a/bindings/fixtures/gateway/application-recovery-frame.json +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ" } }, "cases": [ diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index d22d9992d..859d5da1c 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/9", + "attempt_schema": "auths.gateway-attempt/10", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 95b02ba01..b10ba0695 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 1690ed728..f862ecaf6 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"b3ozerw4GptGOSyfIAZwiKH6x3f45ECsV1NXdZfdN2ltVWBMuETW0OF93Bo4XFVbQa34X8ps4glR17MtzrrKDw"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"0k74GEyPpcB-DkRdbfalFHoozQLCJAR3Xrb9U0xadNn3chbJn1JuA8UMj27Idp-WF5195cp4PYUFupj4NGO6AQ"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index ba8908e07..92dbd148c 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -73,7 +73,7 @@ ], "kind": "exact" }, - "compiler": "auths.gateway-effect-compiler/5", + "compiler": "auths.gateway-effect-compiler/6", "configuration": [ 12, 12, @@ -259,8 +259,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -394,17 +394,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/5\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/5\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/6\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/6\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "19e205f6c6234e4d23c7240014db3fe6f07661e5601fcb6f8954eb9cd61be51c", + "effect_id_hex": "bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,226,5,246,198,35,78,77,35,199,36,0,20,219,63,230,240,118,97,229,96,31,203,111,137,84,235,156,214,27,229,28],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"b3ozerw4GptGOSyfIAZwiKH6x3f45ECsV1NXdZfdN2ltVWBMuETW0OF93Bo4XFVbQa34X8ps4glR17MtzrrKDw\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"0k74GEyPpcB-DkRdbfalFHoozQLCJAR3Xrb9U0xadNn3chbJn1JuA8UMj27Idp-WF5195cp4PYUFupj4NGO6AQ\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index 586b09ef4..51a825a0d 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[50,150,69,229,33,135,64,182,196,31,108,221,236,228,204,114,78,150,1,104,4,244,108,229,77,62,251,136,221,74,3,158],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"1z-bqatxaFT6gTbrLiDF4rWmgegel6iTKTJW8izpr_LOulj3PtpwqkCt6Fwm0js4TLeLDXWymhQoEITpbc-kBQ\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[144,33,228,5,245,161,61,220,135,231,27,210,107,169,9,245,248,137,102,139,56,250,94,238,177,251,39,148,64,10,193,78],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"dW9ZaQKt4VKSR7xKklmNrK8GmfM2PiqGGjIYQrV_9mfNeZjzSwWA5piWVjDycjRN68o7lNOHBRzcec4D06M4Cw\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "329645e5218740b6c41f6cddece4cc724e96016804f46ce54d3efb88dd4a039e", + "effect_id": "9021e405f5a13ddc87e71bd26ba909f5f889668b38fa5eeeb1fb2794400ac14e", "dependencies": [ "55aab28f95092b9b9abc5dce74fcd3a13b02a2f54250893bed28852ac45fa264", "f2e4936daf26963e87b15bc36f0cdd7d548fbe5e291e318f65867fcd9156f7b2" @@ -39,11 +39,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7", + "effect_id": "318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index 5cb13f13d..0c9194f03 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -4,9 +4,9 @@ "cases": [ { "recipe": "stripe", - "effect_id_hex": "9ad8532b61afb71e84a27b4da7add7997bd37d9f8c27cbe9e20513d6909b4691", - "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[154,216,83,43,97,175,183,30,132,162,123,77,167,173,215,153,123,211,125,159,140,39,203,233,226,5,19,214,144,155,70,145],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"klmrSXldy6zVyiKHg42MizkQRz1Z38To_vS-QCGhpiXH49WymGAwBRLqFgyhwr7Gw_yBKHelJSLdp7Fixk0TBQ\"}", + "effect_id_hex": "91e26bebf2aeb60f23733d0d1c8eb56ed870fa92f017fdb9ef3fd24f1691c3d6", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[145,226,107,235,242,174,182,15,35,115,61,13,28,142,181,110,216,112,250,146,240,23,253,185,239,63,210,79,22,145,195,214],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ERpgVRq-vCQdyRgb54hpSkQP0NSVLj0tERd6FQuMEwUPurzBzdI7Am19dcaEkraf8dl_DkkJhsS9mAHamqOeDQ\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -152,9 +152,9 @@ }, { "recipe": "airtable-pre-entry", - "effect_id_hex": "19df37a438b464b6c359abcc45a41b56228c0b2cb40e6e71f89772381de97d5b", - "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[25,223,55,164,56,180,100,182,195,89,171,204,69,164,27,86,34,140,11,44,180,14,110,113,248,151,114,56,29,233,125,91],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"1WvIQRCUXSW21bv6uK8ewPNF1XK9Oi9RxPYVmzMy8XRvkOLwYum4Z74UEM0sGq0yrCozHpCqb1kz-kBzfvBBDQ\"}", + "effect_id_hex": "9bb588917b5f0c51cd6e1d573beb2b7b92bc954c0ae85a97a1d2c24b2f19086f", + "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[155,181,136,145,123,95,12,81,205,110,29,87,59,235,43,123,146,188,149,76,10,232,90,151,161,210,194,75,47,25,8,111],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"m0DHYElBr_RB_Ilrn4RXtVzz7Wg9W9tUXTWVtpg02K1egzicvfZ6ALoaHIz6Yq35Jj6yYKmQcnqLSV9dSKwxCA\"}", "prerequisite_acquisitions": [ { "disclosure": "none", diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 7e1aa5d5f..100246c9e 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/9", + "attempt_schema": "auths.gateway-attempt/10", "cases": [ { "recipe": "stripe", @@ -15,6 +15,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -24,6 +26,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -33,6 +37,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -42,6 +48,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -61,6 +69,8 @@ "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null @@ -70,6 +80,8 @@ "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null @@ -79,6 +91,8 @@ "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null @@ -88,6 +102,8 @@ "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null @@ -116,6 +132,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -125,6 +143,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -134,6 +154,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -143,6 +165,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -167,6 +191,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -186,6 +212,8 @@ "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null @@ -214,6 +242,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json index f4d6a11e7..3879821d7 100644 --- a/bindings/fixtures/gateway/recovery-compilation.json +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -1,16 +1,16 @@ { "schema": "auths.gateway-recovery-compilation-fixture/1", "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", - "binding_canonical": "{\"action\":[28,29,64,199,196,100,168,122,186,200,255,50,39,187,169,162,181,39,121,46,216,3,168,44,178,6,71,169,242,151,173,171],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[79,140,244,79,218,254,15,13,137,244,118,177,16,50,60,131,139,190,78,3,210,89,22,50,180,122,195,74,102,11,87,35],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[84,133,14,150,254,76,226,204,25,238,215,152,138,87,51,202,114,137,31,20,252,168,80,167,62,20,101,210,35,251,203,245],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,218,86,32,137,2,150,150,15,10,67,164,204,104,233,111,209,79,72,108,30,198,142,145,121,77,232,229,230,47,201,66],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[231,72,65,146,18,47,22,22,213,221,241,8,78,236,114,193,251,66,144,2,146,13,138,139,51,234,214,148,109,143,227,193],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id": "798928b00aa6e680768de38d0510246c8aec5eb18873b4b4b4acc8e137532c21", + "binding_canonical": "{\"action\":[28,54,189,163,195,0,28,219,188,23,162,99,67,138,19,221,31,15,17,205,158,136,222,46,139,42,211,27,136,124,81,58],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[189,228,70,245,1,112,155,54,232,6,205,109,191,126,247,63,101,35,202,243,90,140,247,184,111,163,145,151,111,0,150,157],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[125,211,174,90,206,175,39,217,216,51,189,127,59,107,180,155,207,190,1,76,103,205,208,45,158,117,246,40,215,243,173,125],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[78,69,176,40,128,157,35,150,198,73,64,89,13,26,29,116,28,88,135,255,10,32,239,49,193,132,192,8,187,48,133,223],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[147,57,98,238,125,84,212,151,55,59,189,169,136,7,68,251,220,10,142,97,167,82,234,136,172,18,93,62,228,54,132,171],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "9573c34bc7d94262a39cfec374fafc90ed2cfac06f533af200a54471578977a3", "authorization_call": { "arguments": { "maximum_response_bytes": 16384, "operation_id": "read-1", "operator_namespace": "observer-demo", - "read_contract": "54850e96fe4ce2cc19eed7988a5733ca72891f14fca850a73e1465d223fbcbf5", + "read_contract": "7dd3ae5aceaf27d9d833bd7f3b6bb49bcfbe014c67cdd02d9e75f628d7f3ad7d", "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", - "source_effect": "ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718", + "source_effect": "8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a", "source_operation": "source-1" }, "name": "auths_gateway_recovery_read_v1", @@ -18,7 +18,7 @@ "profile_version": 2, "service": "gateway-observer-test" }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"798928b00aa6e680768de38d0510246c8aec5eb18873b4b4b4acc8e137532c21\",\n \"binding_canonical\": \"{\\\"action\\\":[28,29,64,199,196,100,168,122,186,200,255,50,39,187,169,162,181,39,121,46,216,3,168,44,178,6,71,169,242,151,173,171],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/5\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[79,140,244,79,218,254,15,13,137,244,118,177,16,50,60,131,139,190,78,3,210,89,22,50,180,122,195,74,102,11,87,35],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[84,133,14,150,254,76,226,204,25,238,215,152,138,87,51,202,114,137,31,20,252,168,80,167,62,20,101,210,35,251,203,245],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[40,218,86,32,137,2,150,150,15,10,67,164,204,104,233,111,209,79,72,108,30,198,142,145,121,77,232,229,230,47,201,66],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[231,72,65,146,18,47,22,22,213,221,241,8,78,236,114,193,251,66,144,2,146,13,138,139,51,234,214,148,109,143,227,193],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 28,\n 29,\n 64,\n 199,\n 196,\n 100,\n 168,\n 122,\n 186,\n 200,\n 255,\n 50,\n 39,\n 187,\n 169,\n 162,\n 181,\n 39,\n 121,\n 46,\n 216,\n 3,\n 168,\n 44,\n 178,\n 6,\n 71,\n 169,\n 242,\n 151,\n 173,\n 171\n ],\n \"native_authority\": [\n 79,\n 140,\n 244,\n 79,\n 218,\n 254,\n 15,\n 13,\n 137,\n 244,\n 118,\n 177,\n 16,\n 50,\n 60,\n 131,\n 139,\n 190,\n 78,\n 3,\n 210,\n 89,\n 22,\n 50,\n 180,\n 122,\n 195,\n 74,\n 102,\n 11,\n 87,\n 35\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/5\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 40,\n 218,\n 86,\n 32,\n 137,\n 2,\n 150,\n 150,\n 15,\n 10,\n 67,\n 164,\n 204,\n 104,\n 233,\n 111,\n 209,\n 79,\n 72,\n 108,\n 30,\n 198,\n 142,\n 145,\n 121,\n 77,\n 232,\n 229,\n 230,\n 47,\n 201,\n 66\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 231,\n 72,\n 65,\n 146,\n 18,\n 47,\n 22,\n 22,\n 213,\n 221,\n 241,\n 8,\n 78,\n 236,\n 114,\n 193,\n 251,\n 66,\n 144,\n 2,\n 146,\n 13,\n 138,\n 139,\n 51,\n 234,\n 214,\n 148,\n 109,\n 143,\n 227,\n 193\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 84,\n 133,\n 14,\n 150,\n 254,\n 76,\n 226,\n 204,\n 25,\n 238,\n 215,\n 152,\n 138,\n 87,\n 51,\n 202,\n 114,\n 137,\n 31,\n 20,\n 252,\n 168,\n 80,\n 167,\n 62,\n 20,\n 101,\n 210,\n 35,\n 251,\n 203,\n 245\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"1c1d40c7c464a87abac8ff3227bba9a2b527792ed803a82cb20647a9f297adab\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"54850e96fe4ce2cc19eed7988a5733ca72891f14fca850a73e1465d223fbcbf5\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"ce43b36d66a579e228b9e87c46ccbd2f32039e584e51bcb20d9b4c62a5913718\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"9573c34bc7d94262a39cfec374fafc90ed2cfac06f533af200a54471578977a3\",\n \"binding_canonical\": \"{\\\"action\\\":[28,54,189,163,195,0,28,219,188,23,162,99,67,138,19,221,31,15,17,205,158,136,222,46,139,42,211,27,136,124,81,58],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/6\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[189,228,70,245,1,112,155,54,232,6,205,109,191,126,247,63,101,35,202,243,90,140,247,184,111,163,145,151,111,0,150,157],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[125,211,174,90,206,175,39,217,216,51,189,127,59,107,180,155,207,190,1,76,103,205,208,45,158,117,246,40,215,243,173,125],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[78,69,176,40,128,157,35,150,198,73,64,89,13,26,29,116,28,88,135,255,10,32,239,49,193,132,192,8,187,48,133,223],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[147,57,98,238,125,84,212,151,55,59,189,169,136,7,68,251,220,10,142,97,167,82,234,136,172,18,93,62,228,54,132,171],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 28,\n 54,\n 189,\n 163,\n 195,\n 0,\n 28,\n 219,\n 188,\n 23,\n 162,\n 99,\n 67,\n 138,\n 19,\n 221,\n 31,\n 15,\n 17,\n 205,\n 158,\n 136,\n 222,\n 46,\n 139,\n 42,\n 211,\n 27,\n 136,\n 124,\n 81,\n 58\n ],\n \"native_authority\": [\n 189,\n 228,\n 70,\n 245,\n 1,\n 112,\n 155,\n 54,\n 232,\n 6,\n 205,\n 109,\n 191,\n 126,\n 247,\n 63,\n 101,\n 35,\n 202,\n 243,\n 90,\n 140,\n 247,\n 184,\n 111,\n 163,\n 145,\n 151,\n 111,\n 0,\n 150,\n 157\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/6\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 78,\n 69,\n 176,\n 40,\n 128,\n 157,\n 35,\n 150,\n 198,\n 73,\n 64,\n 89,\n 13,\n 26,\n 29,\n 116,\n 28,\n 88,\n 135,\n 255,\n 10,\n 32,\n 239,\n 49,\n 193,\n 132,\n 192,\n 8,\n 187,\n 48,\n 133,\n 223\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 147,\n 57,\n 98,\n 238,\n 125,\n 84,\n 212,\n 151,\n 55,\n 59,\n 189,\n 169,\n 136,\n 7,\n 68,\n 251,\n 220,\n 10,\n 142,\n 97,\n 167,\n 82,\n 234,\n 136,\n 172,\n 18,\n 93,\n 62,\n 228,\n 54,\n 132,\n 171\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 125,\n 211,\n 174,\n 90,\n 206,\n 175,\n 39,\n 217,\n 216,\n 51,\n 189,\n 127,\n 59,\n 107,\n 180,\n 155,\n 207,\n 190,\n 1,\n 76,\n 103,\n 205,\n 208,\n 45,\n 158,\n 117,\n 246,\n 40,\n 215,\n 243,\n 173,\n 125\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"1c36bda3c3001cdbbc17a263438a13dd1f0f11cd9e88de2e8b2ad31b887c513a\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"7dd3ae5aceaf27d9d833bd7f3b6bb49bcfbe014c67cdd02d9e75f628d7f3ad7d\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "refused_changed_fields": [ "source_effect", "source_operation", diff --git a/bindings/fixtures/gateway/recovery-policy-budgets.json b/bindings/fixtures/gateway/recovery-policy-budgets.json new file mode 100644 index 000000000..2aaa51593 --- /dev/null +++ b/bindings/fixtures/gateway/recovery-policy-budgets.json @@ -0,0 +1,126 @@ +{ + "schema": "auths.gateway-recovery-policy-budget-fixture/1", + "scope": "native signed bounded read compilation; real file concurrent admission and restart; oracle entry; no provider or PostgreSQL claim", + "cases": [ + { + "limit": "count", + "maximum_response_bytes": 16384, + "prior_unknown_operations": 0, + "winning_operations": 1, + "uncharged_refusals": [ + { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "retained_after_restart": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 1, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "substituted_membership_refused": true, + "old_window_entry_refused": true, + "new_window_requires_new_binding_and_approval": true, + "mutation_counter_identity_distinct": true, + "unknown_keeps_policy_charge": true, + "rejected_policies": [ + "different-argument", + "response-above-ceiling", + "response-above-sum" + ] + }, + { + "limit": "sum", + "maximum_response_bytes": 16384, + "prior_unknown_operations": 0, + "winning_operations": 1, + "uncharged_refusals": [ + { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "retained_after_restart": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "substituted_membership_refused": true, + "old_window_entry_refused": true, + "new_window_requires_new_binding_and_approval": true, + "mutation_counter_identity_distinct": true, + "unknown_keeps_policy_charge": true, + "rejected_policies": [ + "different-argument", + "response-above-ceiling", + "response-above-sum" + ] + }, + { + "limit": "sum-predecessor", + "maximum_response_bytes": 16384, + "prior_unknown_operations": 1, + "winning_operations": 1, + "uncharged_refusals": [ + { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "retained_after_restart": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "substituted_membership_refused": true, + "old_window_entry_refused": true, + "new_window_requires_new_binding_and_approval": true, + "mutation_counter_identity_distinct": true, + "unknown_keeps_policy_charge": true, + "rejected_policies": [ + "different-argument", + "response-above-ceiling", + "response-above-sum" + ] + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/recovery-refinement.json b/bindings/fixtures/gateway/recovery-refinement.json index fc108c988..ce49f36f4 100644 --- a/bindings/fixtures/gateway/recovery-refinement.json +++ b/bindings/fixtures/gateway/recovery-refinement.json @@ -20,6 +20,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 503, "response_bytes": 176, "response_version_ok": true @@ -45,6 +47,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 176, "response_version_ok": false @@ -70,6 +74,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 2, "response_version_ok": true @@ -95,6 +101,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 1, "response_version_ok": true @@ -120,6 +128,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 75, "response_version_ok": true @@ -145,6 +155,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 148, "response_version_ok": true @@ -170,6 +182,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 36, "response_version_ok": true @@ -195,6 +209,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 61, "response_version_ok": true @@ -220,6 +236,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 124, "response_version_ok": true @@ -245,6 +263,8 @@ "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, "response_status": 200, "response_bytes": 176, "response_version_ok": true diff --git a/compliance.toml b/compliance.toml index 4f3759adf..86a1ce699 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/9", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/10", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/9", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/10", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1608,7 +1608,7 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] recovery-refinement = [ diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index c6d7d56b5..8f3eef965 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -576,3 +576,30 @@ removed from the shared application protocol even in harness builds. General acquisition/disclosure and the installed approval journey remain separate unfinished requirements; this cutover must not present a report as disclosure or a provider response as a successful mutation. + +## Managed recovery read budgets + +Recovery compilation consumes the same selected native bounded branch and the +same tightening, count and sum arithmetic as mutation compilation. Its numeric +policy argument is exactly `maximum_response_bytes`; a sum reserves that full +response ceiling, including lost responses. The mutation recipe's spend-sum +requirement does not apply to the separate recovery action. Read-policy count +and byte counters use distinct domain-separated identities from mutation +count/amount counters, retaining namespace, subject, evaluator, partition and +fixed-window components. Epochs and operation IDs do not reset these budgets. + +The existing slot candidate, slot encoding, sum-predecessor check and reservation +membership logic is shared inside the gateway store. Admission inserts one +acquisition journal record, its permanent source allocation and every managed +slot atomically. A collision advances only its candidate; no partial insert or +refund is possible. Final entry validates every slot with fresh native authority +inside the same fence. Prerequisite reads retain their parent's declared +allowance and do not charge the parent's managed policy again. + +At most sixteen bounded links produce 32 managed reservations plus two source +reservations, preserving the 34-reservation limit. Admission requires at most +34 inserted records, 16 predecessors, one source and three native dependencies +(54 total); entry requires at most 38 records. Both fit the existing 64-record +fence. Journal `/10` rejects the superseded acquisition layout. Compiler `/6` +binds the read's managed reservation set. Independent acquisition/disclosure, +credential replacement and installed race/fault evidence remain separate work. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index bcc544941..338a3ebe8 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -179,7 +179,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/9`; a store holding obsolete records is refused as + `auths.gateway-attempt/10`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 79ce207e3..5e75779cc 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -705,6 +705,44 @@ closure regeneration passed after that correction (one artifact-generation test) controlled disclosure/ACK, Python-owner removal, authenticated UI/bindings, and complete installed/process/PostgreSQL/fault/formal/performance/CI evidence. +## Managed recovery read budget checkpoint + +- Independent recovery compilation now consumes selected native count/sum + policies instead of refusing all managed bounds. The bounded argument is + exactly `maximum_response_bytes`; every sum reserves the full approved + response ceiling. Mutation recipe spend requirements remain mutation-owned. + Read count/byte identities are separate from mutation count/amount identities. +- Mutation and recovery use the same fixed-window candidate arithmetic, slot + encoding, sum-predecessor checks and final membership validation. Recovery + admission inserts managed slots and the permanent source allocation in one + fenced batch. Replays add no charge; failed contention inserts nothing. + Prerequisites do not reserve the parent policy again. +- Compiler `/6` binds the managed reservations. Journal `/10` retains immutable + acquisition counter membership and rejects the old layout. Decode checks + exact counter keys against the signed binding; final entry checks actual + slot identity, ownership, cumulative amount and window with current native + authorization under the fence. Public snapshots report policy counter counts + alongside the source allocation without exposing private keys or content. +- `recovery-policy-budgets.json` contains three real file histories: final count, + final byte sum and sum admission after an already charged unknown read. Each + races two independently approved operations for the last capacity, retains + exactly one winner, refuses substituted membership and old-window entry, + preserves lost-permit charges through reopening, and requires a newly + approved binding for a fresh window. Wrong argument, too-small ceiling and + too-small sum policies are refused. Entry uses an explicit-time oracle, not + an installed provider or PostgreSQL deployment. +- Required recovery, mutation binding/approval, prerequisite compilation/entry + and predicates, admission, mutation entry/fuzz, attempt scenario and replay + artifact generators passed. Application frame/CLI and final semantic closure + regeneration also passed. The native binding generator now writes and checks + the exact approval envelope alongside its signing request. No broad local + gate or hosted CI has been run. No A01–A22 acceptance criterion closes at this checkpoint. +- Remaining read implementation: onboarding/rotation and recovery ancillary + reads, plus safe replacement credentials. General acquisition, controlled + disclosure/authenticated ACK, Python-owner removal, authenticated UI/bindings, + full installed/process/PostgreSQL/fault/formal/performance and hosted evidence + remain required. + ## Phase gates | Phase | State | Outstanding gate | @@ -712,7 +750,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes wired | Onboarding/rotation and ancillary reads, general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation and ancillary reads, general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -726,7 +764,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission and prerequisite charge fixtures | Full adapter concurrency and all units pending | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission, prerequisite and managed read charge fixtures | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 0ae35d6db..a7c2e4aed 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -347,3 +347,21 @@ or malformed approvals, invalid source IDs and transport substitution. response over a real socket. These are transport artifacts, not installed proof, provider, disclosure or end-to-end acceptance evidence. The independent old observation evaluator remains confined to test-only reference/control paths. + +### Managed read reservation extension + +Mutation count/amount and recovery call/response-byte budgets share checked +fixed-window arithmetic, ordered slot candidates, immutable cumulative sums, +atomic insert and final membership validation. They do not share units or counter +identities. Recovery sums mean the complete approved response ceiling; mutation +sums keep their recipe-defined argument. Source-lifetime recovery allocation is +an additional independent limit. Prerequisites charge their declared child +allowance without repeating the parent's managed spend reservation. + +This extension reuses the existing store mechanism rather than adding a budget +owner. The admission transaction includes every managed slot and the source +allocation; replay and contention create no partial charge. The native recovery +corpus must cover count/sum exhaustion, retained unknown charges, window changes, +source/allocation collisions and missing/substituted membership. Full adapter +concurrency and performance acceptance remain open until executed evidence is +recorded in the AP074 ledger. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 1cdd1c8bb..e48c5b9c9 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -152,7 +152,7 @@ Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. The concrete native encoding is `auths.bound-effect/3`, with effect compiler -`auths.gateway-effect-compiler/5`. Reservations use a closed window alternative: +`auths.gateway-effect-compiler/6`. Reservations use a closed window alternative: fixed epoch-aligned windows or the retained source effect's lifetime. Mutation count/sum reservations retain fixed windows; recovery acquisitions declare separate acquisition-count and response-byte charges against one source. A @@ -162,6 +162,16 @@ and entry transitions can discharge it. Decoding never grants authority. The replay key MUST NOT include the action/effect digest as its only differentiator: the same logical operation ID with changed binding is a conflict, not a fresh operation. Exact replays return existing state; they never mint another capability. A newly chosen operation ID cannot evade a signed approval's binding or the shared budget. +Managed recovery policies use the same selected-branch tightening and fixed-window +count/sum arithmetic as mutation. Their argument is `maximum_response_bytes`; +read calls and full response ceilings have separate counter identities from +mutation counts and amounts. The mutation recipe's spend-sum requirement does +not apply to independently authorized read actions. Admission reserves these +slots atomically with the permanent source allowance, and final entry checks +all membership and window facts under the writer fence. Unknown outcomes retain +both charges. Prerequisites do not charge the parent policy a second time. +The existing sixteen-link and 34-reservation limits remain unchanged. + ### 4.2 Compilation and approval without circular commitments 1. Verify the caller's canonical action under installed trust and policy. @@ -235,7 +245,7 @@ these declarations. The declaration alone is neither a capacity reservation nor an entry permit; runtime must durably account and grant every constituent read through the shared journal before contacting the provider. -The concrete journal encoding is `auths.gateway-attempt/9`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/10`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover index b7c71765d..ad19cc89f 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover @@ -1 +1 @@ -{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0"}} \ No newline at end of file +{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit index b1d9cc8c4..7a323bc0c 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit @@ -1 +1 @@ -{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsyNSwyMjYsNSwyNDYsMTk4LDM1LDc4LDc3LDM1LDE5OSwzNiwwLDIwLDIxOSw2MywyMzAsMjQwLDExOCw5NywyMjksOTYsMzEsMjAzLDExMSwxMzcsODQsMjM1LDE1NiwyMTQsMjcsMjI5LDI4XSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImIzb3plcnc0R3B0R09TeWZJQVp3aUtINngzZjQ1RUNzVjFOWGRaZmROMmx0VldCTXVFVFcwT0Y5M0JvNFhGVmJRYTM0WDhwczRnbFIxN010enJyS0R3In0"} \ No newline at end of file +{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index f228ec72b..aa8fcd941 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index a95eca4a2..5beef93f2 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 12e15d649..a88ea1d1d 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 7c643a63a..1048fe1be 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 5ab1daa0d..4c3b12e29 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/9","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/5\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[135,50,207,121,13,202,148,85,219,205,12,155,235,73,171,26,215,54,9,160,56,29,245,108,140,173,144,129,43,163,32,183],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"95XPiHFOQ-4d3RLv402yst_SUcwy2MnN9a58s64dt55kysZQptqZu8T1kOvGbWRa6-Y2fI6OtQV0pTNye_PtCQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"8732cf790dca9455dbcd0c9beb49ab1ad73609a0381df56c8cad90812ba320b7","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 6db9f222382ff7cb1fe5383170bd6cf1a1041d24..e8677aebdba25b0f108ad0301eba2976ffdfc6de 100644 GIT binary patch delta 1075 zcmeH_%}PR15XaTrMA9b6z0humbLM>Siq!CfRJ24fF2{SXno*iwQrh$kBGGF^_Z8}C zdWnws3auoDKQqJpW?C+S?@pr~cCS`nb__O!Q4N#7NxD}NO3};fe@%wpJ;0= yGei$mz==jQ*7(Yzl7StBj4SO+8Vbg(B804~+2ZHHSMuK!yW#miF-2U>R#LxXs39Ey delta 1074 zcmeH_OG*P#6hzZ8BMA-^%sk-iM&AE36NIQy^E2@iBF*c59S8x5b{p-HI}kL8yKvH5 z(ABsIy^C-ZoK;b$E?lTL{?03-G5i|F_2h9r zy-U*2EuS}MLn|-4)5B(`*ASlfPZol(Jk7$hVf>J@)0?(+(xgiGOv+iFj(YR#c64tB zbkGOh8dq#`q&iveoXiL9JPEtme$n2lmsj__<;V7T&uGr#iMGVY&I&1g6nhfe zD2ar15p`a3MXV#-P(P6>HnH=T7|J5Y8Hx0=RcjVM>z~2@C{|+ge=>@qRXZ;K0`;RG AYXATM diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 9558a2d525fc6c9c3042ce07c68d0fa5861eb0de..393e3638f5473aa5737b4bea69faaa7a83928cce 100644 GIT binary patch delta 1075 zcmeH_(Mm!=5QaVGO(fj}c`tM~#P00w+1@OBCa1L|e1OlZBa4o?>*cR;xt-ykcfwU_Wf!shZ zA1XMh)??|I|IJG`eJ55axVF%W`yAi-w+x zF1w}C#p$d)373`5q^TCq_w!=CRV0nM2&+Ev{HRk%Y6toB_P!UtANEcdRbgPmND&Bu zO7@8|+AvMjKn9#BL~XP$4N5mKgOG8le3yoTaU%&KaWz-^*!y(;O|c!G{}WRr)!eu9 E3%I8ty8r+H delta 1074 zcmeH_O-chn6ofOHl>`?GW*>0(BK<$zJ3)vVG=C=kgvii6J%JFAm>Hw9@&(G@RbHOUdx0rFD^U>0Vt4a<{gHABk^mziP)31r zlnkiQpd~PB&`L~zO0>v^9B4>^DGaeGzyMVQBzj~8vP5H@Acdq5*fk(fDh?daXnqZ& zTJkWP%#$>-%crgBz{tza^rOPny)QR_plh_Qrg>c>*WI=0>rO_{Tt5f?6-)kg8N@e%xwVkI{JC!;8u)vw?e DN}V7H diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 37aa77ef7e946a22fa203759c94189ed5ee0f22c..5e2d4a871c9f1bb3dd76f75dbff6d4e6420e297a 100644 GIT binary patch delta 778 zcmd^+-AY115XU)5L39=M1YHlbJNw;LkrvvAik2wGVLfNnjM8*T>84i*e3CfVJwsh~ z(E|k0D?}^3MKS!D|1iH980HmT;1QQ7$-Y+OD3aO9+Gp;88=xEk@mEwTFbuQ+PJm)? zKxIHA3m6Xy83o8-839gzyJkTkP^tkJ5*$P*F|05e0;n0NFhUW?1+=%^Y;-wxli2$C z_wwNEChc_^Q*UbQ+}BH^qNr5Mh_{`))_$qlB7?lJhhth){j0L?#oC{?4*ExXwBSEkMO=n^gBE@ei5CRgdGOxC6nr4xQc0J@>)mzQP+kiNx05Ygv+D-CF-@JaUPE3pT2Lgl1W9L%yoS+s{xF-|y5tE_8=C_>jjErWReYsyV*PB@C7@8RA7#TsZp_#dkrLm5Msg8+(j-e5d zrDJFYRAOcfRAvIiK-$Pu#|+3cHqbFKgveTgR2b+{r9?(i4W_As`((zof#ilX5^?BDCW}!zHDu@Xn0Mwv_CIA2c diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 9235f7c67..9479c45d8 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"51ce5b4d0760d4c13addf2dd75d4a31865143d36f7bad46cd5d43e8a1810127c"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"d351284a2ab7fb3b2699c2cdaa847bc57be076ccae7fbd6e33dc52c541426818"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"3418bc2c6059d890f9db90f8e1e99186f774bdda624e25b4fed39d4657b1807f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"7a56da89947cde6dfa30e5f7f7459dc9ae0bceec824da2d0fac909752c043cbd"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"83367b3ce047bec872c16f29550a82524ff707f10f596fe0e83455b8844c182c"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"428844f4ad3d85daa6cebcb67504f6bb72bddd450f2ca0878a67cb7c36ac8938"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"de9dcf020f8dc02b5741bb751997ab0ff82874b84f7e580e45bf5d7d6770c19c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fdfe6a41e6880a2643197938e2c4eacee7f98708f47064e6f73c8b7b180d30da"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"c8d6f1fb99c6b24747e178953fd56e6fe21ca4951270d1c27e84181f2f6ae2f8"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5508c30098625683df3c9288c6cd794015a46765cd5ce2d8c57004d578b5dc1d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"a4e3841f45f460f4941d4b0256d47f2de5dcca6403d5bc8324c156bc1b29a169"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"74abfc3e8d3fd66ee4d8f846185b7e7aa818e0e336330b40be60068add3a40e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"c02d7f4d30c0c756a7c281276e143f57c73a519e888423f7f1c7a89fa9eff1b3"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"6f909e744dc4d367430f0362d3f04cd33ced9b8a2b49d3e7538e356e984a8311"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"e32cb0f59691a888fa7c30dbff672cba9dd539d86272136e03b9b89e83e65e1a"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"963ee4736520a84aeb361b0bacea63bf3cd442c8c23dc157d7fc0203eb5fd127"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"f769475da6e81962aedbd6c6a7ffa131935250eeaa0190d53f9daca79e31aee5"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"91222f74f87fec987ca7b8a9d37d5b6e8523ea5d29073f8ad34ab961cf40b194"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"428844f4ad3d85daa6cebcb67504f6bb72bddd450f2ca0878a67cb7c36ac8938"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"bcb29a26957ebe7eb19480155d537538bb7777285fa1f3dfcb847e7c3e269199"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"31df8baf384d5433e9f9b108e684de8862ba3c3beeabfcf70c6ef2beedc1cecb"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"0acb5f556558273a95362798289df5f5dc2dee65931748289e901b44a320b700"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"7ba35eb603312947cf548b4b8b2249a01597b02e2c8e46a88c2e63ca3fce65c7"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"f16e5ae91963ff88a11ca1f0808da48f2bbd66f8bb30e97ba12efcfe44addde0"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"642596880b4bd1c0227e22b11593baf22793e3de96507c1259ca0be9975911eb"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"c02d7f4d30c0c756a7c281276e143f57c73a519e888423f7f1c7a89fa9eff1b3"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bounds.rs b/product/runtime/auths-gateway/src/bounds.rs index 6c8e49e2e..8b3b638ab 100644 --- a/product/runtime/auths-gateway/src/bounds.rs +++ b/product/runtime/auths-gateway/src/bounds.rs @@ -694,19 +694,42 @@ pub(crate) fn link_policy( } } -/// Until acquisition counters consume bounded-policy commitments, reject them -/// explicitly. Native authorization must never silently drop a managed charge. -pub(crate) fn refuse_unaccounted_acquisition_bounds( +/// Read budgets use the existing bounded evaluator with explicit call/byte +/// units. Their identities cannot consume or replenish mutation budgets. +pub(crate) fn admit_acquisition_bounds( proof_cbor: &[u8], verified: &VerifiedAction, -) -> Result<(), &'static str> { - if authorized_chains(proof_cbor, verified)? + namespace: &OperatorNamespace, + now: u64, +) -> Result, GatewaySubmitResult> { + let links = selected_bound_links(proof_cbor, verified)?; + if links .iter() - .any(|branch| branch.chain.iter().any(carries_bound)) + .any(|link| link.policy.argument() != "maximum_response_bytes") { - return Err("gateway.acquisition.unsupported-bounds"); + return Err(not_entered("gateway.acquisition.unsupported-bounds")); } - Ok(()) + let mut bound = admit_policy_links(links, verified.canonical_action(), namespace, None, now) + .map_err(not_entered)?; + if let Some(bound) = &mut bound { + // Retain the established namespace/subject/evaluator/window/partition + // commitment, but place read units in disjoint counter domains. + let rekey = |domain: &[u8], key: &[u8; 32]| -> [u8; 32] { + let mut hash = Sha256::new(); + hash.update(domain); + hash.update(key); + hash.finalize().into() + }; + for counter in &mut bound.counts { + counter.key = rekey(b"auths.gateway-read-policy-count/1\0", &counter.key); + } + for counter in &mut bound.sums { + counter.key = rekey(b"auths.gateway-read-policy-bytes/1\0", &counter.key); + } + bound.counts.sort_by_key(|counter| counter.key); + bound.sums.sort_by_key(|counter| counter.key); + } + Ok(bound) } /// Admits the verified action under every link of its bounded branch and @@ -723,7 +746,22 @@ pub(crate) fn admit_links( recipe: &CompiledRecipe, now: u64, ) -> Result, &'static str> { - let requirement = recipe.sum_requirement(); + admit_policy_links( + links, + action, + recipe.namespace(), + recipe.sum_requirement(), + now, + ) +} + +fn admit_policy_links( + links: Vec, + action: &CanonicalAction, + namespace: &OperatorNamespace, + requirement: Option, + now: u64, +) -> Result, &'static str> { if links.len() > MAX_BOUNDED_LINKS { return Err("gateway.policy.too-many-bounds"); } @@ -767,13 +805,7 @@ pub(crate) fn admit_links( .and_then(|next| next.checked_mul(window_seconds)) .filter(|end| end.checked_add(window_seconds).is_some()) .ok_or("gateway.verify.clock-unavailable")?; - let (counts, sums) = chain_counters( - &links, - &partitions, - recipe.namespace(), - window_seconds, - index, - ); + let (counts, sums) = chain_counters(&links, &partitions, namespace, window_seconds, index); Ok(Some(BoundAdmission { links, argument, @@ -1062,6 +1094,14 @@ pub(crate) fn admit_bounds( recipe: &CompiledRecipe, now: u64, ) -> Result, GatewaySubmitResult> { + let links = selected_bound_links(proof_cbor, verified)?; + admit_links(links, verified.canonical_action(), recipe, now).map_err(not_entered) +} + +fn selected_bound_links( + proof_cbor: &[u8], + verified: &VerifiedAction, +) -> Result, GatewaySubmitResult> { let refuse = not_entered; let chain = bounded_chain(proof_cbor, verified).map_err(refuse)?; let mut bounds: Vec<(PrincipalId, BoundedPolicyCommitment)> = Vec::new(); @@ -1093,15 +1133,14 @@ pub(crate) fn admit_bounds( { return Err(refuse("gateway.policy.dangling-link")); } - let links = bounds + bounds .into_iter() .map(|(subject, body)| { link_policy(body.commitment(), body.policy()) .map(|policy| BoundLink { subject, policy }) }) .collect::, _>>() - .map_err(refuse)?; - admit_links(links, verified.canonical_action(), recipe, now).map_err(refuse) + .map_err(refuse) } /// The account-scope binding: for a recipe with `account_scope`, the action diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 390808a1c..5f4d727bb 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -36,7 +36,7 @@ pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/3"; pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/5"; +const COMPILER: &str = "auths.gateway-effect-compiler/6"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -499,6 +499,33 @@ fn canonical(value: &T) -> Result>, EffectBindin } impl EffectBinding { + /// Decode-time membership only; fresh window and durable slot checks belong + /// to the entry fence. Each native policy counter must appear exactly once. + pub(crate) fn matches_acquisition_counters( + &self, + counts: &[[u8; 32]], + sums: &[[u8; 32]], + ) -> bool { + if !matches!(self.wire.protocol, Protocol::Acquisition { .. }) { + return false; + } + let fixed: Vec<_> = self + .wire + .reservations + .iter() + .filter(|entry| matches!(entry.window, ReservationWindow::Fixed { .. })) + .collect(); + fixed.len() == counts.len() + sums.len() + && fixed.iter().all(|entry| { + let keys = match entry.unit { + Unit::AcquisitionCount => counts, + Unit::ResponseBytes => sums, + _ => return false, + }; + keys.iter().filter(|key| **key == entry.key).count() == 1 + }) + } + pub(crate) fn is_mutation(&self) -> bool { matches!(self.wire.protocol, Protocol::Mutation { .. }) } @@ -1058,6 +1085,13 @@ impl ApprovedEffect { } } + pub(crate) fn recovery_bound(&self) -> Option<&crate::bounds::BoundAdmission> { + match &self.effect.command { + CompiledEffect::Mutation(_) => None, + CompiledEffect::Acquisition(command) => command.bound.as_ref(), + } + } + pub(crate) fn prerequisite_plans(&self) -> Result, EffectBindingError> { let CompiledEffect::Mutation(mutation) = &self.effect.command else { return Err(EffectBindingError::Invalid); @@ -1181,24 +1215,17 @@ pub fn compile_mutation_effect( .map_err(|_| not_entered("gateway.effect.invalid-binding")) } -fn bind_mutation( - installed: &EffectInstallation<'_>, - command: VerifiedCommand, - proof: &[u8], - action: &[u8], -) -> Result { - let request = &command.request; - let prerequisites = Prerequisites::compile( - installed.recipe, - &command, - *installed.connection.account_commitment(), - )?; +fn managed_reservations( + bound: Option<&crate::bounds::BoundAdmission>, + count_unit: Unit, + sum_unit: Unit, +) -> Vec { let mut reservations = Vec::new(); - if let Some(bound) = &command.bound { + if let Some(bound) = bound { for count in &bound.counts { reservations.push(Reservation { key: count.key, - unit: Unit::MutationCount, + unit: count_unit, amount: 1, ceiling: count.capacity, window: ReservationWindow::Fixed { @@ -1210,7 +1237,7 @@ fn bind_mutation( for sum in &bound.sums { reservations.push(Reservation { key: sum.key, - unit: Unit::MutationSum, + unit: sum_unit, amount: bound.argument, ceiling: sum.capacity, window: ReservationWindow::Fixed { @@ -1221,6 +1248,26 @@ fn bind_mutation( } } reservations.sort_by_key(|entry| (entry.key, entry.unit)); + reservations +} + +fn bind_mutation( + installed: &EffectInstallation<'_>, + command: VerifiedCommand, + proof: &[u8], + action: &[u8], +) -> Result { + let request = &command.request; + let prerequisites = Prerequisites::compile( + installed.recipe, + &command, + *installed.connection.account_commitment(), + )?; + let reservations = managed_reservations( + command.bound.as_ref(), + Unit::MutationCount, + Unit::MutationSum, + ); let connection = Zeroizing::new( installed .connection diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 5c40bea84..defda27d3 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -110,6 +110,7 @@ impl RecoveryReadTarget { operation: &LogicalOperationId, action_commitment: [u8; 32], native_authority: [u8; 32], + bound: Option<&crate::bounds::BoundAdmission>, ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); let connection = Zeroizing::new( @@ -128,6 +129,13 @@ impl RecoveryReadTarget { } let plan = self.journal_plan().map_err(|_| invalid())?; let capacity = plan.capacity().map_err(|_| invalid())?; + let mut reservations = capacity.reservations(); + reservations.extend(managed_reservations( + bound, + Unit::AcquisitionCount, + Unit::ResponseBytes, + )); + reservations.sort_by_key(|entry| (entry.key, entry.unit)); EffectBinding::new(BindingWire { schema: EFFECT_BINDING_SCHEMA.to_owned(), namespace: installed.recipe.namespace().as_str().to_owned(), @@ -146,7 +154,7 @@ impl RecoveryReadTarget { approval_policy: ApprovalPolicy::Exact { approver: installed.approver, }, - reservations: capacity.reservations(), + reservations, protocol: Protocol::Acquisition { request: plan.request, projection: plan.contract, @@ -297,7 +305,22 @@ impl RecoveryPlan { projection: self.contract, maximum_response_bytes: self.maximum_response_bytes, }) - || effect.wire.reservations != capacity.reservations() + || effect + .wire + .reservations + .iter() + .filter(|entry| entry.window == ReservationWindow::SourceLifetime) + .cloned() + .collect::>() + != capacity.reservations() + || effect.wire.reservations.iter().any(|entry| { + matches!(entry.window, ReservationWindow::Fixed { .. }) + && match entry.unit { + Unit::AcquisitionCount => entry.amount != 1, + Unit::ResponseBytes => entry.amount != capacity.maximum_bytes, + _ => true, + } + }) { return Err(EffectBindingError::Invalid); } @@ -330,6 +353,7 @@ impl AcquisitionCapacity { pub(super) struct VerifiedAcquisition { pub(super) target: RecoveryReadTarget, + pub(super) bound: Option, #[cfg(unix)] actors: Vec, #[cfg(unix)] @@ -358,8 +382,9 @@ impl VerifiedAcquisition { /// separate; a mutation claim explicitly refuses this protocol. /// /// # Errors -/// Refuses invalid native proof, another tool/source/limit, unaccounted managed -/// bounds, observer overlap, unsupported scope, or changed installation. +/// Refuses invalid native proof, another tool/source/limit, managed bounds on +/// arguments other than the response ceiling, observer overlap, unsupported +/// scope, or changed installation. pub fn compile_recovery_acquisition( installed: &EffectInstallation<'_>, target: &RecoveryReadTarget, @@ -394,7 +419,12 @@ pub fn compile_recovery_acquisition( if command.call() != &expected { return Err(invalid()); } - crate::bounds::refuse_unaccounted_acquisition_bounds(proof, verified).map_err(not_entered)?; + let bound = crate::bounds::admit_acquisition_bounds( + proof, + verified, + installed.recipe.namespace(), + now, + )?; crate::separation::check_proof_observers(proof, verified).map_err(not_entered)?; #[cfg(unix)] let branches = crate::bounds::authorized_branches(proof, verified).map_err(not_entered)?; @@ -407,6 +437,7 @@ pub fn compile_recovery_acquisition( &operation, action_commitment, native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?, + bound.as_ref(), )?; let contract = target.contract(); let effect = BoundEffect { @@ -415,6 +446,7 @@ pub fn compile_recovery_acquisition( binding, command: CompiledEffect::Acquisition(Box::new(VerifiedAcquisition { target: target.clone(), + bound, #[cfg(unix)] actors: branches.actors, #[cfg(unix)] diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index caa597849..5eff4bcc2 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -12,6 +12,9 @@ use ed25519_dalek::{Signer as _, SigningKey}; #[path = "effect_prerequisite_tests.rs"] mod prerequisite_tests; +#[path = "effect_read_budget_tests.rs"] +mod read_budget_tests; + /// Native read authority is independent of an expired source writer. File /// provenance is real; the source entry is a test grant with no provider send. #[tokio::test] @@ -337,6 +340,18 @@ async fn native_recovery_acquisition_fixture_is_current() { std::fs::write(&path, &bytes).expect("write recovery entry corpus"); } assert_eq!(std::fs::read(path).expect("recovery entry corpus"), bytes); + let budget_corpus = + read_budget_tests::corpus(&source, &target, &read_installation, &policy, &root).await; + let budget_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/recovery-policy-budgets.json"); + let budget_bytes = serde_json::to_vec_pretty(&budget_corpus).expect("budget corpus"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&budget_path, &budget_bytes).expect("write budget corpus"); + } + assert_eq!( + std::fs::read(&budget_path).expect("budget corpus"), + budget_bytes + ); let mut corpus = exercise_recovery_refinement(&attempts, &recipe, &source, &reads).await; let mut frame_cases = Vec::new(); for (command, accepted) in [ @@ -1051,11 +1066,18 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .join("../../../bindings/fixtures/gateway/effect-binding.json"); let policy_path = fixture_path.with_file_name("effect-policy.json"); let request_path = fixture_path.with_file_name("effect-approval-request.json"); + let approval_path = fixture_path.with_file_name("effect-approval.json"); + let approval_bytes = approval.to_private_bytes().expect("approval bytes"); if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { std::fs::write(&fixture_path, &fixture).expect("write native fixture"); std::fs::write(&policy_path, &policy_bytes).expect("write native policy fixture"); std::fs::write(&request_path, &signing_request).expect("write native signing fixture"); + std::fs::write(&approval_path, &approval_bytes).expect("write native approval fixture"); } + assert_eq!( + std::fs::read(&approval_path).expect("approval fixture"), + *approval_bytes + ); assert_eq!( std::fs::read(&policy_path).expect("policy fixture"), *policy_bytes diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 8d55782eb..ec3bed41e 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -237,7 +237,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/9", + "attempt_schema": "auths.gateway-attempt/10", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/effect_read_budget_tests.rs b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs new file mode 100644 index 000000000..ea53985c2 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs @@ -0,0 +1,328 @@ +//! Native managed read budgets over the real file journal. Entry uses the +//! explicit-time test oracle; these histories make no provider or PG claim. +use super::*; +use crate::effect::{ApprovedEffect, RecoveryReadTarget, compile_recovery_acquisition}; +use crate::entry::EntryValidation::Oracle; +use crate::store::{AcquisitionClaim, AcquisitionStage, BoundedClaim}; +use crate::{ArgumentCeilingPolicy, GatewayAttemptStore}; +use base64ct::Base64; +use std::sync::Arc; + +fn read_grant( + root: &Signer, + reader: &Signer, + call: &McpToolCall, + policy: &ArgumentCeilingPolicy, +) -> SignedGrant { + let extension = CriticalExtension::new( + ExtensionId::parse(auths_registries::BOUNDED_POLICY_COMMITMENT_EXTENSION_V1).expect("ID"), + policy.extension_body(None).expect("policy"), + ) + .expect("extension"); + let statement = GrantStatement::new( + root.principal.clone(), + reader.principal.clone(), + call.profile_ref().expect("profile"), + PermissionSet::new(vec![call.permission().expect("permission")]).expect("permissions"), + window(NOW - 3_600, NOW + 3_600), + AudienceSet::new(vec![audience()]).expect("audiences"), + ActionConstraint::AnyBody, + None, + 0, + None, + StatusPolicy::ExpiryOnly, + AssurancePolicyId::parse(ASSURANCE).expect("assurance"), + CriticalExtensions::new(vec![extension]).expect("extensions"), + ); + let descriptor = root.descriptor(); + let signature = root.sign(&grant_signing_preimage(&statement, &descriptor).expect("preimage")); + SignedGrant::new(statement, SignatureEnvelope::new(descriptor, signature)) +} + +#[allow( + clippy::too_many_lines, + reason = "one bounded policy admission/restart history produces the native corpus" +)] +pub(super) async fn corpus( + source: &Arc, + target: &RecoveryReadTarget, + installed: &EffectInstallation<'_>, + policy: &EffectPolicy, + root: &Signer, +) -> Value { + let mut cases = Vec::new(); + for (name, max_count, sum_calls) in [ + ("count", 1, None), + ("sum", 4, Some(1)), + ("sum-predecessor", 4, Some(2)), + ] { + let directory = tempfile::tempdir().expect("directory"); + let path = std::fs::canonicalize(directory.path()) + .expect("path") + .join("journal"); + let store = Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("store")); + let attempts = + crate::GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"); + let BoundedClaim::Claimed(claim) = attempts + .claim_bounded(source, NOW, Oracle { now: NOW }) + .await + .expect("source claim") + else { + panic!("source"); + }; + let (_, permit) = claim + .grant_entry( + source.clone(), + Oracle { now: NOW }, + NOW, + &crate::GatewayPreEntry::default(), + ) + .await + .expect("source grant"); + drop(permit); + let reader = signer(0x33); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let maximum = target.closed_request().maximum_response_bytes() as u64; + let mut bound = + ArgumentCeilingPolicy::new("maximum_response_bytes", maximum, 3_600, max_count) + .expect("bound"); + if let Some(calls) = sum_calls { + bound = bound.with_sum(calls * maximum, None).expect("sum"); + } + let probe = target + .authorization_call( + installed.recipe, + &LogicalOperationId::parse("budget-policy-probe").expect("operation"), + ) + .expect("call"); + let mut rejected_policies = Vec::new(); + for (name, candidate) in [ + ( + "different-argument", + ArgumentCeilingPolicy::new("amount", maximum, 3_600, 1).expect("policy"), + ), + ( + "response-above-ceiling", + ArgumentCeilingPolicy::new("maximum_response_bytes", maximum - 1, 3_600, 1) + .expect("policy"), + ), + ( + "response-above-sum", + ArgumentCeilingPolicy::new("maximum_response_bytes", maximum, 3_600, 1) + .expect("policy") + .with_sum(maximum - 1, None) + .expect("sum"), + ), + ] { + let grant = read_grant(root, &reader, &probe, &candidate); + let submission = submission_for_call(root, &reader, &grant, &probe, &[]); + assert!( + compile_recovery_acquisition( + installed, + target, + NOW + 2, + &submission.proof, + &submission.action + ) + .is_err(), + "{name}" + ); + rejected_policies.push(name); + } + let compile = |operation: &str, now: u64| { + let call = target + .authorization_call( + installed.recipe, + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("call"); + let grant = read_grant(root, &reader, &call, &bound); + let submission = submission_for_call(root, &reader, &grant, &call, &[]); + let effect = compile_recovery_acquisition( + installed, + target, + now, + &submission.proof, + &submission.action, + ) + .expect("bounded read"); + let request = effect.approval_request(now, now + 1_000).expect("approval"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + Arc::new( + effect + .approve(request.with_signature(signature), &public, now) + .expect("approved"), + ) + }; + let prior_slots = u64::from(sum_calls == Some(2)); + if prior_slots == 1 { + let prefix = compile("budget-prefix", NOW + 2); + let AcquisitionClaim::Reserved(handle) = attempts + .claim_recovery(&prefix, NOW + 2, Oracle { now: NOW + 2 }) + .await + .expect("prefix") + else { + panic!("prefix reservation"); + }; + let (_, permit) = handle + .grant_entry(prefix, Oracle { now: NOW + 2 }, NOW + 2) + .await + .expect("prefix grant"); + drop(permit); + } + let reads = [ + compile("budget-read-1", NOW + 2), + compile("budget-read-2", NOW + 2), + ]; + let compiled = reads[0].recovery_bound().expect("managed budget"); + assert_eq!(compiled.argument, maximum); + assert_eq!(compiled.counts.len(), 1); + assert_eq!(compiled.sums.len(), usize::from(sum_calls.is_some())); + assert_ne!( + compiled.counts[0].key, + crate::bounds::count_counter_key( + installed.recipe.namespace(), + &reader.principal, + 3_600, + (NOW + 2) / 3_600 + ) + ); + if let Some(sum) = compiled.sums.first() { + assert_ne!( + sum.key, + crate::bounds::sum_counter_key( + installed.recipe.namespace(), + &reader.principal, + "", + 3_600, + (NOW + 2) / 3_600 + ) + ); + } + let (first, second) = tokio::join!( + attempts.claim_recovery(&reads[0], NOW + 2, Oracle { now: NOW + 2 }), + attempts.claim_recovery(&reads[1], NOW + 2, Oracle { now: NOW + 2 }), + ); + let mut winners = Vec::new(); + let mut refused = Vec::new(); + for (index, result) in [first, second].into_iter().enumerate() { + match result.expect("atomic admission") { + AcquisitionClaim::Reserved(handle) => winners.push((index, handle)), + AcquisitionClaim::Existing(snapshot) => { + assert_eq!(snapshot.stage, AcquisitionStage::NotEntered); + assert_eq!(snapshot.reserved_calls, 0); + assert_eq!(snapshot.reserved_bytes, 0); + refused.push(snapshot); + } + } + } + assert_eq!(winners.len(), 1, "one final capacity winner"); + assert_eq!(refused.len(), 1); + let (winner, handle) = winners.pop().expect("winner"); + let approved = &reads[winner]; + let compiled = approved.recovery_bound().expect("bound"); + let counter_key = crate::GatewayAttemptKey::from_bytes(crate::bounds::count_slot_key( + &compiled.counts[0].key, + prior_slots, + )); + let original = store + .load(crate::GatewayRecordKind::CountSlot, &counter_key) + .expect("load") + .expect("slot"); + let row: Value = serde_json::from_slice(&original).expect("slot"); + let changed = std::str::from_utf8(&original) + .expect("UTF-8") + .replace(row["claim"].as_str().expect("claim"), &"00".repeat(32)); + // Slots are deliberately immutable through the adapter. Inject storage + // corruption directly, preserving a canonical row with a wrong claim. + let slot_path = path.join(format!("slot-{}.json", hex::encode(counter_key.as_bytes()))); + let original_file = std::fs::read(&slot_path).expect("slot file"); + let mut envelope: Value = serde_json::from_slice(&original_file).expect("envelope"); + envelope["record_b64"] = json!(Base64::encode_string(changed.as_bytes())); + std::fs::write(&slot_path, serde_json::to_vec(&envelope).expect("envelope")) + .expect("inject"); + assert!( + handle + .grant_entry(approved.clone(), Oracle { now: NOW + 3 }, NOW + 3) + .await + .is_err(), + "substituted membership denies entry" + ); + std::fs::write(&slot_path, original_file).expect("restore"); + let AcquisitionClaim::Reserved(handle) = attempts + .claim_recovery(approved, NOW + 3, Oracle { now: NOW + 3 }) + .await + .expect("reopen") + else { + panic!("reserved"); + }; + let boundary = compiled.window_end; + assert!( + approved.validate_for_entry(installed, boundary).is_err(), + "new window recompiles a different exact binding" + ); + assert!( + handle + .grant_entry(approved.clone(), Oracle { now: boundary }, boundary) + .await + .is_err(), + "expired fixed window denies oracle entry too" + ); + let AcquisitionClaim::Reserved(handle) = attempts + .claim_recovery(approved, NOW + 3, Oracle { now: NOW + 3 }) + .await + .expect("reopen") + else { + panic!("reserved"); + }; + let (_, permit) = handle + .grant_entry(approved.clone(), Oracle { now: NOW + 3 }, NOW + 3) + .await + .expect("read grant"); + drop(permit); + let attempts = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen store")), + policy.clone(), + ) + .expect("attempts"); + let AcquisitionClaim::Existing(retained) = attempts + .claim_recovery(approved, NOW + 4, Oracle { now: NOW + 4 }) + .await + .expect("replay") + else { + panic!("history only"); + }; + assert_eq!(retained.stage, AcquisitionStage::Unknown); + assert_eq!(retained.reserved_calls, 1); + assert_eq!(retained.reserved_bytes, maximum); + let third = compile("budget-read-3", NOW + 4); + let AcquisitionClaim::Existing(exhausted) = attempts + .claim_recovery(&third, NOW + 4, Oracle { now: NOW + 4 }) + .await + .expect("exhaustion") + else { + panic!("unknown retains charge"); + }; + assert_eq!(exhausted.stage, AcquisitionStage::NotEntered); + assert_eq!(exhausted.reserved_calls, 0); + let next = compile("budget-next-window", boundary); + let AcquisitionClaim::Reserved(next) = attempts + .claim_recovery(&next, boundary, Oracle { now: boundary }) + .await + .expect("new window") + else { + panic!("fresh approved window"); + }; + assert_eq!(next.snapshot().expect("snapshot").reserved_calls, 1); + cases.push(json!({"limit": name, "maximum_response_bytes": maximum, + "prior_unknown_operations": prior_slots, "winning_operations": 1, "uncharged_refusals": refused, "retained_after_restart": retained, + "substituted_membership_refused": true, "old_window_entry_refused": true, + "new_window_requires_new_binding_and_approval": true, + "mutation_counter_identity_distinct": true, "unknown_keeps_policy_charge": true, + "rejected_policies": rejected_policies})); + } + json!({"schema": "auths.gateway-recovery-policy-budget-fixture/1", "scope": "native signed bounded read compilation; real file concurrent admission and restart; oracle entry; no provider or PostgreSQL claim", "cases": cases}) +} diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index da3336e8f..022f19b43 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/9"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/10"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index fcc3680e4..47c1546b0 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/9"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/10"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index ed347b5c3..ae2e2840e 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/9", + "store_schema": "auths.gateway-attempt/10", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 5659c8faf..1a4c70e72 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/9"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/10"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/9", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/10", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 530f22f71..daaf31af4 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "b89d136af81d5bd839824593d150d080716ebcbcff7930d8de908d05ad710ba4"; + "4774b0983f379ac657672a4efcb9db1e47e96f3af8998507e9adef66efc436d4"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 521db70f6..2aed6950e 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/9`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/10`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/9"; +const SCHEMA: &str = "auths.gateway-attempt/10"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -702,6 +702,7 @@ enum ProtocolState { } mod acquisition; +mod capacity; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, @@ -798,25 +799,7 @@ fn canonical(value: &T) -> Result, GatewayAttemptError> { impl Record { fn counters(&self) -> Result, GatewayAttemptError> { - if self.state.counters.len() > MAX_COUNTERS { - return Err(GatewayAttemptError::Corrupt); - } - let counters = self - .state - .counters - .iter() - .map(|entry| { - Ok(GatewayCounterEntry { - kind: entry.kind, - counter: digest_bytes(&entry.counter)?, - slot: entry.slot, - }) - }) - .collect::, GatewayAttemptError>>()?; - if counters.windows(2).any(|pair| pair[0] >= pair[1]) { - return Err(GatewayAttemptError::Corrupt); - } - Ok(counters) + capacity::decode_counters(&self.state.counters) } fn recovery_target(&self) -> Result { @@ -950,93 +933,15 @@ impl Record { snapshots: &[Option>], now: u64, ) -> Result<(), GatewayAttemptError> { - let counters = self.counters()?; - let Some(bound) = bound else { - return if counters.is_empty() && snapshots.is_empty() { - Ok(()) - } else { - Err(GatewayAttemptError::Corrupt) - }; - }; - if counters.len() != bound.counts.len() + bound.sums.len() - || snapshots.len() != counters.len() - || bound.window_seconds == 0 - || bound.counts.iter().any(|bound| { - counters - .iter() - .filter(|counter| { - counter.kind == GatewayCounterKind::Count && counter.counter == bound.key - }) - .count() - != 1 - }) - || bound.sums.iter().any(|bound| { - counters - .iter() - .filter(|counter| { - counter.kind == GatewayCounterKind::Sum && counter.counter == bound.key - }) - .count() - != 1 - }) - || now >= bound.window_end - || now / bound.window_seconds != bound.window_index - { - return Err(GatewayAttemptError::InvalidTransition); - } - let claim = hex::encode(key.as_bytes()); - for (counter, bytes) in counters.iter().zip(snapshots) { - let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; - let valid = match counter.kind { - GatewayCounterKind::Count => { - let slot: CountSlotRecord = - serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; - let limit = bound - .counts - .iter() - .find(|candidate| candidate.key == counter.counter) - .ok_or(GatewayAttemptError::Corrupt)?; - canonical(&slot)? == bytes - && slot.schema == COUNT_SLOT_SCHEMA - && slot.counter == hex::encode(counter.counter) - && slot.slot == counter.slot - && slot.slot < limit.capacity - && slot.namespace == self.namespace - && slot.operation_id == self.operation_id - && slot.claim == claim - && slot.window_seconds == bound.window_seconds - && slot.window_index == bound.window_index - && slot.window_end == bound.window_end - } - GatewayCounterKind::Sum => { - let slot: SumSlotRecord = - serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; - let limit = bound - .sums - .iter() - .find(|candidate| candidate.key == counter.counter) - .ok_or(GatewayAttemptError::Corrupt)?; - canonical(&slot)? == bytes - && slot.schema == SUM_SLOT_SCHEMA - && slot.counter == hex::encode(counter.counter) - && slot.slot == counter.slot - && slot.slot < limit.slots - && slot.namespace == self.namespace - && slot.operation_id == self.operation_id - && slot.claim == claim - && slot.window_seconds == bound.window_seconds - && slot.window_index == bound.window_index - && slot.window_end == bound.window_end - && slot.amount == bound.argument - && slot.amount <= slot.cumulative - && slot.cumulative <= limit.capacity - } - }; - if !valid { - return Err(GatewayAttemptError::Corrupt); - } - } - Ok(()) + capacity::validate_reservations( + &self.namespace, + &self.operation_id, + &self.state.counters, + key, + bound, + snapshots, + now, + ) } fn locator_valid(&self) -> bool { @@ -2583,25 +2488,12 @@ impl ClaimedGatewayAttempt { blocking(move || { let mut attempt = self.attempt; let dependencies = validation.dependencies(); - let counters = attempt.record.counters()?; let prerequisites = approved .prerequisite_plans() .map_err(|_| GatewayAttemptError::InvalidTransition)?; let mut keys = vec![(GatewayRecordKind::Attempt, attempt.key)]; keys.extend_from_slice(&dependencies); - keys.extend(counters.iter().map(|counter| match counter.kind { - GatewayCounterKind::Count => ( - GatewayRecordKind::CountSlot, - GatewayAttemptKey(crate::bounds::count_slot_key( - &counter.counter, - counter.slot, - )), - ), - GatewayCounterKind::Sum => ( - GatewayRecordKind::SumSlot, - GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.counter, counter.slot)), - ), - })); + keys.extend(capacity::dependencies(&attempt.record.state.counters)?); let counter_end = keys.len(); keys.extend(acquisition::prerequisite_dependencies( attempt.key, @@ -3128,114 +3020,13 @@ fn store_exhausted( record: encode(&record)?, expires_at: None, }]; - match insert_claim(store, &mut record, &entries, admission, None, &[], &[])? { + match insert_claim(store, &mut record, &entries, admission, None)? { GatewayInsert::Inserted => Ok(Reserved::Exhausted(code)), GatewayInsert::Exists { .. } => Err(GatewayAttemptError::Replay), } } -/// The claim record with the reserved slots, and the batch that inserts it -/// with one slot record per count and sum counter. -fn claim_batch( - key: GatewayAttemptKey, - base: &Record, - bound: &crate::bounds::BoundAdmission, - counts: &[u64], - sums: &[u64], - totals: &[u64], -) -> Result<(Record, Vec, Vec), GatewayAttemptError> { - use crate::bounds::{count_slot_key, sum_slot_key}; - let mut record = base.clone(); - let mut counters: Vec = bound - .counts - .iter() - .zip(counts) - .map(|(counter, slot)| GatewayCounterEntry { - kind: GatewayCounterKind::Count, - counter: counter.key, - slot: *slot, - }) - .chain( - bound - .sums - .iter() - .zip(sums) - .map(|(counter, slot)| GatewayCounterEntry { - kind: GatewayCounterKind::Sum, - counter: counter.key, - slot: *slot, - }), - ) - .collect(); - counters.sort_unstable(); - record.state.counters = counters - .iter() - .map(|entry| CounterWire { - kind: entry.kind, - counter: hex::encode(entry.counter), - slot: entry.slot, - }) - .collect(); - record.snapshot(false)?; - let stored = encode(&record)?; - let claim = hex::encode(key.as_bytes()); - let mut entries = Vec::with_capacity(1 + counts.len() + sums.len()); - entries.push(GatewayRecordEntry { - kind: GatewayRecordKind::Attempt, - key, - record: stored.clone(), - expires_at: None, - }); - for (counter, slot) in bound.counts.iter().zip(counts) { - let slot_record = CountSlotRecord { - schema: COUNT_SLOT_SCHEMA.to_owned(), - counter: hex::encode(counter.key), - slot: *slot, - window_seconds: bound.window_seconds, - window_index: bound.window_index, - window_end: bound.window_end, - namespace: base.namespace.clone(), - operation_id: base.operation_id.clone(), - claim: claim.clone(), - }; - entries.push(GatewayRecordEntry { - kind: GatewayRecordKind::CountSlot, - key: GatewayAttemptKey(count_slot_key(&counter.key, *slot)), - record: canonical(&slot_record)?, - expires_at: Some(bound.expires_at()), - }); - } - for ((counter, slot), total) in bound.sums.iter().zip(sums).zip(totals) { - let slot_record = SumSlotRecord { - schema: SUM_SLOT_SCHEMA.to_owned(), - counter: hex::encode(counter.key), - slot: *slot, - amount: bound.argument, - cumulative: total - .checked_add(bound.argument) - .ok_or(GatewayAttemptError::Corrupt)?, - window_seconds: bound.window_seconds, - window_index: bound.window_index, - window_end: bound.window_end, - namespace: base.namespace.clone(), - operation_id: base.operation_id.clone(), - claim: claim.clone(), - }; - entries.push(GatewayRecordEntry { - kind: GatewayRecordKind::SumSlot, - key: GatewayAttemptKey(sum_slot_key(&counter.key, *slot)), - record: canonical(&slot_record)?, - expires_at: Some(bound.expires_at()), - }); - } - Ok((record, stored, entries)) -} - -/// Finds each counter's frontier, then inserts the claim and one slot per -/// count and sum counter in one all-or-none batch. A full counter stores -/// the claim alone as `not-entered`; a lost race advances that counter and -/// retries, at most [`MAX_CLAIM_ROUNDS`] times. The count and sum checks are -/// the translated leaves `chain_counts_admit` and `chain_sums_admit`. +/// Reserve immutable count/sum slots using the shared candidate arithmetic. fn reserve_with_claim( store: &dyn GatewayAttemptStore, key: GatewayAttemptKey, @@ -3243,75 +3034,23 @@ fn reserve_with_claim( bound: &crate::bounds::BoundAdmission, admission: &Admission, ) -> Result { - use crate::bounds::{count_slot_key, sum_slot_key}; - use auths_bounded_policy::kernel::{chain_counts_admit, chain_sums_admit}; - let mut counts = bound - .counts - .iter() - .map(|counter| { - frontier( - store, - GatewayRecordKind::CountSlot, - &counter.key, - counter.capacity, - count_slot_key, - ) - }) - .collect::, _>>()?; - let mut sums = bound - .sums - .iter() - .map(|counter| { - frontier( - store, - GatewayRecordKind::SumSlot, - &counter.key, - counter.slots, - sum_slot_key, - ) - }) - .collect::, _>>()?; - let mut totals = sums - .iter() - .zip(&bound.sums) - .map(|(slot, counter)| match slot.checked_sub(1) { - None => Ok(0), - Some(previous) => cumulative(store, &counter.key, previous), - }) - .collect::, _>>()?; - let count_capacities: Vec = bound - .counts - .iter() - .map(|counter| counter.capacity) - .collect(); - let sum_capacities: Vec = bound.sums.iter().map(|counter| counter.capacity).collect(); + let mut candidate = capacity::CapacityCandidate::new(store, bound)?; for _ in 0..MAX_CLAIM_ROUNDS { - let sum_slots_left = sums - .iter() - .zip(&bound.sums) - .all(|(slot, counter)| *slot < counter.slots); - if !chain_counts_admit(&counts, &count_capacities) || !sum_slots_left { - return store_exhausted( - store, - key, - base, - "gateway.policy.window-exhausted", - admission, - ); - } - if !chain_sums_admit(&totals, bound.argument, &sum_capacities) { - return store_exhausted(store, key, base, "gateway.policy.sum-exhausted", admission); - } - let (mut record, _, entries) = claim_batch(key, base, bound, &counts, &sums, &totals)?; - match insert_claim( - store, - &mut record, - &entries, - admission, - Some(bound), - &sums, - &totals, - )? { + if let Some(code) = candidate.refusal() { + return store_exhausted(store, key, base, code, admission); + } + let (counters, slots) = candidate.batch(key, &base.namespace, &base.operation_id)?; + let mut record = base.clone(); + record.state.counters = counters; + record.snapshot(false)?; + let mut entries = vec![GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + entries.extend(slots); + match insert_claim(store, &mut record, &entries, admission, Some(&candidate))? { GatewayInsert::Inserted => { return Ok(Reserved::Claimed { stored: encode(&record)?, @@ -3319,23 +3058,7 @@ fn reserve_with_claim( }); } GatewayInsert::Exists { index: 0 } => return Err(GatewayAttemptError::Replay), - GatewayInsert::Exists { index } => { - let position = index - 1; - if let Some(slot) = counts.get_mut(position) { - *slot += 1; - } else { - let position = position - counts.len(); - let (Some(slot), Some(total), Some(counter)) = ( - sums.get_mut(position), - totals.get_mut(position), - bound.sums.get(position), - ) else { - return Err(GatewayAttemptError::Corrupt); - }; - *total = cumulative(store, &counter.key, *slot)?; - *slot += 1; - } - } + GatewayInsert::Exists { index } => candidate.advance(store, index - 1)?, } } Ok(Reserved::Contended) @@ -3381,61 +3104,20 @@ fn insert_claim( record: &mut Record, entries: &[GatewayRecordEntry], admission: &Admission, - bound: Option<&crate::bounds::BoundAdmission>, - sums: &[u64], - totals: &[u64], + candidate: Option<&capacity::CapacityCandidate<'_>>, ) -> Result { let mut dependencies = admission.dependencies(); let native_end = dependencies.len(); - if let Some(bound) = bound { - if sums.len() != bound.sums.len() || totals.len() != sums.len() { - return Err(GatewayAttemptError::Corrupt); - } - for (counter, slot) in bound.sums.iter().zip(sums) { - if let Some(previous) = slot.checked_sub(1) { - dependencies.push(( - GatewayRecordKind::SumSlot, - GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.key, previous)), - )); - } - } - } else if !sums.is_empty() || !totals.is_empty() { - return Err(GatewayAttemptError::Corrupt); + if let Some(candidate) = candidate { + dependencies.extend(candidate.dependencies()); } store.fenced_insert_all(entries, &dependencies, &mut |snapshots| { if snapshots.len() != dependencies.len() { return Err(GatewayAttemptError::Corrupt); } admission.stamp(record, &snapshots[..native_end])?; - if let Some(bound) = bound { - let mut predecessors = snapshots[native_end..].iter(); - for ((counter, slot), total) in bound.sums.iter().zip(sums).zip(totals) { - match slot.checked_sub(1) { - None if *total != 0 => return Err(GatewayAttemptError::Corrupt), - None => {} - Some(previous) => { - let bytes = predecessors - .next() - .and_then(|bytes| bytes.as_deref()) - .ok_or(GatewayAttemptError::Corrupt)?; - let row: SumSlotRecord = serde_json::from_slice(bytes) - .map_err(|_| GatewayAttemptError::Corrupt)?; - if canonical(&row)? != bytes - || row.schema != SUM_SLOT_SCHEMA - || row.counter != hex::encode(counter.key) - || row.slot != previous - || row.amount > row.cumulative - || row.cumulative != *total - || row.window_seconds != bound.window_seconds - || row.window_index != bound.window_index - || row.window_end != bound.window_end - || row.cumulative > counter.capacity - { - return Err(GatewayAttemptError::Corrupt); - } - } - } - } + if let Some(candidate) = candidate { + candidate.validate_predecessors(&snapshots[native_end..])?; } encode(record) }) @@ -3553,8 +3235,7 @@ impl GatewayAttempts { record: encode(&record)?, expires_at: None, }]; - match insert_claim(&*store, &mut record, &entries, &admission, None, &[], &[])? - { + match insert_claim(&*store, &mut record, &entries, &admission, None)? { GatewayInsert::Inserted => Ok(Reserved::Claimed { stored: encode(&record)?, record: Box::new(record), diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 20fd62f07..e8445ea85 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -26,6 +26,11 @@ pub struct AcquisitionSnapshot { pub reserved_calls: u64, /// Permanently allocated response-byte ceiling. pub reserved_bytes: u64, + /// Distinct fixed-window policy counters holding one invocation each. + /// These constrain the same read as the source-lifetime allocation. + pub policy_count_counters: u64, + /// Distinct fixed-window policy counters holding the full response ceiling. + pub policy_byte_counters: u64, /// Recorded HTTP status; it is not a mutation outcome or disclosure ACK. pub response_status: Option, /// Bounded received byte count, without the content or its commitment. @@ -55,6 +60,7 @@ pub enum AcquisitionStage { pub(super) struct AcquisitionState { plan: AcquisitionPlan, allocation: Option, + counters: Vec, phase: AcquisitionPhase, } @@ -117,6 +123,7 @@ impl JournalProtocol for AcquisitionState { record.evaluated_at, &record.state.plan, record.state.allocation, + &record.state.counters, ))?, entry: record .entry @@ -146,6 +153,30 @@ impl JournalProtocol for AcquisitionState { .plan .validate(&binding) .map_err(|_| GatewayAttemptError::Corrupt)?; + let counters = capacity::decode_counters(&record.state.counters)?; + if record.state.allocation.is_some() + && matches!(record.state.plan, AcquisitionPlan::Recovery(_)) + { + let counts: Vec<_> = counters + .iter() + .filter(|entry| entry.kind == GatewayCounterKind::Count) + .map(|entry| entry.counter) + .collect(); + let sums: Vec<_> = counters + .iter() + .filter(|entry| entry.kind == GatewayCounterKind::Sum) + .map(|entry| entry.counter) + .collect(); + if !binding.matches_acquisition_counters(&counts, &sums) { + return Err(GatewayAttemptError::Corrupt); + } + } + if (record.state.allocation.is_none() + || matches!(record.state.plan, AcquisitionPlan::Prerequisite(_))) + && !record.state.counters.is_empty() + { + return Err(GatewayAttemptError::Corrupt); + } if !transition::consistent(&Self::view(record)?) || record .entry @@ -223,6 +254,18 @@ impl Record { } else { 0 }, + policy_count_counters: self + .state + .counters + .iter() + .filter(|entry| entry.kind == GatewayCounterKind::Count) + .count() as u64, + policy_byte_counters: self + .state + .counters + .iter() + .filter(|entry| entry.kind == GatewayCounterKind::Sum) + .count() as u64, response_status, response_bytes, response_version_ok: match &self.state.phase { @@ -482,6 +525,10 @@ impl GatewayAttempts { AcquisitionPlan::Recovery(_) => key, AcquisitionPlan::Prerequisite(plan) => prerequisite_key(source_key, plan.index()), }; + let bound = match &plan { + AcquisitionPlan::Recovery(_) => approved.recovery_bound().cloned(), + AcquisitionPlan::Prerequisite(_) => None, + }; let expected_plan = plan.clone(); let expected = String::from_utf8( binding @@ -509,30 +556,53 @@ impl GatewayAttempts { AcquisitionState { plan, allocation: None, + counters: Vec::new(), phase: AcquisitionPhase::Reserved, }, )?; base.validate_header()?; - for slot in 0..capacity.attempts { + let mut candidate = bound + .as_ref() + .map(|bound| capacity::CapacityCandidate::new(&*store, bound)) + .transpose()?; + let mut slot = 0; + for _ in 0..MAX_CLAIM_ROUNDS { + let refusal = if slot >= capacity.attempts { + Some("gateway.acquisition.exhausted") + } else { + candidate + .as_ref() + .and_then(capacity::CapacityCandidate::refusal) + }; let mut record = base.clone(); - record.state.allocation = Some(slot); + let mut slots = Vec::new(); + if let Some(code) = refusal { + record.state.phase = AcquisitionPhase::NotEntered { + code: code.to_owned(), + }; + } else { + record.state.allocation = Some(slot); + if let Some(candidate) = &candidate { + (record.state.counters, slots) = + candidate.batch(key, &record.namespace, &record.operation_id)?; + } + } AcquisitionState::validate(&record)?; - let stored = encode(&record)?; - let allocation = Allocation::new(&record.state.plan, key, slot)?; - let entries = [ - GatewayRecordEntry { - kind: GatewayRecordKind::Attempt, - key, - record: stored.clone(), - expires_at: None, - }, - GatewayRecordEntry { + let mut entries = vec![GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + if refusal.is_none() { + entries.push(GatewayRecordEntry { kind: GatewayRecordKind::EffectAllocation, key: allocation_key(&capacity, slot), - record: canonical(&allocation)?, + record: canonical(&Allocation::new(&record.state.plan, key, slot)?)?, expires_at: None, - }, - ]; + }); + entries.extend(slots); + } match insert_acquisition( &*store, &mut record, @@ -540,7 +610,11 @@ impl GatewayAttempts { &dependencies, &admission, source_key, - key, + if refusal.is_none() { + candidate.as_ref() + } else { + None + }, )? { GatewayInsert::Inserted => { let stored = encode(&record)?; @@ -549,39 +623,17 @@ impl GatewayAttempts { GatewayInsert::Exists { index: 0 } => { return Err(existing_binding(&*store, key, &base.binding_canonical)); } - GatewayInsert::Exists { index: 1 } => {} + GatewayInsert::Exists { index: 1 } if refusal.is_none() => slot += 1, + GatewayInsert::Exists { index } if refusal.is_none() => { + candidate + .as_mut() + .ok_or(GatewayAttemptError::Corrupt)? + .advance(&*store, index - 2)?; + } GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), } } - let mut record = base; - record.state.phase = AcquisitionPhase::NotEntered { - code: "gateway.acquisition.exhausted".to_owned(), - }; - AcquisitionState::validate(&record)?; - let stored = encode(&record)?; - let entries = [GatewayRecordEntry { - kind: GatewayRecordKind::Attempt, - key, - record: stored, - expires_at: None, - }]; - match insert_acquisition( - &*store, - &mut record, - &entries, - &dependencies, - &admission, - source_key, - key, - )? { - GatewayInsert::Inserted => { - let stored = encode(&record)?; - Ok((record, stored)) - } - GatewayInsert::Exists { .. } => { - Err(existing_binding(&*store, key, &record.binding_canonical)) - } - } + Err(GatewayAttemptError::Conflict) }) .await; let (record, stored) = match reserved { @@ -679,6 +731,8 @@ impl ReservedAcquisition { ), ]; keys.extend_from_slice(&dependencies); + let native_end = keys.len(); + keys.extend(capacity::dependencies(&attempt.record.state.counters)?); let mut committed = None; attempt.store.fenced_replace(&keys, &mut |snapshots| { if snapshots.len() != keys.len() @@ -716,8 +770,25 @@ impl ReservedAcquisition { return Err(GatewayAttemptError::BindingConflict); } let now = validation - .validate(&approved, &snapshots[3..], authorization_started_at) + .validate( + &approved, + &snapshots[3..native_end], + authorization_started_at, + ) .map_err(|_| GatewayAttemptError::InvalidTransition)?; + let bound = match &plan { + AcquisitionPlan::Recovery(_) => approved.recovery_bound(), + AcquisitionPlan::Prerequisite(_) => None, + }; + capacity::validate_reservations( + ¤t.namespace, + ¤t.operation_id, + ¤t.state.counters, + attempt.key, + bound, + &snapshots[native_end..], + now, + )?; let mut next = current.clone(); next.record_grant( &approved, @@ -897,9 +968,15 @@ fn insert_acquisition( dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], admission: &Admission, source_key: GatewayAttemptKey, - key: GatewayAttemptKey, + candidate: Option<&capacity::CapacityCandidate<'_>>, ) -> Result { - store.fenced_insert_all(entries, dependencies, &mut |snapshots| { + let key = entries.first().ok_or(GatewayAttemptError::Corrupt)?.key; + let native_end = dependencies.len(); + let mut dependencies = dependencies.to_vec(); + if let Some(candidate) = candidate { + dependencies.extend(candidate.dependencies()); + } + store.fenced_insert_all(entries, &dependencies, &mut |snapshots| { if snapshots.len() != dependencies.len() || snapshots.is_empty() { return Err(GatewayAttemptError::Corrupt); } @@ -911,7 +988,10 @@ fn insert_acquisition( if !eligible_source(&record.state.plan, &source, source_key, key)? { return Err(GatewayAttemptError::InvalidTransition); } - admission.stamp(record, &snapshots[1..])?; + admission.stamp(record, &snapshots[1..native_end])?; + if let Some(candidate) = candidate { + candidate.validate_predecessors(&snapshots[native_end..])?; + } if record.evaluated_at < source.evaluated_at { return Err(GatewayAttemptError::InvalidTransition); } diff --git a/product/runtime/auths-gateway/src/store/capacity.rs b/product/runtime/auths-gateway/src/store/capacity.rs new file mode 100644 index 000000000..1949369df --- /dev/null +++ b/product/runtime/auths-gateway/src/store/capacity.rs @@ -0,0 +1,398 @@ +//! Shared fixed-window slot mechanics. Protocol owners decide which capacity +//! to reserve; this module preserves the existing bounded arithmetic and rows. +use super::*; +use crate::bounds::{BoundAdmission, count_slot_key, sum_slot_key}; + +pub(super) struct CapacityCandidate<'a> { + bound: &'a BoundAdmission, + counts: Vec, + sums: Vec, + totals: Vec, +} + +impl<'a> CapacityCandidate<'a> { + pub(super) fn new( + store: &dyn GatewayAttemptStore, + bound: &'a BoundAdmission, + ) -> Result { + let counts = bound + .counts + .iter() + .map(|counter| { + frontier( + store, + GatewayRecordKind::CountSlot, + &counter.key, + counter.capacity, + count_slot_key, + ) + }) + .collect::, _>>()?; + let sums = bound + .sums + .iter() + .map(|counter| { + frontier( + store, + GatewayRecordKind::SumSlot, + &counter.key, + counter.slots, + sum_slot_key, + ) + }) + .collect::, _>>()?; + let totals = sums + .iter() + .zip(&bound.sums) + .map(|(slot, counter)| match slot.checked_sub(1) { + None => Ok(0), + Some(previous) => cumulative(store, &counter.key, previous), + }) + .collect::, _>>()?; + Ok(Self { + bound, + counts, + sums, + totals, + }) + } + pub(super) fn refusal(&self) -> Option<&'static str> { + use auths_bounded_policy::kernel::{chain_counts_admit, chain_sums_admit}; + let Self { + bound, + counts, + sums, + totals, + } = self; + let count_capacities: Vec = bound + .counts + .iter() + .map(|counter| counter.capacity) + .collect(); + let sum_capacities: Vec = bound.sums.iter().map(|counter| counter.capacity).collect(); + let sum_slots_left = sums + .iter() + .zip(&bound.sums) + .all(|(slot, counter)| *slot < counter.slots); + if !chain_counts_admit(counts, &count_capacities) || !sum_slots_left { + return Some("gateway.policy.window-exhausted"); + } + if !chain_sums_admit(totals, bound.argument, &sum_capacities) { + return Some("gateway.policy.sum-exhausted"); + } + None + } + pub(super) fn batch( + &self, + key: GatewayAttemptKey, + namespace: &str, + operation_id: &str, + ) -> Result<(Vec, Vec), GatewayAttemptError> { + let Self { + bound, + counts, + sums, + totals, + } = self; + let mut counters: Vec = bound + .counts + .iter() + .zip(counts) + .map(|(counter, slot)| GatewayCounterEntry { + kind: GatewayCounterKind::Count, + counter: counter.key, + slot: *slot, + }) + .chain( + bound + .sums + .iter() + .zip(sums) + .map(|(counter, slot)| GatewayCounterEntry { + kind: GatewayCounterKind::Sum, + counter: counter.key, + slot: *slot, + }), + ) + .collect(); + counters.sort_unstable(); + let wires = counters + .iter() + .map(|entry| CounterWire { + kind: entry.kind, + counter: hex::encode(entry.counter), + slot: entry.slot, + }) + .collect(); + let claim = hex::encode(key.as_bytes()); + let mut entries = Vec::with_capacity(1 + counts.len() + sums.len()); + for (counter, slot) in bound.counts.iter().zip(counts) { + let slot_record = CountSlotRecord { + schema: COUNT_SLOT_SCHEMA.to_owned(), + counter: hex::encode(counter.key), + slot: *slot, + window_seconds: bound.window_seconds, + window_index: bound.window_index, + window_end: bound.window_end, + namespace: namespace.to_owned(), + operation_id: operation_id.to_owned(), + claim: claim.clone(), + }; + entries.push(GatewayRecordEntry { + kind: GatewayRecordKind::CountSlot, + key: GatewayAttemptKey(count_slot_key(&counter.key, *slot)), + record: canonical(&slot_record)?, + expires_at: Some(bound.expires_at()), + }); + } + for ((counter, slot), total) in bound.sums.iter().zip(sums).zip(totals) { + let slot_record = SumSlotRecord { + schema: SUM_SLOT_SCHEMA.to_owned(), + counter: hex::encode(counter.key), + slot: *slot, + amount: bound.argument, + cumulative: total + .checked_add(bound.argument) + .ok_or(GatewayAttemptError::Corrupt)?, + window_seconds: bound.window_seconds, + window_index: bound.window_index, + window_end: bound.window_end, + namespace: namespace.to_owned(), + operation_id: operation_id.to_owned(), + claim: claim.clone(), + }; + entries.push(GatewayRecordEntry { + kind: GatewayRecordKind::SumSlot, + key: GatewayAttemptKey(sum_slot_key(&counter.key, *slot)), + record: canonical(&slot_record)?, + expires_at: Some(bound.expires_at()), + }); + } + Ok((wires, entries)) + } + pub(super) fn advance( + &mut self, + store: &dyn GatewayAttemptStore, + index: usize, + ) -> Result<(), GatewayAttemptError> { + let Self { + bound, + counts, + sums, + totals, + } = self; + let position = index; + if let Some(slot) = counts.get_mut(position) { + *slot += 1; + } else { + let position = position - counts.len(); + let (Some(slot), Some(total), Some(counter)) = ( + sums.get_mut(position), + totals.get_mut(position), + bound.sums.get(position), + ) else { + return Err(GatewayAttemptError::Corrupt); + }; + *total = cumulative(store, &counter.key, *slot)?; + *slot += 1; + } + Ok(()) + } +} + +pub(super) fn decode_counters( + wires: &[CounterWire], +) -> Result, GatewayAttemptError> { + if wires.len() > MAX_COUNTERS { + return Err(GatewayAttemptError::Corrupt); + } + let counters = wires + .iter() + .map(|entry| { + Ok(GatewayCounterEntry { + kind: entry.kind, + counter: digest_bytes(&entry.counter)?, + slot: entry.slot, + }) + }) + .collect::, GatewayAttemptError>>()?; + if counters.windows(2).any(|pair| pair[0] >= pair[1]) { + return Err(GatewayAttemptError::Corrupt); + } + Ok(counters) +} + +pub(super) fn validate_reservations( + namespace: &str, + operation_id: &str, + counters: &[CounterWire], + key: GatewayAttemptKey, + bound: Option<&crate::bounds::BoundAdmission>, + snapshots: &[Option>], + now: u64, +) -> Result<(), GatewayAttemptError> { + let counters = decode_counters(counters)?; + let Some(bound) = bound else { + return if counters.is_empty() && snapshots.is_empty() { + Ok(()) + } else { + Err(GatewayAttemptError::Corrupt) + }; + }; + if counters.len() != bound.counts.len() + bound.sums.len() + || snapshots.len() != counters.len() + || bound.window_seconds == 0 + || bound.counts.iter().any(|bound| { + counters + .iter() + .filter(|counter| { + counter.kind == GatewayCounterKind::Count && counter.counter == bound.key + }) + .count() + != 1 + }) + || bound.sums.iter().any(|bound| { + counters + .iter() + .filter(|counter| { + counter.kind == GatewayCounterKind::Sum && counter.counter == bound.key + }) + .count() + != 1 + }) + || now >= bound.window_end + || now / bound.window_seconds != bound.window_index + { + return Err(GatewayAttemptError::InvalidTransition); + } + let claim = hex::encode(key.as_bytes()); + for (counter, bytes) in counters.iter().zip(snapshots) { + let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; + let valid = match counter.kind { + GatewayCounterKind::Count => { + let slot: CountSlotRecord = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + let limit = bound + .counts + .iter() + .find(|candidate| candidate.key == counter.counter) + .ok_or(GatewayAttemptError::Corrupt)?; + canonical(&slot)? == bytes + && slot.schema == COUNT_SLOT_SCHEMA + && slot.counter == hex::encode(counter.counter) + && slot.slot == counter.slot + && slot.slot < limit.capacity + && slot.namespace == namespace + && slot.operation_id == operation_id + && slot.claim == claim + && slot.window_seconds == bound.window_seconds + && slot.window_index == bound.window_index + && slot.window_end == bound.window_end + } + GatewayCounterKind::Sum => { + let slot: SumSlotRecord = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + let limit = bound + .sums + .iter() + .find(|candidate| candidate.key == counter.counter) + .ok_or(GatewayAttemptError::Corrupt)?; + canonical(&slot)? == bytes + && slot.schema == SUM_SLOT_SCHEMA + && slot.counter == hex::encode(counter.counter) + && slot.slot == counter.slot + && slot.slot < limit.slots + && slot.namespace == namespace + && slot.operation_id == operation_id + && slot.claim == claim + && slot.window_seconds == bound.window_seconds + && slot.window_index == bound.window_index + && slot.window_end == bound.window_end + && slot.amount == bound.argument + && slot.amount <= slot.cumulative + && slot.cumulative <= limit.capacity + } + }; + if !valid { + return Err(GatewayAttemptError::Corrupt); + } + } + Ok(()) +} + +impl CapacityCandidate<'_> { + pub(super) fn dependencies(&self) -> Vec<(GatewayRecordKind, GatewayAttemptKey)> { + let Self { bound, sums, .. } = self; + let mut dependencies = Vec::new(); + for (counter, slot) in bound.sums.iter().zip(sums) { + if let Some(previous) = slot.checked_sub(1) { + dependencies.push(( + GatewayRecordKind::SumSlot, + GatewayAttemptKey(crate::bounds::sum_slot_key(&counter.key, previous)), + )); + } + } + dependencies + } + pub(super) fn validate_predecessors( + &self, + snapshots: &[Option>], + ) -> Result<(), GatewayAttemptError> { + let Self { + bound, + sums, + totals, + .. + } = self; + if snapshots.len() != self.dependencies().len() { + return Err(GatewayAttemptError::Corrupt); + } + let mut predecessors = snapshots.iter(); + for ((counter, slot), total) in bound.sums.iter().zip(sums).zip(totals) { + match slot.checked_sub(1) { + None if *total != 0 => return Err(GatewayAttemptError::Corrupt), + None => {} + Some(previous) => { + let bytes = predecessors + .next() + .and_then(|bytes| bytes.as_deref()) + .ok_or(GatewayAttemptError::Corrupt)?; + let row: SumSlotRecord = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + if canonical(&row)? != bytes + || row.schema != SUM_SLOT_SCHEMA + || row.counter != hex::encode(counter.key) + || row.slot != previous + || row.amount > row.cumulative + || row.cumulative != *total + || row.window_seconds != bound.window_seconds + || row.window_index != bound.window_index + || row.window_end != bound.window_end + || row.cumulative > counter.capacity + { + return Err(GatewayAttemptError::Corrupt); + } + } + } + } + Ok(()) + } +} + +pub(super) fn dependencies( + counters: &[CounterWire], +) -> Result, GatewayAttemptError> { + Ok(decode_counters(counters)? + .iter() + .map(|counter| match counter.kind { + GatewayCounterKind::Count => ( + GatewayRecordKind::CountSlot, + GatewayAttemptKey(count_slot_key(&counter.counter, counter.slot)), + ), + GatewayCounterKind::Sum => ( + GatewayRecordKind::SumSlot, + GatewayAttemptKey(sum_slot_key(&counter.counter, counter.slot)), + ), + }) + .collect()) +} From 15b3cad1ac909dcdd1578055a9588a4dd7265455 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 09:51:19 +0000 Subject: [PATCH 036/136] feat(gateway)!: bind recovery credential prerequisites Reuse the native prerequisite compiler, journal and consumed-permit runtime for recovery account and capability checks. Fence retained child evidence at final recovery entry and bind its transport witness with compiler /7 and journal /11. --- .../gateway/application-recovery-cli.json | 2 +- .../gateway/application-recovery-frame.json | 2 +- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 8 - .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 16 +- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/prerequisite-compilation.json | 12 +- .../fixtures/gateway/prerequisite-entry.json | 2 +- .../gateway/recovery-compilation.json | 10 +- .../gateway/recovery-prerequisites.json | 926 ++++++++++++++++++ compliance.toml | 7 +- ...017-bound-effect-and-recovery-ownership.md | 27 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 40 +- .../0009-bound-effect-and-recovery.md | 19 + ...ound-effects-and-recovery-state-machine.md | 17 +- .../corpus/target_gateway_app_frame/recover | 2 +- .../corpus/target_gateway_app_frame/submit | 2 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6549 -> 6549 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6432 -> 6432 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5711 -> 5711 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5017 -> 5017 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 41 +- .../auths-gateway/src/effect/acquisition.rs | 66 +- .../auths-gateway/src/effect/prerequisite.rs | 35 +- .../auths-gateway/src/effect_native_tests.rs | 13 +- .../src/effect_prerequisite_tests.rs | 4 +- .../src/effect_recovery_prerequisite_tests.rs | 335 +++++++ product/runtime/auths-gateway/src/engine.rs | 33 +- product/runtime/auths-gateway/src/entry.rs | 64 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 1 - .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 4 +- .../auths-gateway/src/store/acquisition.rs | 114 ++- .../src/store/acquisition/recovery.rs | 6 +- product/runtime/auths-gateway/src/submit.rs | 110 ++- 48 files changed, 1729 insertions(+), 229 deletions(-) create mode 100644 bindings/fixtures/gateway/recovery-prerequisites.json create mode 100644 product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs diff --git a/bindings/fixtures/gateway/application-recovery-cli.json b/bindings/fixtures/gateway/application-recovery-cli.json index 83c063295..cf0e185ab 100644 --- a/bindings/fixtures/gateway/application-recovery-cli.json +++ b/bindings/fixtures/gateway/application-recovery-cli.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ" } }, "response": { diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json index 180cdc008..0eac3ddfb 100644 --- a/bindings/fixtures/gateway/application-recovery-frame.json +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ" } }, "cases": [ diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 859d5da1c..88c9d6a8c 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/10", + "attempt_schema": "auths.gateway-attempt/11", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 7a8d00ddd..0588abcec 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -104,14 +104,6 @@ "id": "account-scope-unbound" } }, - { - "code": "gateway.acquisition.ancillary-required", - "owner": "effect", - "stage": "before-claim", - "status": "new", - "epic": 74, - "case": null - }, { "code": "gateway.acquisition.binding", "owner": "effect", diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index b10ba0695..13071090e 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index f862ecaf6..a83b04697 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"0k74GEyPpcB-DkRdbfalFHoozQLCJAR3Xrb9U0xadNn3chbJn1JuA8UMj27Idp-WF5195cp4PYUFupj4NGO6AQ"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"tcAoRxGSqLLmIphb0TbUT7eWQAgMYhFThIu-wpuX7A3BvuiyG5mMh-4fagX_1fVqJ7LzeLtEgeixP6DVGD_oCQ"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 92dbd148c..f976350e8 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -73,7 +73,7 @@ ], "kind": "exact" }, - "compiler": "auths.gateway-effect-compiler/6", + "compiler": "auths.gateway-effect-compiler/7", "configuration": [ 12, 12, @@ -259,8 +259,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -394,17 +394,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/6\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/6\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/7\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/7\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "bbd54e6ca55530fa11661aabed8f9aea515dd91dbcab65b3147fb4c11e2d460d", + "effect_id_hex": "717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[187,213,78,108,165,85,48,250,17,102,26,171,237,143,154,234,81,93,217,29,188,171,101,179,20,127,180,193,30,45,70,13],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"0k74GEyPpcB-DkRdbfalFHoozQLCJAR3Xrb9U0xadNn3chbJn1JuA8UMj27Idp-WF5195cp4PYUFupj4NGO6AQ\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"tcAoRxGSqLLmIphb0TbUT7eWQAgMYhFThIu-wpuX7A3BvuiyG5mMh-4fagX_1fVqJ7LzeLtEgeixP6DVGD_oCQ\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index 51a825a0d..bdf0b9482 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[144,33,228,5,245,161,61,220,135,231,27,210,107,169,9,245,248,137,102,139,56,250,94,238,177,251,39,148,64,10,193,78],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"dW9ZaQKt4VKSR7xKklmNrK8GmfM2PiqGGjIYQrV_9mfNeZjzSwWA5piWVjDycjRN68o7lNOHBRzcec4D06M4Cw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[115,31,68,2,118,159,149,183,126,184,84,217,231,182,167,228,210,88,129,112,134,71,81,137,123,121,229,64,24,193,171,167],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"CgCYz6otkGqrgcQDHZlcwwJokERkTy1INF2ebs1RutotCkV-YkMtyBo7cTRQgJrLCy0E_ewV2zpoThlFur-5Aw\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "9021e405f5a13ddc87e71bd26ba909f5f889668b38fa5eeeb1fb2794400ac14e", + "effect_id": "731f4402769f95b77eb854d9e7b6a7e4d2588170864751897b79e54018c1aba7", "dependencies": [ "55aab28f95092b9b9abc5dce74fcd3a13b02a2f54250893bed28852ac45fa264", "f2e4936daf26963e87b15bc36f0cdd7d548fbe5e291e318f65867fcd9156f7b2" @@ -39,11 +39,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000", + "effect_id": "81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index 0c9194f03..5b585f494 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -4,9 +4,9 @@ "cases": [ { "recipe": "stripe", - "effect_id_hex": "91e26bebf2aeb60f23733d0d1c8eb56ed870fa92f017fdb9ef3fd24f1691c3d6", - "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[145,226,107,235,242,174,182,15,35,115,61,13,28,142,181,110,216,112,250,146,240,23,253,185,239,63,210,79,22,145,195,214],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ERpgVRq-vCQdyRgb54hpSkQP0NSVLj0tERd6FQuMEwUPurzBzdI7Am19dcaEkraf8dl_DkkJhsS9mAHamqOeDQ\"}", + "effect_id_hex": "7f4e57aa0df0b4209d5843016fd9ef1eda4b229487c155180308eb198c2c2e9c", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[127,78,87,170,13,240,180,32,157,88,67,1,111,217,239,30,218,75,34,148,135,193,85,24,3,8,235,25,140,44,46,156],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qjbSm1TpBmvrp4X2lvVIzppPuNgxwDEo9eZUzwUoZB5xWaRPvv_ycTyc0rJOG-6D5IRnDBCkx6FsGNvCK9QQAQ\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -152,9 +152,9 @@ }, { "recipe": "airtable-pre-entry", - "effect_id_hex": "9bb588917b5f0c51cd6e1d573beb2b7b92bc954c0ae85a97a1d2c24b2f19086f", - "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[155,181,136,145,123,95,12,81,205,110,29,87,59,235,43,123,146,188,149,76,10,232,90,151,161,210,194,75,47,25,8,111],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"m0DHYElBr_RB_Ilrn4RXtVzz7Wg9W9tUXTWVtpg02K1egzicvfZ6ALoaHIz6Yq35Jj6yYKmQcnqLSV9dSKwxCA\"}", + "effect_id_hex": "601fe4a5697536c2c6d6acfe95f7cd6ef7ee0d8d15b8a59fea7f638e646e6067", + "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[96,31,228,165,105,117,54,194,198,214,172,254,149,247,205,110,247,238,13,141,21,184,165,159,234,127,99,142,100,110,96,103],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"CXVuiGN0K7EwCQPNqRSJgXj8_DDCPm8oIXdD_muEfnWzQ4nxBAlWEMLYBps83rR5YyrcDUMRbiji8650UEDuCg\"}", "prerequisite_acquisitions": [ { "disclosure": "none", diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 100246c9e..7f047a708 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/10", + "attempt_schema": "auths.gateway-attempt/11", "cases": [ { "recipe": "stripe", diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json index 3879821d7..f8aad6c91 100644 --- a/bindings/fixtures/gateway/recovery-compilation.json +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -1,16 +1,16 @@ { "schema": "auths.gateway-recovery-compilation-fixture/1", "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", - "binding_canonical": "{\"action\":[28,54,189,163,195,0,28,219,188,23,162,99,67,138,19,221,31,15,17,205,158,136,222,46,139,42,211,27,136,124,81,58],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[189,228,70,245,1,112,155,54,232,6,205,109,191,126,247,63,101,35,202,243,90,140,247,184,111,163,145,151,111,0,150,157],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[125,211,174,90,206,175,39,217,216,51,189,127,59,107,180,155,207,190,1,76,103,205,208,45,158,117,246,40,215,243,173,125],\"request\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[78,69,176,40,128,157,35,150,198,73,64,89,13,26,29,116,28,88,135,255,10,32,239,49,193,132,192,8,187,48,133,223],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[147,57,98,238,125,84,212,151,55,59,189,169,136,7,68,251,220,10,142,97,167,82,234,136,172,18,93,62,228,54,132,171],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id": "9573c34bc7d94262a39cfec374fafc90ed2cfac06f533af200a54471578977a3", + "binding_canonical": "{\"action\":[65,122,98,210,120,224,214,152,194,82,159,209,122,100,122,250,137,38,77,176,53,42,251,132,215,189,242,44,141,29,181,25],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[147,16,216,225,54,22,226,167,204,22,59,188,88,71,56,60,239,64,124,186,160,242,62,170,188,123,33,34,46,44,83,252],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[114,122,177,80,176,10,176,61,226,141,164,247,174,69,210,31,238,68,160,93,111,230,137,91,226,139,213,126,209,143,209,194],\"request\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[116,70,239,162,42,152,250,6,239,135,195,43,59,81,238,53,103,135,95,107,157,232,161,198,84,40,16,186,121,199,145,139],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[148,149,21,136,228,137,148,170,141,129,224,36,66,173,44,244,57,255,245,165,42,49,23,42,241,180,213,151,10,155,189,47],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "ef01b7fd546a83beb687a30999e10db6db2d8153a1e79c377181c1725cee6855", "authorization_call": { "arguments": { "maximum_response_bytes": 16384, "operation_id": "read-1", "operator_namespace": "observer-demo", - "read_contract": "7dd3ae5aceaf27d9d833bd7f3b6bb49bcfbe014c67cdd02d9e75f628d7f3ad7d", + "read_contract": "727ab150b00ab03de28da4f7ae45d21fee44a05d6fe6895be28bd57ed18fd1c2", "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", - "source_effect": "8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a", + "source_effect": "6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4", "source_operation": "source-1" }, "name": "auths_gateway_recovery_read_v1", @@ -18,7 +18,7 @@ "profile_version": 2, "service": "gateway-observer-test" }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"9573c34bc7d94262a39cfec374fafc90ed2cfac06f533af200a54471578977a3\",\n \"binding_canonical\": \"{\\\"action\\\":[28,54,189,163,195,0,28,219,188,23,162,99,67,138,19,221,31,15,17,205,158,136,222,46,139,42,211,27,136,124,81,58],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/6\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[189,228,70,245,1,112,155,54,232,6,205,109,191,126,247,63,101,35,202,243,90,140,247,184,111,163,145,151,111,0,150,157],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[125,211,174,90,206,175,39,217,216,51,189,127,59,107,180,155,207,190,1,76,103,205,208,45,158,117,246,40,215,243,173,125],\\\"request\\\":[180,240,54,188,68,238,40,135,73,101,76,127,88,129,151,172,196,75,163,166,20,192,31,235,149,244,84,191,242,11,116,133]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[78,69,176,40,128,157,35,150,198,73,64,89,13,26,29,116,28,88,135,255,10,32,239,49,193,132,192,8,187,48,133,223],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[147,57,98,238,125,84,212,151,55,59,189,169,136,7,68,251,220,10,142,97,167,82,234,136,172,18,93,62,228,54,132,171],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 28,\n 54,\n 189,\n 163,\n 195,\n 0,\n 28,\n 219,\n 188,\n 23,\n 162,\n 99,\n 67,\n 138,\n 19,\n 221,\n 31,\n 15,\n 17,\n 205,\n 158,\n 136,\n 222,\n 46,\n 139,\n 42,\n 211,\n 27,\n 136,\n 124,\n 81,\n 58\n ],\n \"native_authority\": [\n 189,\n 228,\n 70,\n 245,\n 1,\n 112,\n 155,\n 54,\n 232,\n 6,\n 205,\n 109,\n 191,\n 126,\n 247,\n 63,\n 101,\n 35,\n 202,\n 243,\n 90,\n 140,\n 247,\n 184,\n 111,\n 163,\n 145,\n 151,\n 111,\n 0,\n 150,\n 157\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/6\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 78,\n 69,\n 176,\n 40,\n 128,\n 157,\n 35,\n 150,\n 198,\n 73,\n 64,\n 89,\n 13,\n 26,\n 29,\n 116,\n 28,\n 88,\n 135,\n 255,\n 10,\n 32,\n 239,\n 49,\n 193,\n 132,\n 192,\n 8,\n 187,\n 48,\n 133,\n 223\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 147,\n 57,\n 98,\n 238,\n 125,\n 84,\n 212,\n 151,\n 55,\n 59,\n 189,\n 169,\n 136,\n 7,\n 68,\n 251,\n 220,\n 10,\n 142,\n 97,\n 167,\n 82,\n 234,\n 136,\n 172,\n 18,\n 93,\n 62,\n 228,\n 54,\n 132,\n 171\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 180,\n 240,\n 54,\n 188,\n 68,\n 238,\n 40,\n 135,\n 73,\n 101,\n 76,\n 127,\n 88,\n 129,\n 151,\n 172,\n 196,\n 75,\n 163,\n 166,\n 20,\n 192,\n 31,\n 235,\n 149,\n 244,\n 84,\n 191,\n 242,\n 11,\n 116,\n 133\n ],\n \"projection\": [\n 125,\n 211,\n 174,\n 90,\n 206,\n 175,\n 39,\n 217,\n 216,\n 51,\n 189,\n 127,\n 59,\n 107,\n 180,\n 155,\n 207,\n 190,\n 1,\n 76,\n 103,\n 205,\n 208,\n 45,\n 158,\n 117,\n 246,\n 40,\n 215,\n 243,\n 173,\n 125\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"1c36bda3c3001cdbbc17a263438a13dd1f0f11cd9e88de2e8b2ad31b887c513a\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"7dd3ae5aceaf27d9d833bd7f3b6bb49bcfbe014c67cdd02d9e75f628d7f3ad7d\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"8de269c34af97f9a3c584d823c96fa54c97818bbef8216034d19fdbda935258a\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\"\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"ef01b7fd546a83beb687a30999e10db6db2d8153a1e79c377181c1725cee6855\",\n \"binding_canonical\": \"{\\\"action\\\":[65,122,98,210,120,224,214,152,194,82,159,209,122,100,122,250,137,38,77,176,53,42,251,132,215,189,242,44,141,29,181,25],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/7\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[147,16,216,225,54,22,226,167,204,22,59,188,88,71,56,60,239,64,124,186,160,242,62,170,188,123,33,34,46,44,83,252],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[114,122,177,80,176,10,176,61,226,141,164,247,174,69,210,31,238,68,160,93,111,230,137,91,226,139,213,126,209,143,209,194],\\\"request\\\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[116,70,239,162,42,152,250,6,239,135,195,43,59,81,238,53,103,135,95,107,157,232,161,198,84,40,16,186,121,199,145,139],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[148,149,21,136,228,137,148,170,141,129,224,36,66,173,44,244,57,255,245,165,42,49,23,42,241,180,213,151,10,155,189,47],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 65,\n 122,\n 98,\n 210,\n 120,\n 224,\n 214,\n 152,\n 194,\n 82,\n 159,\n 209,\n 122,\n 100,\n 122,\n 250,\n 137,\n 38,\n 77,\n 176,\n 53,\n 42,\n 251,\n 132,\n 215,\n 189,\n 242,\n 44,\n 141,\n 29,\n 181,\n 25\n ],\n \"native_authority\": [\n 147,\n 16,\n 216,\n 225,\n 54,\n 22,\n 226,\n 167,\n 204,\n 22,\n 59,\n 188,\n 88,\n 71,\n 56,\n 60,\n 239,\n 64,\n 124,\n 186,\n 160,\n 242,\n 62,\n 170,\n 188,\n 123,\n 33,\n 34,\n 46,\n 44,\n 83,\n 252\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/7\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 116,\n 70,\n 239,\n 162,\n 42,\n 152,\n 250,\n 6,\n 239,\n 135,\n 195,\n 43,\n 59,\n 81,\n 238,\n 53,\n 103,\n 135,\n 95,\n 107,\n 157,\n 232,\n 161,\n 198,\n 84,\n 40,\n 16,\n 186,\n 121,\n 199,\n 145,\n 139\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 148,\n 149,\n 21,\n 136,\n 228,\n 137,\n 148,\n 170,\n 141,\n 129,\n 224,\n 36,\n 66,\n 173,\n 44,\n 244,\n 57,\n 255,\n 245,\n 165,\n 42,\n 49,\n 23,\n 42,\n 241,\n 180,\n 213,\n 151,\n 10,\n 155,\n 189,\n 47\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 66,\n 7,\n 73,\n 6,\n 121,\n 132,\n 117,\n 195,\n 238,\n 29,\n 134,\n 42,\n 43,\n 244,\n 234,\n 224,\n 113,\n 249,\n 243,\n 111,\n 126,\n 216,\n 98,\n 129,\n 25,\n 87,\n 60,\n 118,\n 61,\n 28,\n 67,\n 54\n ],\n \"projection\": [\n 114,\n 122,\n 177,\n 80,\n 176,\n 10,\n 176,\n 61,\n 226,\n 141,\n 164,\n 247,\n 174,\n 69,\n 210,\n 31,\n 238,\n 68,\n 160,\n 93,\n 111,\n 230,\n 137,\n 91,\n 226,\n 139,\n 213,\n 126,\n 209,\n 143,\n 209,\n 194\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"417a62d278e0d698c2529fd17a647afa89264db0352afb84d7bdf22c8d1db519\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"727ab150b00ab03de28da4f7ae45d21fee44a05d6fe6895be28bd57ed18fd1c2\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"prerequisite_acquisitions\": []\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "refused_changed_fields": [ "source_effect", "source_operation", diff --git a/bindings/fixtures/gateway/recovery-prerequisites.json b/bindings/fixtures/gateway/recovery-prerequisites.json new file mode 100644 index 000000000..e7eb5a393 --- /dev/null +++ b/bindings/fixtures/gateway/recovery-prerequisites.json @@ -0,0 +1,926 @@ +{ + "schema": "auths.recovery-prerequisite-fixture/1", + "scope": "native signed recovery compilation and actual credential predicates; file dependency/restart histories use oracle entry; no installed provider/PostgreSQL claim", + "cases": [ + { + "history": "recorded", + "native_evidence_eligible": true, + "oracle_journal_grant": true, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + } + ], + "reopened_parent": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + }, + { + "history": "missing", + "native_evidence_eligible": false, + "oracle_journal_grant": false, + "children": [], + "reopened_parent": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + }, + { + "history": "lost-permit", + "native_evidence_eligible": false, + "oracle_journal_grant": false, + "children": [ + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + ], + "reopened_parent": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + }, + { + "history": "stale", + "native_evidence_eligible": false, + "oracle_journal_grant": false, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + } + ], + "reopened_parent": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + }, + { + "history": "wrong-account", + "native_evidence_eligible": false, + "oracle_journal_grant": true, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 19, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + } + ], + "reopened_parent": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + }, + { + "history": "excess-capability", + "native_evidence_eligible": false, + "oracle_journal_grant": true, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + } + ], + "reopened_parent": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + } + ], + "unadmitted_parent_refused": true, + "substituted_membership_witness_refused": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 86a1ce699..5205fb0d5 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/10", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/11", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/10", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/11", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1608,13 +1608,14 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] recovery-refinement = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] recovery-entry = [ + "product/runtime/auths-gateway/src/effect_prerequisite_tests.rs#native_prerequisite_compilation_fixture_is_current", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] recovery-compilation = [ diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 8f3eef965..05907a0b5 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -603,3 +603,30 @@ reservations, preserving the 34-reservation limit. Admission requires at most fence. Journal `/10` rejects the superseded acquisition layout. Compiler `/6` binds the read's managed reservation set. Independent acquisition/disclosure, credential replacement and installed race/fault evidence remain separate work. + +## Recovery credential prerequisites + +An independently authorized recovery read uses the same installed account and +capability checks as mutation. Its native request commitment and human review +include an ordered account/denied-capability acquisition plan derived from the +pinned recipe and connection. The installation-only probe remains a separate +onboarding obligation. The recovery action's source and recipe commitments fix +which declarations are eligible; approval binds their complete resolved bytes. + +Use the existing prerequisite records, one-call/full-byte allocations, component +keys, shared reducer and consumed transport permits. A child may name a reserved +mutation or a reserved independent recovery acquisition; it cannot name another +child. The parent must remain reserved at child entry. Recovery's final entry +fences all required child records/allocations, freshness and actual account or +capability results, together with its managed policy slots and original source. +A failed or lost child never authorizes replayed I/O. Ancillary reads consume +only their explicit child allowance; the parent managed read policy is not +charged for every component. + +Compiler `/7` binds the complete read transport witness. Journal `/11` rejects +old recovery plans and authenticates child membership against either closed +parent protocol. Recovery has at most five prerequisites, for at most 48 final +entry records including 32 managed slots and three native dependencies. The +existing seven-prerequisite and 64-record bounds remain unchanged. No operator +attestation is silently promoted into native effect authority: first-install +and candidate-rotation authorization remain separate unfinished cutovers. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 338a3ebe8..929d176ab 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -179,7 +179,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/10`; a store holding obsolete records is refused as + `auths.gateway-attempt/11`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 5e75779cc..fe45c055d 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -743,6 +743,44 @@ closure regeneration passed after that correction (one artifact-generation test) full installed/process/PostgreSQL/fault/formal/performance and hosted evidence remain required. +## Recovery credential prerequisite checkpoint + +- Recovery compilation now includes the installed recipe's account and + denied-capability reads in its immutable request commitment and native + review. Compiler `/7` uses the complete acquisition transport witness; + journal `/11` rejects superseded recovery plans. The installation-only + credential probe remains an onboarding obligation. +- Mutation and recovery share the credential-plan compiler, prerequisite + record/allowance, consumed-permit acquisition helper and account/capability + predicates. A child can enter only while its mutation or independent recovery + parent is reserved. Another prerequisite cannot be its parent. Recovery final + entry fences all required children/allocations and evaluates their purpose + and freshness alongside native authority, original source and managed slots. +- The production recovery runtime no longer rejects recipes wholesale for + declared credential checks. It acquires and records them in order, stops on + a failed account/capability predicate, and validates them again at final + entry. Child replay loads original evidence; unknown children cannot remint + permits. Their explicit allowances do not charge the parent's managed budget + again. At most five recovery children give a maximum 48-record entry fence. +- `recovery-prerequisites.json` covers recorded, missing, lost-permit, stale, + wrong-account and excess-capability histories using native Stripe recovery + proofs and real file state. Native actual-purpose evaluation is reported + separately from oracle entry. The corpus checks full human review, exact + recompile, missing-parent refusal, corrupted membership witnesses, retained + child charges and restart projections. It does not claim installed provider + transport or PostgreSQL evidence. +- The prerequisite/recovery artifact generators passed after correcting a + missing type import and making the Stripe source fixture retain its required + response-derived refund locator. The fixture does not invent an observable + target for a source without that locator. Binding/approval, mutation entry, + admission, attempt/replay, code inventory, application framing and production + CLI/socket generators also passed. Final source closure is regenerated with + this checkpoint. No broad local gate or hosted CI has been observed. +- Remaining: first-install and candidate-rotation read authorization/journaling, + safe replacement credentials, general acquisition, disclosure/ACK, Python + decision removal, authenticated UI/bindings and full installed/process/adapter/ + formal/performance/CI acceptance. No A01–A22 criterion is fully closed. + ## Phase gates | Phase | State | Outstanding gate | @@ -750,7 +788,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation and ancillary reads, general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation reads, general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index a7c2e4aed..1b54840be 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -365,3 +365,22 @@ corpus must cover count/sum exhaustion, retained unknown charges, window changes source/allocation collisions and missing/substituted membership. Full adapter concurrency and performance acceptance remain open until executed evidence is recorded in the AP074 ledger. + +### Credential prerequisites of independent recovery + +The account/denied-capability subset is identical between mutation and recovery: +closed recipe reads, expected installed account, refused HTTP statuses, version +checks, one invocation and full response ceiling, durable receipt, and 30-second +conservative evidence age. Both paths now use the same compiler subset, journal, +permit-consuming acquisition helper and native evidence predicates. Mutation +keeps its additional pre-entry/relative-ceiling semantics. First-install probes +and candidate credentials remain an independent authorization obligation. + +A recovery parent's request commitment authenticates its complete prerequisite +witness. The existing child membership decoder accepts the closed mutation or +recovery parent protocol and refuses disclosure; the source fence refuses a +child as a parent. Final entry requires all child evidence under the same fence. +The six-case recovery prerequisite corpus records the native predicate result +separately from oracle journal grants, so synthetic wrong-account/capability +histories cannot masquerade as installed entry-denial evidence. Installed +transport, PostgreSQL and final formal/performance gates remain open. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index e48c5b9c9..0d578f9eb 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -152,7 +152,7 @@ Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. The concrete native encoding is `auths.bound-effect/3`, with effect compiler -`auths.gateway-effect-compiler/6`. Reservations use a closed window alternative: +`auths.gateway-effect-compiler/7`. Reservations use a closed window alternative: fixed epoch-aligned windows or the retained source effect's lifetime. Mutation count/sum reservations retain fixed windows; recovery acquisitions declare separate acquisition-count and response-byte charges against one source. A @@ -232,7 +232,7 @@ the approved recipe. Account for their entry and limits explicitly; they must no be invisible I/O outside the model. Acquiring those bytes does not authorize disclosing them to the agent. -Mutation compiler `/5` retains an ordered prerequisite acquisition plan beside +Mutation compiler `/7` retains an ordered prerequisite acquisition plan beside its verified command and commits the complete plan in the transport identity. The plan names at most seven requests: one account check, up to four denied capability checks, one pre-entry read and one relative-ceiling read. Each pins @@ -245,7 +245,7 @@ these declarations. The declaration alone is neither a capacity reservation nor an entry permit; runtime must durably account and grant every constituent read through the shared journal before contacting the provider. -The concrete journal encoding is `auths.gateway-attempt/10`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/11`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded @@ -257,6 +257,17 @@ recorded, fresh responses. Receipt time is immutable, and evidence age uses the earlier grant time conservatively. These requirements do not waive tighter native evidence freshness or independently authorized later observation. +Independent recovery uses the same account/denied-capability subset, with at +most five child reads. Its complete request commitment authenticates these +declarations, and the native review renders their resolved requests and limits. +The installation-only probe remains separate. A prerequisite source may be a +reserved mutation or reserved independent recovery acquisition, never another +prerequisite. Recovery final entry fences all child records and allocations and +evaluates their account/capability predicates and freshness. The same consumed +permit and retained-response runtime helper serves both parent types. No child +recharges its parent's managed policy. The maximum recovery entry set is 48 +records within the existing 64-record bound. + Final mutation entry must also evaluate each prerequisite's actual purpose against those retained responses. Signed pre-entry observations must have valid canonical signatures from the pinned observer and exactly match the retained subject, diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover index ad19cc89f..943402246 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover @@ -1 +1 @@ -{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ"}} \ No newline at end of file +{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit index 7a323bc0c..1a61d5c94 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit @@ -1 +1 @@ -{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODcsMjEzLDc4LDEwOCwxNjUsODUsNDgsMjUwLDE3LDEwMiwyNiwxNzEsMjM3LDE0MywxNTQsMjM0LDgxLDkzLDIxNywyOSwxODgsMTcxLDEwMSwxNzksMjAsMTI3LDE4MCwxOTMsMzAsNDUsNzAsMTNdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiMGs3NEdFeVBwY0ItRGtSZGJmYWxGSG9velFMQ0pBUjNYcmI5VTB4YWRObjNjaGJKbjFKdUE4VU1qMjdJZHAtV0Y1MTk1Y3A0UFlVRnVwajROR082QVEifQ"} \ No newline at end of file +{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index aa8fcd941..9205cc337 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 5beef93f2..ecbfe04c8 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index a88ea1d1d..edcfce7ee 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 1048fe1be..1d8ea3d6e 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 4c3b12e29..b6d429476 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/10","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/6\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[49,142,222,222,167,93,85,40,123,8,169,163,144,143,125,64,130,41,169,199,162,118,218,254,52,120,198,30,83,74,112,0],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"ndgbWwt9S3VtTJpI5PQO22qbvZCJQZ0jD5aGr1I7hkOtg_8tNZFhKArWoexJYoS8wzmsEPTE0Qs5eLc0_ctYDQ\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"318ededea75d55287b08a9a3908f7d408229a9c7a276dafe3478c61e534a7000","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index e8677aebdba25b0f108ad0301eba2976ffdfc6de..fc54302579e51f414e30b8ce4fde5be919bd54db 100644 GIT binary patch delta 1072 zcmeH_OG*Pl5Qdq!6LFzn)(Y-Q=<0Xx6itxHn2@LuQ5kw>dWeaSyfBFykDw584i|HV zoW?_Fdk0rRsG=Tx^+UnGU<>xa0xXsraS*6tfAeeY4XFV{2EIrQTmTgu6bI^q3P5du zGVQknC`#a-mOcp>4(J=D!4R*29`(nBdRzkj76wdt9p)$MSpx<^>pQsJbJPC)(2Zg{ zp1*H(+g3*IG3~JH$kmV23hU*qd}#YmIIA4Q(WD+XpW`HIKZK&uYrc$3?c%)idfM&F ztHC%q>y4ijIjV?(31^dOtEMmOq?(;fipKVCX@&orf9~8IYE+0B=QPV5x2PQ^nRB_# yG(&5M6%JWKg_U_?QtMKZIzvUylueaLgr0}xYVp0k4E}AgBDVh%TNGirR{8-kZYRV5 delta 1072 zcmeH_&q@O^5XRYh6Y-#6&kEk=kW7+Ia#L(8-HPqf($cCd>2BIu(f(U(@!}&Wls<=t zeTF`b51}c21y4nWkC|b9GcfS2*ou8Jk7VnE$n*T{{P274ook>R0dXtpOVA9I08W6S ztAP3r@tMQ8lglW;cO@gh>2|6&1OlZBa3jG%xE9?Bt-yhbfpjYrfjq$dnO%$@r*;;Z zbop^KY`!G@Zfl&PTwo@8ZE~l-L zT?Fk>UCrN~XT@5hNWz)0H!+Fgv|R|Z>hWoAhyPoCo!nh8s%+xINRbGEN_L4d+AvL2 wPbQowL~V2|4N5;TJZ;KtV{h!z(3-XoRFGXD=H~;_u diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 393e3638f5473aa5737b4bea69faaa7a83928cce..73909ec52357700f584f1a60ab32acd57c1e512b 100644 GIT binary patch delta 1072 zcmeH_OG*Pl5QZ7uiMUWOYXx^DboIM;iYCZpOi0v-s0=+bJ;cOEUYNvdpS533 zIz4&WA0?;V(W4@VWzjd`bUbNR^+kCWeLzYlsWuBPSx|F2OP?0lbQza6iXJM&Qe6KBne_Jex?f=9UMOgX_egK9s BC}IEr delta 1072 zcmeH_K}rKb5Jef?iMUWOYXx_;=&tUb?%pXTk&I$8BqSs%LuaOw7}3PcV1gTuppXmX z1}^3dxq_GQ5ZWPEa22HZR2B8Apx`fXfgj8x`Eob%JU>6#``&)z8Yo9VT#Nb=Gy^4o z6QJlSpuR(V<}mK$G79ir$p~<|p6V5WK&b*;NpKLZMR!6gaG+u!-3mn@cW`@bXXE>c zO(T=d-}i^jr=;I)O*36*&8!iOE20)w5udv+o%0~Zp$o47DiBtoE)U80OO zOcT|U2`36s8y!o7(oam!GA>o@Q!5xZk`OWv3g!G~XX*XhVnb~IC$`9g!k708njjL!pYls`%=Mq86}#XBJ@fwGsz`s-o4;+7nU(hzz_)4O{>f925uYg9<=x zfHLi;1Sm@2o|Zld7!K$QrNI#IfFAYBgnC>8{t5%8ybtpo^{fGdp!GFeZMy03X6z=h zE#}`#y^fWkyGy(5B6QJST4(*dosaEsfV28m9F|esx{s5vbK4Nd{no?8G*3^ukB7aX zJRcRwQNI`{vRfA;)0mahc2l24#Of$5GSmBT*R9KlOCbcdlsWVjMOxaY4MCfX=@gDpDnTgtW delta 779 zcmd^+-%0{e5XM=gAi9crg02TTXU_k-A}!QV7e&#E<+yv)jMCgCrJG(M@JV9tdj)U1 z=mCPDM~II27RB%}-!Q)!7-j`4cwqs_zjvY_ka=zQtMJSXP>z7O5tRxI11*3Ppy(Y? z=@H31#=U$-0n%GWfYVLatO*24HQ-u;gYYH#6-I*xH3Q{GC<3{Lt3$V#-ppJY*=+f< zHE!Q0!+vL;nI>yzt;)148etvrq5s%Bt%N-?E(&`-qh&R^t!KkXXSLqhsCqK%Ox&W< zoiz3Q=`JlbS|t*u!d=89inDGp%-^<;3jgU^6D(i%KL7AXm+$+R$Bb&1_^?VOLZDWC mqOGya5Is-{CmPXM6Dx~KCU)Q$S2~u|3C67=gyiYLNAL@3#@E3B diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index 510a2ce03b85e85928d6ed9df03eabf5b2606e56..539ae0766798ae10a49d5d7c1d08a79b1099c626 100644 GIT binary patch delta 487 zcmbQKK2v>yF{9z;cbxHzjOLsDxL-5Z8yZ>a7#bSu04XyI9TQU>BU2L{a}ymSATl!5 zF|@GMF*3FQiW=w`8Jg*s09Bg-v4M`IiH;$VVQ!&gX#h0A5U3QW*}w>>+)T$1L>cQC zn*+@;2J(!6YAtmv4RtImVs&DaQY#8Fi&Bf@6H6xlW6cUnH1kQ#P0lcm^hxz|PIfiU zP76vaN-W4TtaR0l_bK;_56q8G@(IiFGWE|6EGxG34hhbv^2jPM3ok55^35*EGdFN_ lH7&ICsw}Sv^0o-|GjL0BDc`)0O`mxr`8J<%^K-#Xi~y$Oh!6k( delta 487 zcmbQKK2v>yF{8oecbxHzjAontxL-5Zn^@`?ni%OA89}h2nYoUov5tkQj){Sep%IX! zV`v6cVrC3fW&*@O+Q?ML49GM#&@nND$XbF_80i=qTId*ou&IfTDUfRfG{VwC2dL1( zSjQZw#n4E{AXX?vnaJVKCxu-Kh~_Uyp;5$@bVJNVB@fo5U&DH(||yKBcsBk zvM6V-z$k+(7t=)dB12E}jBNjs^mvOBzbLm1Z^xqW{L~7s$oyc7@~Yfo*MJaLgTP|b eRG(yn_~epEm%z>Y*z}o4l5g`FH$NBL#0UW335PHM diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 9479c45d8..5f29a96f6 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"6f909e744dc4d367430f0362d3f04cd33ced9b8a2b49d3e7538e356e984a8311"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"e32cb0f59691a888fa7c30dbff672cba9dd539d86272136e03b9b89e83e65e1a"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"9ffb468a1c963c92b85578892fe943a63f221da8305871f88406ed29a6b2eb40"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"963ee4736520a84aeb361b0bacea63bf3cd442c8c23dc157d7fc0203eb5fd127"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"f769475da6e81962aedbd6c6a7ffa131935250eeaa0190d53f9daca79e31aee5"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"91222f74f87fec987ca7b8a9d37d5b6e8523ea5d29073f8ad34ab961cf40b194"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"428844f4ad3d85daa6cebcb67504f6bb72bddd450f2ca0878a67cb7c36ac8938"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"c9b50e2e1401c9272e20a74fc649b4d70fac3f2cf1a4e3997965d4a43db2297b"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"bcb29a26957ebe7eb19480155d537538bb7777285fa1f3dfcb847e7c3e269199"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7b80f0053a368750acab902fe438251f0f7f12c67d9550e650f576fe66574878"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"31df8baf384d5433e9f9b108e684de8862ba3c3beeabfcf70c6ef2beedc1cecb"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"0acb5f556558273a95362798289df5f5dc2dee65931748289e901b44a320b700"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"7ba35eb603312947cf548b4b8b2249a01597b02e2c8e46a88c2e63ca3fce65c7"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"f16e5ae91963ff88a11ca1f0808da48f2bbd66f8bb30e97ba12efcfe44addde0"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"642596880b4bd1c0227e22b11593baf22793e3de96507c1259ca0be9975911eb"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"c023111488270f9e1395e7fad014da9dd6e8981855930c55c9a670a29aacdb80"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"c02d7f4d30c0c756a7c281276e143f57c73a519e888423f7f1c7a89fa9eff1b3"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"db2961901bf4b3f415ccc3ff24286aa55e22cd77cfe1a804daa830d2ab3abb4b"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"83baeba3afe26411ee6fd78c5ac1333283c8a2faaad36f72529ec3599309309f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"e6706daf9d6a399260ec910090942fe7137483f203c7761d7f70eb67c840e7e8"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"f87cda8b02bc28f0d699e3f68b4ac911985b569ab89a3131723829ccd3d733a3"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"814a4865cc24213a92ff6799a86a008ba18babd905ba0dcc0e6737a819dc1d02"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"91222f74f87fec987ca7b8a9d37d5b6e8523ea5d29073f8ad34ab961cf40b194"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"a408bb8e94cf35ae23f91c92143e577dd6d078548f59cfb98a0acdabc13054da"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"522e6c3951e7c9eb245c00154a0f6a5420bc349a57ea8d9738d6e2b6903fa199"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"0dde0912a42d2f8408f2b1997e693a655fc3a6e0ffcc8a741e329b886cb71d0d"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2141c5fe226b94a16fbe02e2ec86ead155a4162c9181bce85c50b528e2ea49bb"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"366be49b2fbd174c490a094d8bfa2575aabf423d4f4ef648f190e7b84b3238d9"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"41147db2e2733d28b0c64e01f52586f4fb55bb6cd986bab24c562baa806593a0"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"1b060e74685a3b1bf9f46337968a832c3fd69618e8fe7694ffd42c1a8126c57b"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"40908f5018b42e6629b074ebea294e73d2b843d7e6bc3b0c30188889d29b82e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"2b75197b410bf823a4ebfda91ee5eb6c78905a4940ce0736f488a5d0a4926951"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"30f4ba5d71e424074622b6e8197307914e4271aa7f995276bb910d633b0c8504"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 5f4d727bb..0e9aa1048 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -22,6 +22,7 @@ mod acquisition; mod prerequisite; pub(crate) use acquisition::{ AcquisitionCapacity, AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, + RecoveryPlan, }; pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; use prerequisite::Prerequisites; @@ -36,7 +37,7 @@ pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/3"; pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/6"; +const COMPILER: &str = "auths.gateway-effect-compiler/7"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -835,7 +836,13 @@ impl BoundEffect { .map_err(|_| not_entered("gateway.effect.invalid-binding"))?; review } - CompiledEffect::Acquisition(_) => self.review.clone(), + CompiledEffect::Acquisition(command) => { + let mut review = self.review.clone(); + review["prerequisite_acquisitions"] = + serde_json::to_value(&command.prerequisites) + .map_err(|_| not_entered("gateway.effect.invalid-binding"))?; + review + } }, effect_id_hex: hex::encode(self.binding.id().as_bytes()), binding_canonical, @@ -1092,12 +1099,22 @@ impl ApprovedEffect { } } + pub(crate) fn recovery_plan(&self) -> Result { + match &self.effect.command { + CompiledEffect::Acquisition(command) => command.journal_plan(), + CompiledEffect::Mutation(_) => Err(EffectBindingError::Invalid), + } + } + + fn prerequisites(&self) -> &Prerequisites { + match &self.effect.command { + CompiledEffect::Mutation(command) => &command.prerequisites, + CompiledEffect::Acquisition(command) => &command.prerequisites, + } + } + pub(crate) fn prerequisite_plans(&self) -> Result, EffectBindingError> { - let CompiledEffect::Mutation(mutation) = &self.effect.command else { - return Err(EffectBindingError::Invalid); - }; - mutation - .prerequisites + self.prerequisites() .kinds() .map(|kind| self.prerequisite(kind).map(|(plan, _)| plan)) .collect() @@ -1107,11 +1124,13 @@ impl ApprovedEffect { &self, kind: PrerequisiteKind, ) -> Result<(PrerequisitePlan, ClosedPrerequisiteRead), EffectBindingError> { - let CompiledEffect::Mutation(mutation) = &self.effect.command else { - return Err(EffectBindingError::Invalid); + let (index, read) = self.prerequisites().select(kind)?; + let transport = match &self.effect.command { + CompiledEffect::Mutation(mutation) => { + request_bytes(&mutation.command.request, &mutation.prerequisites)? + } + CompiledEffect::Acquisition(command) => command.request_bytes()?, }; - let (index, read) = mutation.prerequisites.select(kind)?; - let transport = request_bytes(&mutation.command.request, &mutation.prerequisites)?; let plan = PrerequisitePlan::new(self.effect.binding(), index, transport)?; Ok((plan, read.clone())) } diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index defda27d3..755f946ca 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -87,18 +87,28 @@ impl RecoveryReadTarget { &self.request } - pub(crate) fn journal_plan(&self) -> Result { + fn request_bytes( + &self, + prerequisites: &Prerequisites, + ) -> Result>, EffectBindingError> { + canonical(&json!({"request": self.read_wire(), "prerequisite_acquisitions": prerequisites})) + } + + fn journal_plan( + &self, + prerequisites: &Prerequisites, + ) -> Result { + let transport = self.request_bytes(prerequisites)?; Ok(RecoveryPlan { source_binding: String::from_utf8(self.source.to_private_bytes()?.to_vec()) .map_err(|_| EffectBindingError::Invalid)?, - request: commitment( - "auths.effect-acquisition-request/1", - &canonical(&self.read_wire())?, - )?, + request: commitment("auths.effect-acquisition-request/2", &transport)?, contract: commitment( "auths.gateway-recovery-read/1", &canonical(&self.contract())?, )?, + transport_canonical: String::from_utf8(transport.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, maximum_response_bytes: u64::try_from(self.request.maximum_response_bytes()) .map_err(|_| EffectBindingError::Invalid)?, }) @@ -111,6 +121,7 @@ impl RecoveryReadTarget { action_commitment: [u8; 32], native_authority: [u8; 32], bound: Option<&crate::bounds::BoundAdmission>, + prerequisites: &Prerequisites, ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); let connection = Zeroizing::new( @@ -127,7 +138,7 @@ impl RecoveryReadTarget { { return Err(invalid()); } - let plan = self.journal_plan().map_err(|_| invalid())?; + let plan = self.journal_plan(prerequisites).map_err(|_| invalid())?; let capacity = plan.capacity().map_err(|_| invalid())?; let mut reservations = capacity.reservations(); reservations.extend(managed_reservations( @@ -210,6 +221,7 @@ pub(crate) struct RecoveryPlan { pub(crate) source_binding: String, request: [u8; 32], contract: [u8; 32], + transport_canonical: String, maximum_response_bytes: u64, } @@ -260,6 +272,22 @@ pub(crate) struct AcquisitionCapacity { } impl RecoveryPlan { + pub(crate) fn matches_target( + &self, + target: &RecoveryReadTarget, + ) -> Result { + let witness: Value = serde_json::from_slice(self.transport_canonical.as_bytes()) + .map_err(|_| EffectBindingError::Invalid)?; + Ok(self.source()? == target.source + && self.maximum_response_bytes == target.request.maximum_response_bytes() as u64 + && self.contract + == commitment( + "auths.gateway-recovery-read/1", + &canonical(&target.contract())?, + )? + && canonical(&witness["request"])? == canonical(&target.read_wire())?) + } + pub(crate) fn source(&self) -> Result { EffectBinding::from_private_bytes(self.source_binding.as_bytes()) } @@ -291,6 +319,17 @@ impl RecoveryPlan { ) -> Result { let source = self.source()?; let capacity = self.capacity()?; + let transport = self.transport_canonical.as_bytes(); + if transport.len() > MAX_EFFECT_BYTES + || self.request != commitment("auths.effect-acquisition-request/2", transport)? + { + return Err(EffectBindingError::Invalid); + } + let witness: Value = + serde_json::from_slice(transport).map_err(|_| EffectBindingError::Invalid)?; + if canonical(&witness)?.as_slice() != transport { + return Err(EffectBindingError::Invalid); + } if source.wire.namespace != effect.wire.namespace || source.wire.partition != effect.wire.partition || source.wire.epoch != effect.wire.epoch @@ -354,6 +393,7 @@ impl AcquisitionCapacity { pub(super) struct VerifiedAcquisition { pub(super) target: RecoveryReadTarget, pub(super) bound: Option, + pub(super) prerequisites: Prerequisites, #[cfg(unix)] actors: Vec, #[cfg(unix)] @@ -363,6 +403,14 @@ pub(super) struct VerifiedAcquisition { } impl VerifiedAcquisition { + pub(super) fn journal_plan(&self) -> Result { + self.target.journal_plan(&self.prerequisites) + } + + pub(super) fn request_bytes(&self) -> Result>, EffectBindingError> { + self.target.request_bytes(&self.prerequisites) + } + #[cfg(unix)] pub(super) fn private_review(&self) -> Value { json!({ @@ -372,6 +420,7 @@ impl VerifiedAcquisition { "arguments": self.arguments, "method": "GET", "recovery": self.target.contract(), + "prerequisite_acquisitions": self.prerequisites, }) } } @@ -432,12 +481,16 @@ pub fn compile_recovery_acquisition( auths_codec::encode_canonical_action(verified.canonical_action()).map_err(|_| invalid())?; let action_commitment = commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; + let prerequisites = + Prerequisites::credentials(installed.recipe, *installed.connection.account_commitment()) + .map_err(|_| invalid())?; let binding = target.binding( installed, &operation, action_commitment, native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?, bound.as_ref(), + &prerequisites, )?; let contract = target.contract(); let effect = BoundEffect { @@ -447,6 +500,7 @@ pub fn compile_recovery_acquisition( command: CompiledEffect::Acquisition(Box::new(VerifiedAcquisition { target: target.clone(), bound, + prerequisites, #[cfg(unix)] actors: branches.actors, #[cfg(unix)] diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index 582fba577..d4fc52796 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -1,4 +1,4 @@ -//! Closed prerequisite acquisitions derived from a verified mutation and recipe. +//! Closed prerequisite acquisitions derived from a verified effect and recipe. //! These declarations are committed by the parent effect and displayed by its //! native review. They grant neither read entry nor disclosure; the journal must //! independently acknowledge each one-use acquisition before transport. @@ -14,7 +14,7 @@ const MAX_PREREQUISITES: usize = 7; const MAX_RESPONSE_BYTES: usize = 65_536; pub(crate) const MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS: u64 = 30; -/// The complete ordered set for one mutation. Construction is private to the +/// The complete ordered set for one mutation or independent recovery read. Construction is private to the /// native compiler; an application cannot append a request or select a purpose. #[derive(Serialize)] pub(super) struct Prerequisites(Vec); @@ -130,17 +130,16 @@ impl Prerequisites { Self(Vec::new()) } - pub(super) fn compile( + pub(super) fn credentials( recipe: &CompiledRecipe, - command: &VerifiedCommand, account: [u8; 32], ) -> Result { let mut plan = Self(Vec::new()); let reads = recipe .credential_reads() .map_err(|_| EffectBindingError::Invalid)?; - // The onboarding probe is not a mutation prerequisite. Commissioning - // must acquire its own separately bound probe, never inherit this plan. + // The onboarding probe is not an installed mutation/recovery prerequisite. + // Candidate checks need their own authority, never inherit this plan. if let Some(guard) = recipe.guard_checks() { match (reads.account(), guard.account_pointer) { (Some(read), Some(json_pointer)) => plan.push( @@ -171,6 +170,16 @@ impl Prerequisites { } else if reads.account().is_some() || !reads.denied().is_empty() { return Err(EffectBindingError::Invalid); } + canonical(&plan)?; + Ok(plan) + } + + pub(super) fn compile( + recipe: &CompiledRecipe, + command: &VerifiedCommand, + account: [u8; 32], + ) -> Result { + let mut plan = Self::credentials(recipe, account)?; match ( command.request.pre_entry_read(), recipe.pre_entry_pointers(), @@ -267,7 +276,7 @@ impl Purpose { } } -/// Private membership witness for one read in the exact approved mutation. +/// Private membership witness for one read in the exact approved parent effect. /// Audit decoding cannot construct the sealed request or grant transport entry. #[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] #[serde(deny_unknown_fields)] @@ -324,13 +333,15 @@ impl PrerequisitePlan { fn declaration(&self) -> Result { let source = self.source()?; - let super::Protocol::Mutation { request } = source.wire.protocol else { - return Err(EffectBindingError::Invalid); + let (request, domain) = match source.wire.protocol { + super::Protocol::Mutation { request } => (request, "auths.effect-transport/1"), + super::Protocol::Acquisition { request, .. } => { + (request, "auths.effect-acquisition-request/2") + } + super::Protocol::Disclosure { .. } => return Err(EffectBindingError::Invalid), }; let bytes = self.transport_canonical.as_bytes(); - if bytes.len() > super::MAX_EFFECT_BYTES - || request != super::commitment("auths.effect-transport/1", bytes)? - { + if bytes.len() > super::MAX_EFFECT_BYTES || request != super::commitment(domain, bytes)? { return Err(EffectBindingError::Invalid); } // This bounded value is only an authenticated membership witness. It diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 5eff4bcc2..78a8e43b8 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -15,6 +15,9 @@ mod prerequisite_tests; #[path = "effect_read_budget_tests.rs"] mod read_budget_tests; +#[path = "effect_recovery_prerequisite_tests.rs"] +mod recovery_prerequisite_tests; + /// Native read authority is independent of an expired source writer. File /// provenance is real; the source entry is a test grant with no provider send. #[tokio::test] @@ -819,12 +822,10 @@ async fn exercise_recovery_refinement( .await .expect("terminal contract remains available for replay"); assert!( - retained.journal_plan().expect("retained plan") - == read - .recovery_target() - .expect("read target") - .journal_plan() - .expect("approved plan") + read.recovery_plan() + .expect("approved plan") + .matches_target(&retained) + .expect("retained target") ); assert!( matches!( diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index ec3bed41e..ca9ca5f55 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -212,6 +212,8 @@ async fn native_prerequisite_compilation_fixture_is_current() { journals.push(journal_witness(&approved, &policy, base).await); if base == "stripe" { guard_evidence_fixture(&approved, &installed); + super::recovery_prerequisite_tests::fixture(&approved, &installed, &policy, &root) + .await; } cases.push(json!({ "recipe": base, @@ -237,7 +239,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/10", + "attempt_schema": "auths.gateway-attempt/11", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs new file mode 100644 index 000000000..1f8c89509 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs @@ -0,0 +1,335 @@ +//! Recovery credential prerequisites share mutation's journal and predicates. +//! File histories use oracle entry; native evidence evaluation is tested apart. +use super::*; +use crate::effect::{ApprovedEffect, PrerequisiteKind, compile_recovery_acquisition}; +use crate::entry::EntryValidation::Oracle; +use crate::store::BoundedClaim; +use crate::{AcquisitionClaim, AcquisitionStage, GatewayAttempts}; +use std::sync::Arc; + +#[allow( + clippy::too_many_lines, + reason = "one native recovery/child history emits a bounded evidence corpus" +)] +pub(super) async fn fixture( + source: &Arc, + installed: &EffectInstallation<'_>, + policy: &EffectPolicy, + root: &Signer, +) { + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let reader = signer(0x33); + let observer = signer(h::OBSERVER_SEED); + let mut cases = Vec::new(); + for history in [ + "recorded", + "missing", + "lost-permit", + "stale", + "wrong-account", + "excess-capability", + ] { + let directory = tempfile::tempdir().expect("directory"); + let path = std::fs::canonicalize(directory.path()) + .expect("canonical") + .join("journal"); + let attempts = GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("store")), + policy.clone(), + ) + .expect("attempts"); + let BoundedClaim::Claimed(parent) = attempts + .claim_bounded(source, NOW, Oracle { now: NOW }) + .await + .expect("source claim") + else { + panic!("source"); + }; + // Establish a response-recorded source using the existing mutation fixture's + // explicit-time entry oracle. These synthetic bodies do not establish + // that an installed mutation could pass its prerequisite predicates. + for plan in source.prerequisite_plans().expect("source plan") { + let kind = plan.kind().expect("kind"); + let AcquisitionClaim::Reserved(child) = attempts + .claim_prerequisite(source, kind, NOW, Oracle { now: NOW }) + .await + .expect("source child") + else { + panic!("child"); + }; + let (granted, permit) = child + .grant_entry(source.clone(), Oracle { now: NOW }, NOW) + .await + .expect("source child grant"); + drop(permit); + granted + .record_response(200, true, b"{}", NOW) + .await + .expect("source response"); + } + let (granted_source, permit) = parent + .grant_entry( + source.clone(), + Oracle { now: NOW }, + NOW, + &crate::GatewayPreEntry::default(), + ) + .await + .expect("source grant"); + drop(permit); + let body = b"{\"id\":\"re_SYNTHETIC074\"}"; + let locator = source + .command() + .expect("mutation") + .request + .observation_template() + .expect("observation template") + .extract_locator(body) + .expect("source locator"); + use sha2::Digest as _; + granted_source + .record_response(200, sha2::Sha256::digest(body).into(), Some(locator)) + .await + .expect("synthetic recorded source response"); + let source_operation = + LogicalOperationId::parse(source.effect().binding().journal_identity().1) + .expect("source operation"); + let target = attempts + .retained_recovery_target( + installed.recipe.namespace(), + &source_operation, + *installed.recipe.digest(), + ) + .await + .expect("target"); + let call = target + .authorization_call( + installed.recipe, + &LogicalOperationId::parse("recovery-with-checks").expect("operation"), + ) + .expect("call"); + let context = h::context_for_tool(root, &observer.principal, NOW, &call).expect("trust"); + let grant = h::grant_for_tool( + root, + &reader.principal, + None, + window(NOW - 3_600, NOW + 3_600), + &call, + ) + .expect("read grant"); + let submission = submission_for_call(root, &reader, &grant, &call, &[]); + let read_installation = policy.installation( + installed.recipe, + &context, + installed.connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = compile_recovery_acquisition( + &read_installation, + &target, + NOW + 1, + &submission.proof, + &submission.action, + ) + .expect("recovery compilation despite mutation spend-sum requirement"); + let review: Value = serde_json::from_slice( + &effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("bytes"), + ) + .expect("JSON"); + let declarations = &review["semantic"]["prerequisite_acquisitions"]; + assert_eq!(declarations.as_array().expect("declarations").len(), 3); + assert_eq!(declarations[0]["purpose"]["kind"], "account"); + assert_eq!(declarations[1]["purpose"]["kind"], "denied-capability"); + assert_eq!(declarations[2]["purpose"]["index"], 1); + assert!( + !declarations.to_string().contains("/balance"), + "onboarding probe remains separate" + ); + let request = effect + .approval_request(NOW + 1, NOW + 100) + .expect("request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approved = Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW + 1) + .expect("approval"), + ); + approved + .validate_for_entry(&read_installation, NOW + 2) + .expect("fresh native recompile"); + let plans = approved.prerequisite_plans().expect("plans"); + assert!( + attempts + .claim_prerequisite( + &approved, + PrerequisiteKind::Account, + NOW + 1, + Oracle { now: NOW + 1 } + ) + .await + .is_err(), + "child needs admitted recovery parent" + ); + let AcquisitionClaim::Reserved(parent) = attempts + .claim_recovery(&approved, NOW + 1, Oracle { now: NOW + 1 }) + .await + .expect("recovery admission") + else { + panic!("recovery parent"); + }; + let mut children = Vec::new(); + let mut evidence = Vec::new(); + for plan in &plans { + let kind = plan.kind().expect("purpose"); + let capacity = plan + .validate(approved.effect().binding()) + .expect("acquisition parent membership"); + assert_eq!(capacity.attempts, 1); + let mut changed = serde_json::to_value(plan).expect("plan"); + changed["transport_canonical"] = json!("{}"); + let changed: crate::effect::PrerequisitePlan = + serde_json::from_value(changed).expect("witness"); + assert!(changed.validate(approved.effect().binding()).is_err()); + if history == "missing" { + continue; + } + let AcquisitionClaim::Reserved(child) = attempts + .claim_prerequisite(&approved, kind, NOW + 1, Oracle { now: NOW + 1 }) + .await + .expect("child admission") + else { + panic!("child reservation"); + }; + let (granted, permit) = child + .grant_entry(approved.clone(), Oracle { now: NOW + 1 }, NOW + 1) + .await + .expect("child grant"); + assert!(matches!( + permit.request(), + crate::store::AcquisitionRequest::Prerequisite(_) + )); + drop(permit); + if history == "lost-permit" { + drop(granted); + } else { + let (status, body) = match kind { + PrerequisiteKind::Account => ( + 200, + if history == "wrong-account" { + b"{\"id\":\"acct_OTHER\"}".as_slice() + } else { + b"{\"id\":\"acct_TESTACCOUNT01\"}".as_slice() + }, + ), + PrerequisiteKind::DeniedCapability(_) => ( + if history == "excess-capability" { + 200 + } else { + 403 + }, + b"{}".as_slice(), + ), + _ => panic!("recovery has only credential prerequisites"), + }; + granted + .record_response(status, true, body, NOW + 2) + .await + .expect("recorded response"); + evidence.push( + attempts + .read_prerequisite(&approved, kind, NOW + 3) + .await + .expect("retained evidence"), + ); + } + let AcquisitionClaim::Existing(snapshot) = attempts + .claim_prerequisite(&approved, kind, NOW + 3, Oracle { now: NOW + 3 }) + .await + .expect("child replay") + else { + panic!("no second child entry"); + }; + assert_eq!(snapshot.reserved_calls, 1); + assert_eq!(snapshot.reserved_bytes, capacity.maximum_bytes); + assert_eq!( + snapshot.policy_count_counters, 0, + "parent policies are not recharged" + ); + children.push(snapshot); + } + let final_at = if history == "stale" { + NOW + 32 + } else { + NOW + 3 + }; + let eligible = crate::entry::validate_prerequisite_evidence( + &approved, + &read_installation, + None, + &crate::GatewayPreEntry::default(), + &evidence, + final_at, + ) + .is_ok(); + assert_eq!( + eligible, + history == "recorded", + "native credential predicates and freshness: {history}" + ); + // Oracle entry proves the journal dependency boundary, independently of + // the actual-purpose predicate exercised above. Do not claim it rejects + // wrong account/capability bodies without installed validation. + let grant = parent + .grant_entry(approved.clone(), Oracle { now: final_at }, final_at) + .await; + let membership_eligible = !matches!(history, "missing" | "lost-permit" | "stale"); + assert_eq!( + grant.is_ok(), + membership_eligible, + "journal dependency boundary" + ); + if let Ok((_, permit)) = grant { + drop(permit); + } + let reopened = GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen")), + policy.clone(), + ) + .expect("attempts"); + let snapshot = reopened + .read_recovery(&approved) + .await + .expect("history") + .expect("parent"); + assert_eq!( + snapshot.stage, + if membership_eligible { + AcquisitionStage::Unknown + } else { + AcquisitionStage::Reserved + } + ); + assert_eq!(snapshot.reserved_calls, 1); + cases.push( + json!({"history": history, "native_evidence_eligible": eligible, + "oracle_journal_grant": membership_eligible, "children": children, + "reopened_parent": snapshot, "prerequisite_acquisitions": declarations, + "unadmitted_parent_refused": true, "substituted_membership_witness_refused": true}), + ); + } + let bytes = serde_json::to_vec_pretty(&json!({"schema": "auths.recovery-prerequisite-fixture/1", "scope": "native signed recovery compilation and actual credential predicates; file dependency/restart histories use oracle entry; no installed provider/PostgreSQL claim", "cases": cases})).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/recovery-prerequisites.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 12534ed53..95f6c569b 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1308,9 +1308,8 @@ impl GatewayEngine { /// # Errors /// Refuses native/approval/configuration failures before admission. Missing /// or unavailable state after uncertain persistence is indeterminate. - /// Recipes requiring additional credential reads currently fail closed; - /// those reads require their own acquisition admission before this path can - /// support them. + /// Account and denied-capability prerequisites use separately charged, + /// approved child acquisitions before final recovery entry. pub async fn acquire_recovery( &self, source_operation: &str, @@ -1340,19 +1339,6 @@ impl GatewayEngine { now: u64, started: Instant, ) -> Result { - let reads = self - .recipe - .credential_reads() - .map_err(|_| not_entered("gateway.acquisition.binding"))?; - if reads.probe().is_some() || reads.account().is_some() || !reads.denied().is_empty() { - return match self.attempts.read_recovery(&approved).await { - Ok(Some(snapshot)) => Ok(snapshot), - Ok(None) => Err(not_entered("gateway.acquisition.ancillary-required")), - Err(_) => Err(GatewaySubmitResult::Indeterminate { - code: "gateway.attempt.state-unavailable".to_owned(), - }), - }; - } // Retained terminal history never needs preparation or custody. if let Some(snapshot) = self .attempts @@ -1512,6 +1498,21 @@ impl GatewayEngine { { return Err("gateway.credential.mode-guard"); } + for plan in approved + .prerequisite_plans() + .map_err(|_| "gateway.acquisition.binding")? + { + let kind = plan.kind().map_err(|_| "gateway.acquisition.binding")?; + let evidence = + submit::acquire_prerequisite(&self.attempts, &approved, kind, io, &lease) + .await + .ok_or("gateway.entry.prerequisite-evidence")?; + crate::entry::validate_credential_evidence( + &self.recipe, + *approved.connection().account_commitment(), + &evidence, + )?; + } let validation = io.entry_validation()?; let now = io.clock().ok_or("gateway.verify.clock-unavailable")?; let (granted, permit) = reserved diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index 014b4aee0..7296e8e5c 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -191,10 +191,10 @@ pub(crate) fn validate_prerequisite_evidence( now: u64, ) -> Result<(), &'static str> { use crate::effect::PrerequisiteKind; - use auths_gateway_kernel::order::{AccountResult, DeniedResult, PreEntryResult}; + use auths_gateway_kernel::order::PreEntryResult; use sha2::{Digest as _, Sha256}; let invalid = "gateway.entry.prerequisite-evidence"; - let command = approved.command().ok_or(invalid)?; + let command = approved.command(); let plans = approved.prerequisite_plans().map_err(|_| invalid)?; if acquired.len() != plans.len() { return Err(invalid); @@ -212,31 +212,15 @@ pub(crate) fn validate_prerequisite_evidence( return Err(invalid); } match evidence.kind { - PrerequisiteKind::Account => { - let guard = installed.recipe.guard_checks().ok_or(invalid)?; - let pointer = guard.account_pointer.as_deref().ok_or(invalid)?; - if crate::submit::account_result( - Some(&evidence.response), - pointer, - Some(*installed.connection.account_commitment()), - ) != AccountResult::Equal - { - return Err(invalid); - } - } - PrerequisiteKind::DeniedCapability(index) => { - let guard = installed.recipe.guard_checks().ok_or(invalid)?; - let refused = guard - .denied_refused - .get(usize::from(index)) - .ok_or(invalid)?; - if crate::submit::denied_result(Some(&evidence.response), refused) - != DeniedResult::Refused - { - return Err(invalid); - } + PrerequisiteKind::Account | PrerequisiteKind::DeniedCapability(_) => { + validate_credential_evidence( + installed.recipe, + *installed.connection.account_commitment(), + evidence, + )?; } PrerequisiteKind::PreEntry => { + let command = command.ok_or(invalid)?; let observer = observer.ok_or(invalid)?; let read = command.request.pre_entry_read().ok_or(invalid)?; let pointers = installed.recipe.pre_entry_pointers().ok_or(invalid)?; @@ -269,6 +253,7 @@ pub(crate) fn validate_prerequisite_evidence( saw_observations = true; } PrerequisiteKind::RelativeCeiling => { + let command = command.ok_or(invalid)?; let ceiling = installed.recipe.ceiling_check().ok_or(invalid)?; let body = evidence.response.usable_body().ok_or(invalid)?; let argument = ceiling.argument_value(&command.arguments).ok_or(invalid)?; @@ -301,3 +286,32 @@ pub(crate) fn validate_prerequisite_evidence( } Ok(()) } + +/// Shared account/capability meaning for mutation and recovery prerequisites. +/// This does not grant entry; the final fence also checks freshness/membership. +pub(crate) fn validate_credential_evidence( + recipe: &CompiledRecipe, + account: [u8; 32], + evidence: &crate::store::PrerequisiteResponse, +) -> Result<(), &'static str> { + use crate::effect::PrerequisiteKind; + use auths_gateway_kernel::order::{AccountResult, DeniedResult}; + let invalid = "gateway.entry.prerequisite-evidence"; + let guard = recipe.guard_checks().ok_or(invalid)?; + let valid = match evidence.kind { + PrerequisiteKind::Account => { + let pointer = guard.account_pointer.as_deref().ok_or(invalid)?; + crate::submit::account_result(Some(&evidence.response), pointer, Some(account)) + == AccountResult::Equal + } + PrerequisiteKind::DeniedCapability(index) => { + let refused = guard + .denied_refused + .get(usize::from(index)) + .ok_or(invalid)?; + crate::submit::denied_result(Some(&evidence.response), refused) == DeniedResult::Refused + } + _ => false, + }; + if valid { Ok(()) } else { Err(invalid) } +} diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 022f19b43..0fc1e12e2 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/10"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/11"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 18546693d..65a611fbe 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -31,7 +31,6 @@ const ROWS: &[&str] = &[ "gateway.recovery.unavailable effect recovery new 74 -", "gateway.acquisition.binding effect compile new 74 -", "gateway.acquisition.exhausted effect admission new 74 -", - "gateway.acquisition.ancillary-required effect before-claim new 74 -", "gateway.acquisition.unsupported-bounds effect compile new 74 -", "gateway.effect.protocol effect before-claim new 74 -", "gateway.recipe.echo-conflict GatewayRecipeError compile existing - R:form-echo-existing-field", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 47c1546b0..e2575c409 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/10"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/11"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index ae2e2840e..4cfee5775 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/10", + "store_schema": "auths.gateway-attempt/11", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 1a4c70e72..8bbea975e 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/10"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/11"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/10", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/11", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index daaf31af4..831537431 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "4774b0983f379ac657672a4efcb9db1e47e96f3af8998507e9adef66efc436d4"; + "9d0e96e0b61a8e2b2d856072de549dcbe5005e527cd1bde403887fba95de5d7c"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 2aed6950e..8f4b2cd47 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/10`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/11`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/10"; +const SCHEMA: &str = "auths.gateway-attempt/11"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index e8445ea85..a1c8c5b46 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -466,13 +466,10 @@ impl GatewayAttempts { evaluated_at: u64, validation: crate::entry::EntryValidation, ) -> Result { - let target = approved - .recovery_target() - .ok_or(GatewayAttemptError::InvalidTransition)?; let plan = AcquisitionPlan::Recovery( - target - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?, + approved + .recovery_plan() + .map_err(|_| GatewayAttemptError::InvalidTransition)?, ); self.claim_acquisition(approved, plan, evaluated_at, validation) .await @@ -695,8 +692,8 @@ impl ReservedAcquisition { .ok_or(GatewayAttemptError::InvalidTransition)?; ( AcquisitionPlan::Recovery( - target - .journal_plan() + approved + .recovery_plan() .map_err(|_| GatewayAttemptError::Corrupt)?, ), AcquisitionRequest::Recovery(target.closed_request().clone()), @@ -733,6 +730,14 @@ impl ReservedAcquisition { keys.extend_from_slice(&dependencies); let native_end = keys.len(); keys.extend(capacity::dependencies(&attempt.record.state.counters)?); + let counter_end = keys.len(); + let prerequisites = match &plan { + AcquisitionPlan::Recovery(_) => approved + .prerequisite_plans() + .map_err(|_| GatewayAttemptError::Corrupt)?, + AcquisitionPlan::Prerequisite(_) => Vec::new(), + }; + keys.extend(prerequisite_dependencies(attempt.key, &prerequisites)?); let mut committed = None; attempt.store.fenced_replace(&keys, &mut |snapshots| { if snapshots.len() != keys.len() @@ -757,12 +762,11 @@ impl ReservedAcquisition { { return Err(GatewayAttemptError::BindingConflict); } - let source = decode( - snapshots[1] - .as_deref() - .ok_or(GatewayAttemptError::Corrupt)?, - )?; - let source_matches = eligible_source(&plan, &source, self.source_key, attempt.key)?; + let source = snapshots[1] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?; + let (source_matches, _) = + eligible_source(&plan, source, self.source_key, attempt.key)?; if !source_matches || snapshots[2].as_deref() != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) @@ -786,9 +790,26 @@ impl ReservedAcquisition { ¤t.state.counters, attempt.key, bound, - &snapshots[native_end..], + &snapshots[native_end..counter_end], + now, + )?; + let acquired = validate_prerequisites( + attempt.key, + approved.effect().binding(), + &prerequisites, + &snapshots[counter_end..], now, )?; + if matches!(plan, AcquisitionPlan::Recovery(_)) { + validation + .validate_prerequisite_evidence( + &approved, + &crate::GatewayPreEntry::default(), + &acquired, + now, + ) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + } let mut next = current.clone(); next.record_grant( &approved, @@ -939,26 +960,48 @@ pub(super) fn validate_prerequisites( fn eligible_source( plan: &AcquisitionPlan, - source: &Record, + source_bytes: &[u8], source_key: GatewayAttemptKey, key: GatewayAttemptKey, -) -> Result { - Ok(match plan { +) -> Result<(bool, u64), GatewayAttemptError> { + match plan { AcquisitionPlan::Recovery(plan) => { - source - .recovery_target()? - .journal_plan() - .map_err(|_| GatewayAttemptError::Corrupt)? - == *plan + let source = decode(source_bytes)?; + Ok(( + plan.matches_target(&source.recovery_target()?) + .map_err(|_| GatewayAttemptError::Corrupt)?, + source.evaluated_at, + )) } AcquisitionPlan::Prerequisite(plan) => { - source.state.stage == GatewayAttemptStage::Reserved - && source.entry.is_none() - && source.validate_header()? - == plan.source().map_err(|_| GatewayAttemptError::Corrupt)? - && key == prerequisite_key(source_key, plan.index()) + let expected = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let (binding, reserved, entered, evaluated_at) = if expected.is_mutation() { + let source = decode(source_bytes)?; + ( + source.validate_header()?, + source.state.stage == GatewayAttemptStage::Reserved, + source.entry.is_some(), + source.evaluated_at, + ) + } else { + let source: Record = decode_as(source_bytes)?; + ( + source.validate_header()?, + matches!(source.state.plan, AcquisitionPlan::Recovery(_)) + && matches!(source.state.phase, AcquisitionPhase::Reserved), + source.entry.is_some(), + source.evaluated_at, + ) + }; + Ok(( + reserved + && !entered + && binding == expected + && key == prerequisite_key(source_key, plan.index()), + evaluated_at, + )) } - }) + } } fn insert_acquisition( @@ -980,19 +1023,18 @@ fn insert_acquisition( if snapshots.len() != dependencies.len() || snapshots.is_empty() { return Err(GatewayAttemptError::Corrupt); } - let source = decode( - snapshots[0] - .as_deref() - .ok_or(GatewayAttemptError::Corrupt)?, - )?; - if !eligible_source(&record.state.plan, &source, source_key, key)? { + let source = snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?; + let (eligible, source_at) = eligible_source(&record.state.plan, source, source_key, key)?; + if !eligible { return Err(GatewayAttemptError::InvalidTransition); } admission.stamp(record, &snapshots[1..native_end])?; if let Some(candidate) = candidate { candidate.validate_predecessors(&snapshots[native_end..])?; } - if record.evaluated_at < source.evaluated_at { + if record.evaluated_at < source_at { return Err(GatewayAttemptError::InvalidTransition); } encode(record) diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index 82b3fd54b..a858abc5f 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -325,11 +325,9 @@ impl GatewayAttempts { )?; if source.binding_canonical != recovery_plan.source_binding || !policy.contains(&source.validate_header()?) - || source - .recovery_target_data()? - .journal_plan() + || !recovery_plan + .matches_target(&source.recovery_target_data()?) .map_err(|_| GatewayAttemptError::Corrupt)? - != *recovery_plan { return Err(GatewayAttemptError::BindingConflict); } diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index d06b58eda..8c30a84db 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -115,6 +115,58 @@ pub(crate) trait SubmitIo { ) -> Option; } +/// Acquire one compiler-selected prerequisite through the shared journal and +/// consumed permit. Both mutation and recovery use this transport sequence. +pub(crate) async fn acquire_prerequisite( + attempts: &GatewayAttempts, + approved: &std::sync::Arc, + kind: PrerequisiteKind, + io: &I, + lease: &I::Lease, +) -> Option { + let started = io.clock()?; + let validation = io.entry_validation().ok()?; + match attempts + .claim_prerequisite(approved, kind, started, validation) + .await + .ok()? + { + crate::AcquisitionClaim::Reserved(reserved) => { + let validation = io.entry_validation().ok()?; + let entry_started = io.clock()?; + let (granted, permit) = reserved + .grant_entry(std::sync::Arc::clone(approved), validation, entry_started) + .await + .ok()?; + match io.acquire(lease, permit).await { + Some(response) => { + let received_at = io.clock()?; + granted + .record_response( + response.status, + response.version_ok, + &response.body, + received_at, + ) + .await + .ok()?; + } + None => { + let _ = granted.record_unknown().await; + return None; + } + } + } + crate::AcquisitionClaim::Existing(_) => {} + } + // Only acknowledged, retained evidence is usable. Replays keep the + // original receipt time and cannot create another provider invocation. + let now = io.clock()?; + let recorded = attempts.read_prerequisite(approved, kind, now).await.ok()?; + (recorded.observed_at <= recorded.received_at && recorded.received_at <= now) + .then_some(recorded) +} + /// The installation one submission runs against. pub(crate) struct SubmitContext<'a> { pub(crate) recipe: &'a CompiledRecipe, @@ -563,56 +615,14 @@ impl Run<'_, I> { &self, kind: PrerequisiteKind, ) -> Option { - let lease = self.lease.as_ref()?; - let approved = self.verified.as_ref()?; - let started = self.io.clock()?; - let validation = self.io.entry_validation().ok()?; - match self - .cx - .attempts - .claim_prerequisite(approved, kind, started, validation) - .await - .ok()? - { - crate::AcquisitionClaim::Reserved(reserved) => { - let validation = self.io.entry_validation().ok()?; - let entry_started = self.io.clock()?; - let (granted, permit) = reserved - .grant_entry(std::sync::Arc::clone(approved), validation, entry_started) - .await - .ok()?; - match self.io.acquire(lease, permit).await { - Some(response) => { - let received_at = self.io.clock()?; - granted - .record_response( - response.status, - response.version_ok, - &response.body, - received_at, - ) - .await - .ok()?; - } - None => { - let _ = granted.record_unknown().await; - return None; - } - } - } - crate::AcquisitionClaim::Existing(_) => {} - } - // Only acknowledged, retained evidence is usable. Replays keep the - // original receipt time and cannot create another provider invocation. - let now = self.io.clock()?; - let recorded = self - .cx - .attempts - .read_prerequisite(approved, kind, now) - .await - .ok()?; - (recorded.observed_at <= recorded.received_at && recorded.received_at <= now) - .then_some(recorded) + acquire_prerequisite( + self.cx.attempts, + self.verified.as_ref()?, + kind, + self.io, + self.lease.as_ref()?, + ) + .await } async fn read_account(&self) -> AccountResult { From f0a364fdcb8ef3f497feecea7464fe3619fda26f Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 10:15:39 +0000 Subject: [PATCH 037/136] feat(gateway)!: bind candidate credential check plans --- .../gateway/application-recovery-cli.json | 2 +- .../gateway/application-recovery-frame.json | 2 +- .../gateway/candidate-compilation.json | 4540 +++++++++++++++++ .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 16 +- bindings/fixtures/gateway/effect-entry.json | 8 +- .../gateway/prerequisite-compilation.json | 12 +- .../gateway/recovery-compilation.json | 10 +- compliance.toml | 5 +- ...017-bound-effect-and-recovery-ownership.md | 25 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 7 + docs/plans/0074-implementation-status.md | 35 +- .../0009-bound-effect-and-recovery.md | 22 + ...ound-effects-and-recovery-state-machine.md | 22 +- .../corpus/target_gateway_app_frame/recover | 2 +- .../corpus/target_gateway_app_frame/submit | 2 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6549 -> 6577 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6432 -> 6460 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5711 -> 5732 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5017 -> 5031 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 34 +- .../auths-gateway/src/effect/acquisition.rs | 197 +- .../auths-gateway/src/effect/candidate.rs | 265 + .../auths-gateway/src/effect/prerequisite.rs | 44 +- .../src/effect_candidate_tests.rs | 434 ++ .../auths-gateway/src/effect_native_tests.rs | 3 + product/runtime/auths-gateway/src/entry.rs | 8 +- .../runtime/auths-gateway/src/onboarding.rs | 8 +- product/runtime/auths-gateway/src/recipe.rs | 6 +- .../auths-gateway/src/semantic_closure.rs | 2 +- .../tests/application_recovery_cli.rs | 5 + 38 files changed, 5622 insertions(+), 110 deletions(-) create mode 100644 bindings/fixtures/gateway/candidate-compilation.json create mode 100644 product/runtime/auths-gateway/src/effect/candidate.rs create mode 100644 product/runtime/auths-gateway/src/effect_candidate_tests.rs diff --git a/bindings/fixtures/gateway/application-recovery-cli.json b/bindings/fixtures/gateway/application-recovery-cli.json index cf0e185ab..248508961 100644 --- a/bindings/fixtures/gateway/application-recovery-cli.json +++ b/bindings/fixtures/gateway/application-recovery-cli.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" } }, "response": { diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json index 0eac3ddfb..521bf928b 100644 --- a/bindings/fixtures/gateway/application-recovery-frame.json +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" } }, "cases": [ diff --git a/bindings/fixtures/gateway/candidate-compilation.json b/bindings/fixtures/gateway/candidate-compilation.json new file mode 100644 index 000000000..2d4b76988 --- /dev/null +++ b/bindings/fixtures/gateway/candidate-compilation.json @@ -0,0 +1,4540 @@ +{ + "schema": "auths.candidate-compilation-fixture/1", + "scope": "native signed compilation, exact approval and existing-route refusal; no candidate transport, custody, publication, installed UI or PostgreSQL claim", + "cases": [ + { + "case": "first-install", + "review": { + "binding": { + "action": [ + 254, + 188, + 237, + 184, + 63, + 106, + 229, + 37, + 201, + 72, + 61, + 250, + 48, + 129, + 35, + 237, + 54, + 135, + 206, + 83, + 37, + 94, + 2, + 4, + 234, + 32, + 100, + 160, + 120, + 144, + 222, + 200 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 24, + 192, + 78, + 114, + 138, + 21, + 255, + 36, + 152, + 102, + 240, + 210, + 54, + 47, + 70, + 168, + 240, + 15, + 104, + 94, + 90, + 13, + 135, + 251, + 31, + 210, + 85, + 253, + 150, + 118, + 213, + 255 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "stripe-refunds", + "native_authority": [ + 208, + 38, + 165, + 192, + 10, + 42, + 38, + 233, + 209, + 20, + 238, + 107, + 255, + 90, + 14, + 183, + 169, + 73, + 131, + 188, + 221, + 241, + 38, + 133, + 233, + 99, + 194, + 253, + 224, + 246, + 24, + 8 + ], + "operation": "candidate-1", + "partition": "synthetic-candidate", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 16384, + "projection": [ + 214, + 208, + 227, + 7, + 36, + 143, + 190, + 187, + 157, + 223, + 172, + 71, + 99, + 249, + 237, + 14, + 248, + 25, + 155, + 46, + 113, + 192, + 39, + 141, + 78, + 53, + 116, + 127, + 192, + 238, + 78, + 57 + ], + "request": [ + 159, + 147, + 67, + 87, + 30, + 216, + 102, + 239, + 216, + 20, + 110, + 96, + 112, + 204, + 21, + 84, + 208, + 97, + 239, + 113, + 222, + 166, + 162, + 211, + 181, + 178, + 26, + 249, + 70, + 116, + 147, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 91, + 120, + 213, + 86, + 70, + 158, + 69, + 206, + 156, + 244, + 156, + 168, + 238, + 186, + 56, + 135, + 185, + 248, + 95, + 174, + 1, + 203, + 18, + 0, + 27, + 106, + 82, + 248, + 224, + 67, + 30, + 169 + ], + "reservations": [ + { + "amount": 1, + "ceiling": 16, + "key": [ + 13, + 153, + 126, + 38, + 186, + 172, + 2, + 4, + 168, + 81, + 26, + 183, + 190, + 101, + 43, + 123, + 14, + 96, + 69, + 1, + 199, + 90, + 50, + 54, + 95, + 91, + 16, + 80, + 73, + 32, + 29, + 103 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 16384, + "ceiling": 262144, + "key": [ + 246, + 115, + 101, + 184, + 224, + 103, + 148, + 224, + 6, + 91, + 104, + 216, + 1, + 145, + 23, + 221, + 209, + 137, + 178, + 11, + 80, + 26, + 249, + 206, + 239, + 254, + 33, + 158, + 195, + 240, + 12, + 138 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[208,38,165,192,10,42,38,233,209,20,238,107,255,90,14,183,169,73,131,188,221,241,38,133,233,99,194,253,224,246,24,8],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "aa960fe7f2c140d13c50650ee14ba7584c6ee9f701d4eaf8627b65729eb03681", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "febcedb83f6ae525c9483dfa308123ed3687ce53255e0204ea2064a07890dec8", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "candidate_connection": "18c04e728a15ff249866f0d2362f46a8f00f685e5a0d87fb1fd255fd9676d5ff", + "expected_previous": null, + "maximum_response_bytes": 16384, + "operation_id": "candidate-1", + "operator_namespace": "stripe-refunds", + "read_contract": "d6d0e307248fbebb9ddfac4763f9ed0ef8199b2e71c0278d4e35747fc0ee4e39", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9" + }, + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "method": "GET", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure.", + "contract": "auths.gateway-candidate-check/1", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ] + } + }, + "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[208,38,165,192,10,42,38,233,209,20,238,107,255,90,14,183,169,73,131,188,221,241,38,133,233,99,194,253,224,246,24,8],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "substitutions_refused": [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra" + ], + "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" + }, + { + "case": "rotation", + "review": { + "binding": { + "action": [ + 124, + 153, + 84, + 88, + 80, + 248, + 196, + 146, + 58, + 220, + 89, + 1, + 172, + 113, + 131, + 82, + 108, + 206, + 210, + 178, + 177, + 219, + 175, + 87, + 115, + 115, + 29, + 90, + 16, + 251, + 245, + 157 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 142, + 56, + 126, + 236, + 9, + 217, + 7, + 98, + 193, + 162, + 213, + 162, + 202, + 138, + 108, + 82, + 236, + 109, + 128, + 65, + 75, + 38, + 104, + 128, + 131, + 186, + 240, + 209, + 0, + 217, + 170, + 180 + ], + "credential_generation": 2, + "epoch": 1, + "namespace": "stripe-refunds", + "native_authority": [ + 20, + 112, + 47, + 231, + 171, + 55, + 86, + 99, + 134, + 148, + 142, + 70, + 205, + 192, + 14, + 222, + 179, + 148, + 167, + 180, + 95, + 4, + 144, + 198, + 9, + 165, + 232, + 10, + 59, + 26, + 192, + 22 + ], + "operation": "candidate-1", + "partition": "synthetic-candidate", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 16384, + "projection": [ + 115, + 128, + 130, + 155, + 163, + 133, + 102, + 177, + 239, + 101, + 240, + 99, + 31, + 178, + 149, + 69, + 239, + 222, + 1, + 88, + 76, + 94, + 144, + 14, + 37, + 22, + 48, + 218, + 196, + 173, + 53, + 164 + ], + "request": [ + 159, + 147, + 67, + 87, + 30, + 216, + 102, + 239, + 216, + 20, + 110, + 96, + 112, + 204, + 21, + 84, + 208, + 97, + 239, + 113, + 222, + 166, + 162, + 211, + 181, + 178, + 26, + 249, + 70, + 116, + 147, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 91, + 120, + 213, + 86, + 70, + 158, + 69, + 206, + 156, + 244, + 156, + 168, + 238, + 186, + 56, + 135, + 185, + 248, + 95, + 174, + 1, + 203, + 18, + 0, + 27, + 106, + 82, + 248, + 224, + 67, + 30, + 169 + ], + "reservations": [ + { + "amount": 1, + "ceiling": 16, + "key": [ + 51, + 79, + 158, + 237, + 106, + 159, + 68, + 168, + 239, + 94, + 173, + 143, + 40, + 103, + 59, + 192, + 154, + 61, + 167, + 187, + 167, + 87, + 200, + 166, + 67, + 172, + 80, + 127, + 127, + 248, + 175, + 232 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 16384, + "ceiling": 262144, + "key": [ + 133, + 104, + 54, + 45, + 137, + 113, + 5, + 251, + 109, + 122, + 163, + 68, + 250, + 208, + 82, + 131, + 31, + 100, + 15, + 154, + 70, + 8, + 158, + 225, + 154, + 17, + 158, + 106, + 205, + 115, + 144, + 162 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[20,112,47,231,171,55,86,99,134,148,142,70,205,192,14,222,179,148,167,180,95,4,144,198,9,165,232,10,59,26,192,22],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "ca164a1d4ab6b0985aff34953d53e462c4f571895ebcd0a5550e4e30544c94d5", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 2, + "provider": "airtable" + }, + "native": { + "action_commitment": "7c99545850f8c4923adc5901ac7183526cced2b2b1dbaf5773731d5a10fbf59d", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "candidate_connection": "8e387eec09d90762c1a2d5a2ca8a6c52ec6d80414b26688083baf0d100d9aab4", + "expected_previous": "18c04e728a15ff249866f0d2362f46a8f00f685e5a0d87fb1fd255fd9676d5ff", + "maximum_response_bytes": 16384, + "operation_id": "candidate-1", + "operator_namespace": "stripe-refunds", + "read_contract": "7380829ba38566b1ef65f0631fb29545efde01584c5e900e251630dac4ad35a4", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9" + }, + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 2, + "credential_reference_commitment": "0606060606060606060606060606060606060606060606060606060606060606", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 2, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999990 + }, + "disclosure": "none", + "expected_previous": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "method": "GET", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 2, + "credential_reference_commitment": "0606060606060606060606060606060606060606060606060606060606060606", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 2, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999990 + }, + "disclosure": "none", + "expected_previous": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure.", + "contract": "auths.gateway-candidate-check/1", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ] + } + }, + "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[20,112,47,231,171,55,86,99,134,148,142,70,205,192,14,222,179,148,167,180,95,4,144,198,9,165,232,10,59,26,192,22],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "substitutions_refused": [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra" + ], + "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" + }, + { + "case": "disabled-rotation", + "review": { + "binding": { + "action": [ + 135, + 76, + 176, + 192, + 90, + 100, + 194, + 57, + 103, + 74, + 64, + 156, + 55, + 239, + 68, + 55, + 185, + 200, + 134, + 82, + 66, + 236, + 248, + 231, + 123, + 63, + 17, + 190, + 132, + 61, + 2, + 61 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 24, + 53, + 101, + 123, + 228, + 84, + 67, + 146, + 12, + 21, + 194, + 232, + 128, + 171, + 142, + 130, + 201, + 180, + 66, + 9, + 177, + 239, + 146, + 175, + 76, + 203, + 217, + 115, + 118, + 252, + 150, + 36 + ], + "credential_generation": 3, + "epoch": 1, + "namespace": "stripe-refunds", + "native_authority": [ + 189, + 8, + 239, + 231, + 198, + 100, + 77, + 232, + 190, + 74, + 108, + 205, + 187, + 236, + 170, + 175, + 242, + 154, + 124, + 105, + 134, + 160, + 172, + 63, + 141, + 189, + 45, + 89, + 10, + 209, + 144, + 38 + ], + "operation": "candidate-1", + "partition": "synthetic-candidate", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 16384, + "projection": [ + 149, + 185, + 79, + 98, + 221, + 201, + 40, + 105, + 70, + 190, + 99, + 98, + 217, + 33, + 85, + 239, + 9, + 251, + 175, + 46, + 132, + 166, + 192, + 182, + 190, + 13, + 80, + 110, + 246, + 191, + 228, + 111 + ], + "request": [ + 159, + 147, + 67, + 87, + 30, + 216, + 102, + 239, + 216, + 20, + 110, + 96, + 112, + 204, + 21, + 84, + 208, + 97, + 239, + 113, + 222, + 166, + 162, + 211, + 181, + 178, + 26, + 249, + 70, + 116, + 147, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 91, + 120, + 213, + 86, + 70, + 158, + 69, + 206, + 156, + 244, + 156, + 168, + 238, + 186, + 56, + 135, + 185, + 248, + 95, + 174, + 1, + 203, + 18, + 0, + 27, + 106, + 82, + 248, + 224, + 67, + 30, + 169 + ], + "reservations": [ + { + "amount": 16384, + "ceiling": 262144, + "key": [ + 40, + 112, + 119, + 69, + 113, + 57, + 227, + 171, + 226, + 123, + 141, + 64, + 11, + 202, + 248, + 248, + 203, + 231, + 70, + 1, + 49, + 224, + 175, + 42, + 115, + 6, + 30, + 32, + 83, + 239, + 28, + 78 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 1, + "ceiling": 16, + "key": [ + 239, + 187, + 178, + 157, + 136, + 234, + 188, + 74, + 82, + 178, + 49, + 215, + 71, + 183, + 101, + 241, + 106, + 67, + 176, + 80, + 216, + 59, + 9, + 102, + 184, + 242, + 218, + 89, + 187, + 210, + 185, + 17 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[189,8,239,231,198,100,77,232,190,74,108,205,187,236,170,175,242,154,124,105,134,160,172,63,141,189,45,89,10,209,144,38],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "874a488e2331930983ebfdf323202e3f7ed8f5b7be0e7fc0fc7d557af4e8014b", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 3, + "provider": "airtable" + }, + "native": { + "action_commitment": "874cb0c05a64c239674a409c37ef4437b9c8865242ecf8e77b3f11be843d023d", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "candidate_connection": "1835657be45443920c15c2e880ab8e82c9b44209b1ef92af4ccbd97376fc9624", + "expected_previous": "0d429c2195fb29efbb8882b0dd52ef4f2488d44e752a1f0558f67035035c05af", + "maximum_response_bytes": 16384, + "operation_id": "candidate-1", + "operator_namespace": "stripe-refunds", + "read_contract": "95b94f62ddc9286946be6362d92155ef09fbaf2e84a6c0b6be0d506ef6bfe46f", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9" + }, + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 3, + "credential_reference_commitment": "0606060606060606060606060606060606060606060606060606060606060606", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 3, + "provider": "airtable", + "state": "disabled", + "updated_at_unix_seconds": 1789999990 + }, + "disclosure": "none", + "expected_previous": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 2, + "provider": "airtable", + "state": "disabled", + "updated_at_unix_seconds": 1789999950 + }, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "method": "GET", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 3, + "credential_reference_commitment": "0606060606060606060606060606060606060606060606060606060606060606", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 3, + "provider": "airtable", + "state": "disabled", + "updated_at_unix_seconds": 1789999990 + }, + "disclosure": "none", + "expected_previous": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 2, + "provider": "airtable", + "state": "disabled", + "updated_at_unix_seconds": 1789999950 + }, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure.", + "contract": "auths.gateway-candidate-check/1", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ] + } + }, + "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[189,8,239,231,198,100,77,232,190,74,108,205,187,236,170,175,242,154,124,105,134,160,172,63,141,189,45,89,10,209,144,38],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "substitutions_refused": [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra" + ], + "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" + }, + { + "case": "head-final", + "review": { + "binding": { + "action": [ + 95, + 139, + 64, + 176, + 169, + 84, + 133, + 27, + 235, + 166, + 176, + 40, + 158, + 1, + 196, + 30, + 111, + 181, + 251, + 21, + 96, + 158, + 57, + 39, + 84, + 36, + 159, + 19, + 182, + 62, + 191, + 222 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 68, + 137, + 40, + 169, + 48, + 182, + 26, + 229, + 22, + 22, + 199, + 171, + 27, + 249, + 153, + 70, + 13, + 173, + 61, + 214, + 174, + 178, + 37, + 64, + 96, + 111, + 28, + 41, + 222, + 77, + 137, + 226 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "stripe-refunds", + "native_authority": [ + 188, + 236, + 232, + 4, + 135, + 50, + 61, + 56, + 161, + 5, + 123, + 148, + 8, + 217, + 87, + 15, + 39, + 29, + 126, + 63, + 139, + 160, + 132, + 69, + 10, + 105, + 40, + 52, + 17, + 98, + 228, + 169 + ], + "operation": "candidate-1", + "partition": "synthetic-candidate", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 16384, + "projection": [ + 9, + 38, + 150, + 106, + 189, + 178, + 5, + 254, + 158, + 107, + 31, + 100, + 42, + 7, + 27, + 106, + 66, + 2, + 183, + 225, + 183, + 137, + 59, + 243, + 138, + 8, + 255, + 202, + 63, + 71, + 209, + 179 + ], + "request": [ + 127, + 144, + 120, + 26, + 221, + 235, + 119, + 212, + 48, + 47, + 88, + 54, + 204, + 33, + 12, + 195, + 141, + 74, + 202, + 125, + 170, + 32, + 97, + 176, + 232, + 181, + 226, + 102, + 188, + 26, + 157, + 244 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 180, + 198, + 112, + 158, + 11, + 120, + 239, + 19, + 180, + 66, + 79, + 44, + 4, + 19, + 130, + 40, + 80, + 156, + 236, + 36, + 65, + 70, + 235, + 55, + 230, + 19, + 73, + 214, + 242, + 68, + 231, + 28 + ], + "reservations": [ + { + "amount": 1, + "ceiling": 16, + "key": [ + 13, + 153, + 126, + 38, + 186, + 172, + 2, + 4, + 168, + 81, + 26, + 183, + 190, + 101, + 43, + 123, + 14, + 96, + 69, + 1, + 199, + 90, + 50, + 54, + 95, + 91, + 16, + 80, + 73, + 32, + 29, + 103 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 16384, + "ceiling": 262144, + "key": [ + 246, + 115, + 101, + 184, + 224, + 103, + 148, + 224, + 6, + 91, + 104, + 216, + 1, + 145, + 23, + 221, + 209, + 137, + 178, + 11, + 80, + 26, + 249, + 206, + 239, + 254, + 33, + 158, + 195, + 240, + 12, + 138 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[188,236,232,4,135,50,61,56,161,5,123,148,8,217,87,15,39,29,126,63,139,160,132,69,10,105,40,52,17,98,228,169],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "f5e5ca393f760e157ba3a02d4f3089cb66d08399348bf5c3a92011b4be6d9102", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "5f8b40b0a954851beba6b0289e01c41e6fb5fb15609e392754249f13b63ebfde", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "candidate_connection": "448928a930b61ae51616c7ab1bf999460dad3dd6aeb22540606f1c29de4d89e2", + "expected_previous": null, + "maximum_response_bytes": 16384, + "operation_id": "candidate-1", + "operator_namespace": "stripe-refunds", + "read_contract": "0926966abdb205fe9e6b1f642a071b6a4202b7e1b7893bf38a08ffca3f47d1b3", + "recipe_digest": "b4c6709e0b78ef13b4424f2c04138228509cec244146eb37e61349d6f244e71c" + }, + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "b4c6709e0b78ef13b4424f2c04138228509cec244146eb37e61349d6f244e71c", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "HEAD", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "method": "HEAD", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "b4c6709e0b78ef13b4424f2c04138228509cec244146eb37e61349d6f244e71c", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 1, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "HEAD", + "url": "https://api.stripe.com/v1/payouts" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ], + "schema": "auths.gateway-candidate-check/1" + }, + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure.", + "contract": "auths.gateway-candidate-check/1", + "prerequisite_acquisitions": [ + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "commitment_domain": "auths.gateway-account/1", + "expected_account_commitment": [ + 211, + 137, + 141, + 250, + 238, + 251, + 144, + 251, + 244, + 138, + 249, + 139, + 90, + 91, + 110, + 174, + 184, + 145, + 125, + 218, + 248, + 246, + 26, + 88, + 244, + 34, + 169, + 159, + 47, + 19, + 232, + 36 + ], + "json_pointer": "/id", + "kind": "account" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 65536, + "method": "GET", + "url": "https://api.stripe.com/v1/account" + } + }, + { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "index": 0, + "kind": "denied-capability", + "refused_statuses": [ + 403 + ] + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/customers" + } + } + ] + } + }, + "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[188,236,232,4,135,50,61,56,161,5,123,148,8,217,87,15,39,29,126,63,139,160,132,69,10,105,40,52,17,98,228,169],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "substitutions_refused": [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra" + ], + "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" + }, + { + "case": "probe-only", + "review": { + "binding": { + "action": [ + 203, + 199, + 42, + 92, + 163, + 123, + 16, + 133, + 254, + 127, + 137, + 126, + 113, + 127, + 241, + 137, + 107, + 16, + 155, + 114, + 109, + 245, + 219, + 48, + 221, + 200, + 255, + 195, + 71, + 160, + 42, + 193 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 248, + 80, + 32, + 215, + 188, + 17, + 142, + 105, + 204, + 80, + 225, + 73, + 139, + 177, + 127, + 16, + 242, + 65, + 181, + 27, + 87, + 123, + 125, + 2, + 229, + 210, + 91, + 132, + 193, + 137, + 116, + 30 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "stripe-refunds", + "native_authority": [ + 125, + 70, + 6, + 21, + 215, + 50, + 106, + 141, + 238, + 94, + 232, + 162, + 163, + 182, + 216, + 178, + 100, + 246, + 17, + 46, + 94, + 55, + 66, + 217, + 120, + 231, + 163, + 191, + 225, + 139, + 107, + 134 + ], + "operation": "candidate-1", + "partition": "synthetic-candidate", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 16384, + "projection": [ + 165, + 34, + 65, + 132, + 42, + 233, + 126, + 82, + 190, + 0, + 147, + 158, + 208, + 50, + 92, + 10, + 27, + 234, + 60, + 180, + 44, + 165, + 137, + 152, + 154, + 224, + 237, + 255, + 172, + 113, + 127, + 90 + ], + "request": [ + 241, + 182, + 47, + 99, + 123, + 228, + 160, + 59, + 120, + 136, + 148, + 142, + 105, + 198, + 9, + 105, + 38, + 136, + 173, + 50, + 179, + 137, + 247, + 255, + 100, + 202, + 46, + 8, + 201, + 97, + 14, + 37 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 11, + 94, + 7, + 167, + 129, + 255, + 110, + 72, + 214, + 230, + 115, + 168, + 217, + 64, + 223, + 184, + 144, + 39, + 88, + 250, + 180, + 93, + 255, + 155, + 10, + 11, + 235, + 180, + 5, + 89, + 143, + 224 + ], + "reservations": [ + { + "amount": 1, + "ceiling": 16, + "key": [ + 13, + 153, + 126, + 38, + 186, + 172, + 2, + 4, + 168, + 81, + 26, + 183, + 190, + 101, + 43, + 123, + 14, + 96, + 69, + 1, + 199, + 90, + 50, + 54, + 95, + 91, + 16, + 80, + 73, + 32, + 29, + 103 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 16384, + "ceiling": 262144, + "key": [ + 246, + 115, + 101, + 184, + 224, + 103, + 148, + 224, + 6, + 91, + 104, + 216, + 1, + 145, + 23, + 221, + 209, + 137, + 178, + 11, + 80, + 26, + 249, + 206, + 239, + 254, + 33, + 158, + 195, + 240, + 12, + 138 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[203,199,42,92,163,123,16,133,254,127,137,126,113,127,241,137,107,16,155,114,109,245,219,48,221,200,255,195,71,160,42,193],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[248,80,32,215,188,17,142,105,204,80,225,73,139,177,127,16,242,65,181,27,87,123,125,2,229,210,91,132,193,137,116,30],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[125,70,6,21,215,50,106,141,238,94,232,162,163,182,216,178,100,246,17,46,94,55,66,217,120,231,163,191,225,139,107,134],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[165,34,65,132,42,233,126,82,190,0,147,158,208,50,92,10,27,234,60,180,44,165,137,152,154,224,237,255,172,113,127,90],\"request\":[241,182,47,99,123,228,160,59,120,136,148,142,105,198,9,105,38,136,173,50,179,137,247,255,100,202,46,8,201,97,14,37]},\"qualification_policy\":\"optional\",\"recipe\":[11,94,7,167,129,255,110,72,214,230,115,168,217,64,223,184,144,39,88,250,180,93,255,155,10,11,235,180,5,89,143,224],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "84f7dabed2310a480eb2f0503ea5b9a1f77bc941c686b26bffcdcb91b07988eb", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "cbc72a5ca37b1085fe7f897e717ff1896b109b726df5db30ddc8ffc347a02ac1", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "candidate_connection": "f85020d7bc118e69cc50e1498bb17f10f241b51b577b7d02e5d25b84c189741e", + "expected_previous": null, + "maximum_response_bytes": 16384, + "operation_id": "candidate-1", + "operator_namespace": "stripe-refunds", + "read_contract": "a52241842ae97e52be00939ed0325c0a1bea3cb42ca589989ae0edffac717f5a", + "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0" + }, + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [], + "schema": "auths.gateway-candidate-check/1" + }, + "method": "GET", + "prerequisite_acquisitions": [], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "candidate": { + "candidate": { + "account_commitment": "d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e824", + "alias": "synthetic", + "allowed_profiles": [ + { + "id": "auths.mcp", + "version": 2 + } + ], + "allowed_workloads": [ + "gateway" + ], + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "contract": "auths.gateway-operation/1", + "created_at_unix_seconds": 1789999900, + "credential_generation": 1, + "credential_reference_commitment": "0505050505050505050505050505050505050505050505050505050505050505", + "descriptor": { + "credential": { + "kind": "bearer" + }, + "operator_namespace": "stripe-refunds", + "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0", + "schema": "auths.gateway-connection-descriptor/1" + }, + "descriptor_schema": "auths.gateway-connection-descriptor/1", + "generation": 1, + "provider": "airtable", + "state": "active", + "updated_at_unix_seconds": 1789999900 + }, + "disclosure": "none", + "expected_previous": null, + "final_check": { + "disclosure": "none", + "maximum_calls": 1, + "maximum_evidence_age_seconds": 30, + "maximum_transport_seconds": 15, + "purpose": { + "equals": false, + "json_pointer": "/livemode", + "kind": "probe" + }, + "request": { + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ] + ], + "maximum_response_bytes": 16384, + "method": "GET", + "url": "https://api.stripe.com/v1/balance" + } + }, + "maximum_attempts": 16, + "ordered_prerequisites": [], + "schema": "auths.gateway-candidate-check/1" + }, + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure.", + "contract": "auths.gateway-candidate-check/1", + "prerequisite_acquisitions": [] + } + }, + "binding_canonical": "{\"action\":[203,199,42,92,163,123,16,133,254,127,137,126,113,127,241,137,107,16,155,114,109,245,219,48,221,200,255,195,71,160,42,193],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[248,80,32,215,188,17,142,105,204,80,225,73,139,177,127,16,242,65,181,27,87,123,125,2,229,210,91,132,193,137,116,30],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[125,70,6,21,215,50,106,141,238,94,232,162,163,182,216,178,100,246,17,46,94,55,66,217,120,231,163,191,225,139,107,134],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[165,34,65,132,42,233,126,82,190,0,147,158,208,50,92,10,27,234,60,180,44,165,137,152,154,224,237,255,172,113,127,90],\"request\":[241,182,47,99,123,228,160,59,120,136,148,142,105,198,9,105,38,136,173,50,179,137,247,255,100,202,46,8,201,97,14,37]},\"qualification_policy\":\"optional\",\"recipe\":[11,94,7,167,129,255,110,72,214,230,115,168,217,64,223,184,144,39,88,250,180,93,255,155,10,11,235,180,5,89,143,224],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "substitutions_refused": [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra" + ], + "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 13071090e..3ef060877 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index a83b04697..0d7712592 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"tcAoRxGSqLLmIphb0TbUT7eWQAgMYhFThIu-wpuX7A3BvuiyG5mMh-4fagX_1fVqJ7LzeLtEgeixP6DVGD_oCQ"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"lhYXACHK7PnyzLTJXNlqVR1vaFb2rHfbRgUNInIyVtaxMIV9b1AGv9vKXVuiJ70Rx3Vrrdpb-2b8rD7hXUcdDg"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index f976350e8..39c9b4f53 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -73,7 +73,7 @@ ], "kind": "exact" }, - "compiler": "auths.gateway-effect-compiler/7", + "compiler": "auths.gateway-effect-compiler/8", "configuration": [ 12, 12, @@ -259,8 +259,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -394,17 +394,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/7\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/7\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "717b1c52855e01df5ef0926f4fe91d0fef39b1b2fb5e8f7287f8963aaaf731ca", + "effect_id_hex": "b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[113,123,28,82,133,94,1,223,94,240,146,111,79,233,29,15,239,57,177,178,251,94,143,114,135,248,150,58,170,247,49,202],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"tcAoRxGSqLLmIphb0TbUT7eWQAgMYhFThIu-wpuX7A3BvuiyG5mMh-4fagX_1fVqJ7LzeLtEgeixP6DVGD_oCQ\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"lhYXACHK7PnyzLTJXNlqVR1vaFb2rHfbRgUNInIyVtaxMIV9b1AGv9vKXVuiJ70Rx3Vrrdpb-2b8rD7hXUcdDg\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index bdf0b9482..553064fba 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[115,31,68,2,118,159,149,183,126,184,84,217,231,182,167,228,210,88,129,112,134,71,81,137,123,121,229,64,24,193,171,167],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"CgCYz6otkGqrgcQDHZlcwwJokERkTy1INF2ebs1RutotCkV-YkMtyBo7cTRQgJrLCy0E_ewV2zpoThlFur-5Aw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[166,97,245,226,218,191,75,185,149,176,105,118,248,30,105,62,64,99,52,105,241,98,144,158,120,101,6,206,121,211,32,44],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"yHsmoV2MRU1udcUF0ozR8jh9RMsKFCKbHe53d93nMX02YCL57kcnm_CCBJnMaVULU7LF7jChz19kgEUuAiSqDw\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/2", "granted_at": 1790000061, - "effect_id": "731f4402769f95b77eb854d9e7b6a7e4d2588170864751897b79e54018c1aba7", + "effect_id": "a661f5e2dabf4bb995b06976f81e693e40633469f162909e786506ce79d3202c", "dependencies": [ "55aab28f95092b9b9abc5dce74fcd3a13b02a2f54250893bed28852ac45fa264", "f2e4936daf26963e87b15bc36f0cdd7d548fbe5e291e318f65867fcd9156f7b2" @@ -39,11 +39,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}", "pre_entry": null, "schema": "auths.effect-entry/2", "granted_at": 1790000000, - "effect_id": "81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58", + "effect_id": "ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index 5b585f494..d900e7541 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -4,9 +4,9 @@ "cases": [ { "recipe": "stripe", - "effect_id_hex": "7f4e57aa0df0b4209d5843016fd9ef1eda4b229487c155180308eb198c2c2e9c", - "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[127,78,87,170,13,240,180,32,157,88,67,1,111,217,239,30,218,75,34,148,135,193,85,24,3,8,235,25,140,44,46,156],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qjbSm1TpBmvrp4X2lvVIzppPuNgxwDEo9eZUzwUoZB5xWaRPvv_ycTyc0rJOG-6D5IRnDBCkx6FsGNvCK9QQAQ\"}", + "effect_id_hex": "5e675b6266454fd2e26a019279e65198a17caee853a1266ddf4accbf91f106d4", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[94,103,91,98,102,69,79,210,226,106,1,146,121,230,81,152,161,124,174,232,83,161,38,109,223,74,204,191,145,241,6,212],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"5pA-_3_xeyEUZp2xs7DSMf8e9KMgQcQoxf7x5LyrEez7T1p-RoMLy9vA-O5SbBvhquLJZlTOmkgz8WriW5U3Ag\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -152,9 +152,9 @@ }, { "recipe": "airtable-pre-entry", - "effect_id_hex": "601fe4a5697536c2c6d6acfe95f7cd6ef7ee0d8d15b8a59fea7f638e646e6067", - "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[96,31,228,165,105,117,54,194,198,214,172,254,149,247,205,110,247,238,13,141,21,184,165,159,234,127,99,142,100,110,96,103],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"CXVuiGN0K7EwCQPNqRSJgXj8_DDCPm8oIXdD_muEfnWzQ4nxBAlWEMLYBps83rR5YyrcDUMRbiji8650UEDuCg\"}", + "effect_id_hex": "49616f4f4aea8e4573c21d8a3a23b7ec57a04e2d19d4753050edf999013457c7", + "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[73,97,111,79,74,234,142,69,115,194,29,138,58,35,183,236,87,160,78,45,25,212,117,48,80,237,249,153,1,52,87,199],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"O_pxvpH8kjf3-O5oVW8wyDXwVRzCJwQbIAGE2CQKQ8Jl_Tn5CXYIvUlNXl2QUFTHAWCj2-Eb5XSCeZO2zWAHBg\"}", "prerequisite_acquisitions": [ { "disclosure": "none", diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json index f8aad6c91..d8d52c914 100644 --- a/bindings/fixtures/gateway/recovery-compilation.json +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -1,16 +1,16 @@ { "schema": "auths.gateway-recovery-compilation-fixture/1", "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", - "binding_canonical": "{\"action\":[65,122,98,210,120,224,214,152,194,82,159,209,122,100,122,250,137,38,77,176,53,42,251,132,215,189,242,44,141,29,181,25],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[147,16,216,225,54,22,226,167,204,22,59,188,88,71,56,60,239,64,124,186,160,242,62,170,188,123,33,34,46,44,83,252],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[114,122,177,80,176,10,176,61,226,141,164,247,174,69,210,31,238,68,160,93,111,230,137,91,226,139,213,126,209,143,209,194],\"request\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[116,70,239,162,42,152,250,6,239,135,195,43,59,81,238,53,103,135,95,107,157,232,161,198,84,40,16,186,121,199,145,139],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[148,149,21,136,228,137,148,170,141,129,224,36,66,173,44,244,57,255,245,165,42,49,23,42,241,180,213,151,10,155,189,47],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id": "ef01b7fd546a83beb687a30999e10db6db2d8153a1e79c377181c1725cee6855", + "binding_canonical": "{\"action\":[171,198,202,225,243,203,65,91,5,214,168,65,4,109,110,228,223,140,16,10,188,212,112,248,120,129,3,82,154,100,197,149],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[197,245,160,82,8,110,148,140,240,36,214,36,182,137,105,78,44,176,85,247,151,99,31,116,4,136,208,0,175,104,44,2],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[105,134,52,231,249,30,88,84,230,35,83,29,92,17,43,152,6,214,85,94,244,140,91,183,56,236,34,27,17,189,56,177],\"request\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[224,89,127,47,134,10,66,191,228,118,95,64,174,22,174,223,117,65,27,148,166,116,190,81,50,2,61,50,176,5,115,58],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[251,243,131,10,106,52,47,231,117,25,236,226,215,203,59,215,151,56,57,169,180,99,211,142,165,11,9,105,230,75,71,71],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "70ac806f6bb2257f44fcb1affacab6355b37db22de02d52ebc6c15f5c749497e", "authorization_call": { "arguments": { "maximum_response_bytes": 16384, "operation_id": "read-1", "operator_namespace": "observer-demo", - "read_contract": "727ab150b00ab03de28da4f7ae45d21fee44a05d6fe6895be28bd57ed18fd1c2", + "read_contract": "698634e7f91e5854e623531d5c112b9806d6555ef48c5bb738ec221b11bd38b1", "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", - "source_effect": "6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4", + "source_effect": "4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f", "source_operation": "source-1" }, "name": "auths_gateway_recovery_read_v1", @@ -18,7 +18,7 @@ "profile_version": 2, "service": "gateway-observer-test" }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"ef01b7fd546a83beb687a30999e10db6db2d8153a1e79c377181c1725cee6855\",\n \"binding_canonical\": \"{\\\"action\\\":[65,122,98,210,120,224,214,152,194,82,159,209,122,100,122,250,137,38,77,176,53,42,251,132,215,189,242,44,141,29,181,25],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/7\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[147,16,216,225,54,22,226,167,204,22,59,188,88,71,56,60,239,64,124,186,160,242,62,170,188,123,33,34,46,44,83,252],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[114,122,177,80,176,10,176,61,226,141,164,247,174,69,210,31,238,68,160,93,111,230,137,91,226,139,213,126,209,143,209,194],\\\"request\\\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[116,70,239,162,42,152,250,6,239,135,195,43,59,81,238,53,103,135,95,107,157,232,161,198,84,40,16,186,121,199,145,139],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[148,149,21,136,228,137,148,170,141,129,224,36,66,173,44,244,57,255,245,165,42,49,23,42,241,180,213,151,10,155,189,47],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 65,\n 122,\n 98,\n 210,\n 120,\n 224,\n 214,\n 152,\n 194,\n 82,\n 159,\n 209,\n 122,\n 100,\n 122,\n 250,\n 137,\n 38,\n 77,\n 176,\n 53,\n 42,\n 251,\n 132,\n 215,\n 189,\n 242,\n 44,\n 141,\n 29,\n 181,\n 25\n ],\n \"native_authority\": [\n 147,\n 16,\n 216,\n 225,\n 54,\n 22,\n 226,\n 167,\n 204,\n 22,\n 59,\n 188,\n 88,\n 71,\n 56,\n 60,\n 239,\n 64,\n 124,\n 186,\n 160,\n 242,\n 62,\n 170,\n 188,\n 123,\n 33,\n 34,\n 46,\n 44,\n 83,\n 252\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/7\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 116,\n 70,\n 239,\n 162,\n 42,\n 152,\n 250,\n 6,\n 239,\n 135,\n 195,\n 43,\n 59,\n 81,\n 238,\n 53,\n 103,\n 135,\n 95,\n 107,\n 157,\n 232,\n 161,\n 198,\n 84,\n 40,\n 16,\n 186,\n 121,\n 199,\n 145,\n 139\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 148,\n 149,\n 21,\n 136,\n 228,\n 137,\n 148,\n 170,\n 141,\n 129,\n 224,\n 36,\n 66,\n 173,\n 44,\n 244,\n 57,\n 255,\n 245,\n 165,\n 42,\n 49,\n 23,\n 42,\n 241,\n 180,\n 213,\n 151,\n 10,\n 155,\n 189,\n 47\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 66,\n 7,\n 73,\n 6,\n 121,\n 132,\n 117,\n 195,\n 238,\n 29,\n 134,\n 42,\n 43,\n 244,\n 234,\n 224,\n 113,\n 249,\n 243,\n 111,\n 126,\n 216,\n 98,\n 129,\n 25,\n 87,\n 60,\n 118,\n 61,\n 28,\n 67,\n 54\n ],\n \"projection\": [\n 114,\n 122,\n 177,\n 80,\n 176,\n 10,\n 176,\n 61,\n 226,\n 141,\n 164,\n 247,\n 174,\n 69,\n 210,\n 31,\n 238,\n 68,\n 160,\n 93,\n 111,\n 230,\n 137,\n 91,\n 226,\n 139,\n 213,\n 126,\n 209,\n 143,\n 209,\n 194\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"417a62d278e0d698c2529fd17a647afa89264db0352afb84d7bdf22c8d1db519\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"727ab150b00ab03de28da4f7ae45d21fee44a05d6fe6895be28bd57ed18fd1c2\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"prerequisite_acquisitions\": []\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"6f105eec5e2d929f16e605f128fce9ed3281f67bb014aa6d51221851f317c8d4\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"70ac806f6bb2257f44fcb1affacab6355b37db22de02d52ebc6c15f5c749497e\",\n \"binding_canonical\": \"{\\\"action\\\":[171,198,202,225,243,203,65,91,5,214,168,65,4,109,110,228,223,140,16,10,188,212,112,248,120,129,3,82,154,100,197,149],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[197,245,160,82,8,110,148,140,240,36,214,36,182,137,105,78,44,176,85,247,151,99,31,116,4,136,208,0,175,104,44,2],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[105,134,52,231,249,30,88,84,230,35,83,29,92,17,43,152,6,214,85,94,244,140,91,183,56,236,34,27,17,189,56,177],\\\"request\\\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[224,89,127,47,134,10,66,191,228,118,95,64,174,22,174,223,117,65,27,148,166,116,190,81,50,2,61,50,176,5,115,58],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[251,243,131,10,106,52,47,231,117,25,236,226,215,203,59,215,151,56,57,169,180,99,211,142,165,11,9,105,230,75,71,71],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 171,\n 198,\n 202,\n 225,\n 243,\n 203,\n 65,\n 91,\n 5,\n 214,\n 168,\n 65,\n 4,\n 109,\n 110,\n 228,\n 223,\n 140,\n 16,\n 10,\n 188,\n 212,\n 112,\n 248,\n 120,\n 129,\n 3,\n 82,\n 154,\n 100,\n 197,\n 149\n ],\n \"native_authority\": [\n 197,\n 245,\n 160,\n 82,\n 8,\n 110,\n 148,\n 140,\n 240,\n 36,\n 214,\n 36,\n 182,\n 137,\n 105,\n 78,\n 44,\n 176,\n 85,\n 247,\n 151,\n 99,\n 31,\n 116,\n 4,\n 136,\n 208,\n 0,\n 175,\n 104,\n 44,\n 2\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 224,\n 89,\n 127,\n 47,\n 134,\n 10,\n 66,\n 191,\n 228,\n 118,\n 95,\n 64,\n 174,\n 22,\n 174,\n 223,\n 117,\n 65,\n 27,\n 148,\n 166,\n 116,\n 190,\n 81,\n 50,\n 2,\n 61,\n 50,\n 176,\n 5,\n 115,\n 58\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 251,\n 243,\n 131,\n 10,\n 106,\n 52,\n 47,\n 231,\n 117,\n 25,\n 236,\n 226,\n 215,\n 203,\n 59,\n 215,\n 151,\n 56,\n 57,\n 169,\n 180,\n 99,\n 211,\n 142,\n 165,\n 11,\n 9,\n 105,\n 230,\n 75,\n 71,\n 71\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 66,\n 7,\n 73,\n 6,\n 121,\n 132,\n 117,\n 195,\n 238,\n 29,\n 134,\n 42,\n 43,\n 244,\n 234,\n 224,\n 113,\n 249,\n 243,\n 111,\n 126,\n 216,\n 98,\n 129,\n 25,\n 87,\n 60,\n 118,\n 61,\n 28,\n 67,\n 54\n ],\n \"projection\": [\n 105,\n 134,\n 52,\n 231,\n 249,\n 30,\n 88,\n 84,\n 230,\n 35,\n 83,\n 29,\n 92,\n 17,\n 43,\n 152,\n 6,\n 214,\n 85,\n 94,\n 244,\n 140,\n 91,\n 183,\n 56,\n 236,\n 34,\n 27,\n 17,\n 189,\n 56,\n 177\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"abc6cae1f3cb415b05d6a841046d6ee4df8c100abcd470f8788103529a64c595\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"698634e7f91e5854e623531d5c112b9806d6555ef48c5bb738ec221b11bd38b1\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"prerequisite_acquisitions\": [],\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "refused_changed_fields": [ "source_effect", "source_operation", diff --git a/compliance.toml b/compliance.toml index 5205fb0d5..f93a0342d 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/11", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/11", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-compilation = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", +] recovery-refinement = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 05907a0b5..258c7a3a8 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -630,3 +630,28 @@ entry records including 32 managed slots and three native dependencies. The existing seven-prerequisite and 64-record bounds remain unchanged. No operator attestation is silently promoted into native effect authority: first-install and candidate-rotation authorization remain separate unfinished cutovers. + +## Candidate credential check compilation + +Candidate checks are a distinct acquisition target. They do not borrow the +current writer's proof or turn an operator attestation into native authority. +The target pins the candidate connection descriptor, expected previous record +(or absence on first install), and exact recipe-declared checks. The native +reserved tool `auths_gateway_candidate_check_v1` requires its own proof and exact +human approval. Compilation performs no custody or provider I/O. + +The ordered provider sequence remains probe, account, denied-capability reads. +The final declared read is the main acquisition; preceding reads are the same +bounded prerequisite declarations used elsewhere. This keeps every child before +parent entry without inventing an aggregate provider response. Each purpose +retains its concrete predicate, and a complete main response will still need +its purpose evaluated before credential publication. Recipes with no network +checks remain an offline operator path; compilation cannot invent a read. + +Lifetime capacity is keyed by candidate credential identity (connection ID, +credential generation and reference commitment), not operation ID or timestamps. +The maximum is sixteen explicitly approved attempts, each with one main-response +ceiling and declared one-call child allowances. Current native count/byte policies +also apply. This checkpoint adds compilation and review only. Candidate staging, +fresh absent/current-record fencing, shared journal admission, actual checks and +publication are required before production onboarding can use this target. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 929d176ab..7b57f2a5e 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -104,6 +104,13 @@ content, locators, echo and private commitments. Installed transport/fault coverage, the authenticated approval frontend, ancillary acquisition cutovers and full acceptance evidence remain open AP074 requirements. +Compiler `/8` additionally exposes a native candidate-check compilation API for +an exact staged first-install or rotation descriptor. Its private review binds +the predecessor (or absence), probe/account/capability order and read limits. +This API does not publish credentials or grant provider entry. The onboarding +and rotation CLI execution cutover is still pending; do not treat compilation +or an operator attestation as proof that candidate reads passed. + A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints the statement for the installation and the preimage the operator's own diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index fe45c055d..b999c2fc0 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -781,6 +781,39 @@ closure regeneration passed after that correction (one artifact-generation test) decision removal, authenticated UI/bindings and full installed/process/adapter/ formal/performance/CI acceptance. No A01–A22 criterion is fully closed. +## Candidate credential compilation checkpoint + +- Compiler `/8` adds the reserved native candidate-check tool and sealed target. + The full proposed connection and exact predecessor/absence are pinned; a + rotation preserves descriptor, account, authorizations and administrative + state. Native verification, selected authority, managed read bounds, binding + construction and exact approval share the existing recovery compilation path. +- Candidate plans retain recipe order (probe/account/denied), with the final + declared read as the primary acquisition and prior reads as declared children. + No-read recipes cannot invent a network operation. Private review includes + the actual GET/HEAD and full descriptor/previous state. Source-lifetime keys + use connection ID, credential generation and reference commitment; changing + the operation or timestamp cannot reset the 16-attempt allowance. +- The native candidate corpus covers first install, active and disabled + rotations, HEAD final reads and probe-only checks; it rejects substituted + candidate/predecessor/recipe/contract/limits/extra arguments, changed connection, + expired or reused approval, revoked predecessors and changed rotation accounts. + Existing mutation/recovery admission and orphan-child routes refuse candidates. + Probe predicates accept the exact value and reject wrong/duplicate JSON values. +- This is compilation and explicit refusal evidence, not candidate execution. + Staged custody, current-or-absence fencing, candidate admission, ordered reads, + safe publication and onboarding/rotation CLI cutover remain required. The + runtime still uses the previous onboarding checks until that direct cutover. + Journal `/11` is unchanged; no candidate journal decoder is introduced here. +- Required native artifact construction passed for candidate compilation and + the changed compiler identity's binding, approval, recovery, prerequisites, + admission/entry, replay, attempt and code fixtures. Application framing passed. + The CLI generator exposed macOS inheritance of the listener's nonblocking flag; + the accepted test stream now explicitly uses blocking I/O with its existing + five-second deadline. CLI regeneration and final source closure then passed + on `15b3cad1` plus this source. No broad local gate or hosted CI was run; no + A01–A22 acceptance criterion closes. + ## Phase gates | Phase | State | Outstanding gate | @@ -788,7 +821,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation reads, general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation execution (candidate compilation authored), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 1b54840be..009a182d0 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -384,3 +384,25 @@ The six-case recovery prerequisite corpus records the native predicate result separately from oracle journal grants, so synthetic wrong-account/capability histories cannot masquerade as installed entry-denial evidence. Installed transport, PostgreSQL and final formal/performance gates remain open. + + +## Candidate credential compilation checkpoint + +Candidate first-install and rotation checks now reuse recovery's native MCP +verification, branch/observer separation, managed read-bound admission and +bound-effect construction. The target comparison stays distinct: recovery pins +a retained mutation, while candidate compilation pins a staged descriptor and +exact predecessor/absence. The existing recipe owns probe/account/capability +meaning. Ordered child plans reuse the closed prerequisite declarations; the +last actual request is the primary acquisition. No callback or aggregate +provider response is introduced. Probe parsing now uses the same bounded, +duplicate-rejecting decoder as the other native evidence predicates. + +`candidate-compilation.json` compares first install, active/disabled rotation, +HEAD-final and probe-only plans using signed native actions. It records full +review and substitution refusals, exact approval/reverification, stable lifetime +keys under operation/time changes, and refusal through the existing mutation, +recovery and orphan-child routes. It is compiler/predicate and route-refusal +evidence only. The candidate journal admission, staged custody, ordered current +or absence validation, transport and publication cutover remain required; this +checkpoint does not promote an operator attestation into native read authority. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 0d578f9eb..61f26812a 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -152,7 +152,7 @@ Introduce one versioned canonical `EffectBinding` with an immutable `EffectId`. Use tagged, versioned alternatives for protocol-specific facts. Do not represent validity with a large set of optional fields whose illegal combinations are interpreted differently by callers. The concrete native encoding is `auths.bound-effect/3`, with effect compiler -`auths.gateway-effect-compiler/7`. Reservations use a closed window alternative: +`auths.gateway-effect-compiler/8`. Reservations use a closed window alternative: fixed epoch-aligned windows or the retained source effect's lifetime. Mutation count/sum reservations retain fixed windows; recovery acquisitions declare separate acquisition-count and response-byte charges against one source. A @@ -232,7 +232,7 @@ the approved recipe. Account for their entry and limits explicitly; they must no be invisible I/O outside the model. Acquiring those bytes does not authorize disclosing them to the agent. -Mutation compiler `/7` retains an ordered prerequisite acquisition plan beside +Mutation compiler `/8` retains an ordered prerequisite acquisition plan beside its verified command and commits the complete plan in the transport identity. The plan names at most seven requests: one account check, up to four denied capability checks, one pre-entry read and one relative-ceiling read. Each pins @@ -245,6 +245,24 @@ these declarations. The declaration alone is neither a capacity reservation nor an entry permit; runtime must durably account and grant every constituent read through the shared journal before contacting the provider. +Candidate onboarding/rotation compilation uses the reserved native tool +`auths_gateway_candidate_check_v1` and private contract +`auths.gateway-candidate-check/1`. It pins the complete proposed connection and +exact predecessor or first-install absence. Rotation preserves descriptor, +account, authorization and administrative state; changing those is not a +credential-only rotation. Native read authority and exact approval are required +separately from the operator installation attestation. Checks run in recipe order: +probe, account, then denied capabilities. The final declared read is the main +acquisition and earlier reads are its prerequisites; no synthetic aggregate +provider response is invented. A recipe without checks has no candidate network +operation. Each credential identity (connection ID, credential generation and +reference commitment) has a 16-attempt lifetime ceiling independent of operation +IDs and timestamps, with the full primary response ceiling and explicit child +allowances. Selected native managed limits also apply. This compilation alone +cannot establish predecessor freshness, enter transport or publish a credential; +the runtime must fence predecessor/absence and retain the checks through safe +publication in the same authoritative journal contract. + The concrete journal encoding is `auths.gateway-attempt/11`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover index 943402246..852aeddc5 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover @@ -1 +1 @@ -{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ"}} \ No newline at end of file +{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit index 1a61d5c94..f389c2de8 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit @@ -1 +1 @@ -{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxMTMsMTIzLDI4LDgyLDEzMyw5NCwxLDIyMyw5NCwyNDAsMTQ2LDExMSw3OSwyMzMsMjksMTUsMjM5LDU3LDE3NywxNzgsMjUxLDk0LDE0MywxMTQsMTM1LDI0OCwxNTAsNTgsMTcwLDI0Nyw0OSwyMDJdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoidGNBb1J4R1NxTExtSXBoYjBUYlVUN2VXUUFnTVloRlRoSXUtd3B1WDdBM0J2dWl5RzVtTWgtNGZhZ1hfMWZWcUo3THplTHRFZ2VpeFA2RFZHRF9vQ1EifQ"} \ No newline at end of file +{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 9205cc337..c739a7090 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index ecbfe04c8..943a3a869 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index edcfce7ee..a9fccca4a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 1d8ea3d6e..e2de1f19a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index b6d429476..ecc7f4ff0 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/7\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[129,113,29,68,45,254,74,24,225,189,238,250,216,49,169,10,94,19,178,90,111,185,202,236,12,233,37,243,122,199,91,88],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"a6Lemch3YLeNCcE3kfRfrapn1yE-_LwN_Qo_bLVlJ5OkQvs9KTShzHjp6WqtbMktn70AE5q9JywxRK8UN0FdDw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"81711d442dfe4a18e1bdeefad831a90a5e13b25a6fb9caec0ce925f37ac75b58","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index fc54302579e51f414e30b8ce4fde5be919bd54db..45eeadcdf0f2d36d944bd89a90b9fb87ffd1af59 100644 GIT binary patch delta 1055 zcmeH_ze)o^5XSSb60uM)eIVTkH?w!QyOpTXoT0F)-gVnBAH84GbB#()tBqY{`HGL0Brz@VU) z)7A5K)UM5DeS0jYcip4_obGuwucMF*?iCHv8d5nOxmH-w0oWT$s|}-?EY0* zHmd5lRF1k2qe|!TV00Ta$KLswHN5en!??av$o$#wR`0umeeElU3&|W(LU11ugTP0Q yk{o&I`{;%$iISgHLv&)y3zN9<2qMv2xCwIw z$z{BR?H$}GLKXGks~-yfC3|C~TyFDaS$fXrW%io?EIuLCfXKiVPXQM|1qaE2x}XA3 zX`oEGEdh!ia7TMC31|-J8mT}Nr+^N1$AmiE1N<%wm~=YKP1La(G=fss(5cwj;AUjU zftf6N8)@6~?OoJmSH5lRM^%<4tz={deVkW!0)N^Fn)gBIU-W9?G;KbNb-jJoeLTJ$ zc$dRTc#=-~lI&H*P}kTnURTV>Bn@?x0x;k!<-DD?!U#=|u+3yzX<<6!;iI{Lslhks9%3_pQ zo0>#1G@2M;kwsJ(KaF&3Y)oRSsYsbLu@sTWKgzx0zYTt~$$!EIi;wbN{<8MqeE}5; BA!7gl diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 7ca3921dee33c43a82ec67ee22357a97ee8fae43..1700a451f24c1b09e50bd95acce415028f31b162 100644 GIT binary patch delta 765 zcmd^+ze)o^5XL=>f>?<@f%OPGvwOF@Hljw85J@75`6H2V=k6)NnB*ie+V}_xd6JOY z!Y8n_va=9;09*IKr_f@U`99|N!7#7z0hxt`m6uuO(eu>2wEDI9KwJPJ2P6h4Bq(w+ z0OUSkfPfNExk|@$O9Y@a5TjoUfhdI?K?+d25XON->N$iY5a+-NlyeDO47o;}&Y-<% zCxhwtQc^n_4qKw92RDuV(xr)xN4MFkE!H|?Bl&2HHF;95j{CLPuZU)Sbl8t3dC|Ja z>2lE=WOGU5uA8sl?{=@FO0RHw!a7%lWN-ew{FM0zM{ax5+1lryedF|Py}e^Y<4dKv sPev&jB4QMUC{dHI&%+Rd*u>H*7TG|?TxuCxP0Z&QaAT~UCmZkH4-eAL?EnA( delta 766 zcmd^+OG*Pl5QZ}*AmT=dC&;=2UHzEub|az@NybQG5)mRp&rA=|(U=z|apOu{y2wdn zc3#30xO1mx5Zh}gRPk38U;R+j2fRV4P}q2VDLs3h%)6VP#RsGs5E(e}6>tGmaF86R z3n~DW2FjG15}@b}5tO=se#I_E zmlHb;&1_XIXB|JVH}Qa-2e!E%*I1Ue(}@`kaapT|!Mqu^Zo??(UDw4)*1DVOM(1>J ze{?nS&&IRpIGYV6*{g}Mt}o|{c0+ZWIz~ny%|IPS7CMHOKtl|Sb&O0vVn8iM<~l~k z#yZAEIu<}tBORbIMnKBQ*eF&fMk%$TVDfj?q7a|L!bp=`%Yx!?XTOY;q`=a0m*7~+^?DI4UH^y3=NHSfRveqj)|#`k*SG}xrvSu5E+^3 z7+P5B7#UjtMGbU}49#>*fU3=a*g(h9M8^=wFt^aLGys}l2viExY+wXbZl+@hqKtKn z&4K0^19?V3wU#=ThB_7&u{tqIsTBp8MXAN{i6xVd@n?sa`K0D1XBbENr2080yBcSw z1*H`w7UUULy6VRJl>5a8=Eo=bgyndd`ez506BQcI5B}a diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 5f29a96f6..64bb910b7 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"db2961901bf4b3f415ccc3ff24286aa55e22cd77cfe1a804daa830d2ab3abb4b"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"83baeba3afe26411ee6fd78c5ac1333283c8a2faaad36f72529ec3599309309f"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"e6706daf9d6a399260ec910090942fe7137483f203c7761d7f70eb67c840e7e8"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"f87cda8b02bc28f0d699e3f68b4ac911985b569ab89a3131723829ccd3d733a3"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"814a4865cc24213a92ff6799a86a008ba18babd905ba0dcc0e6737a819dc1d02"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"91222f74f87fec987ca7b8a9d37d5b6e8523ea5d29073f8ad34ab961cf40b194"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"a408bb8e94cf35ae23f91c92143e577dd6d078548f59cfb98a0acdabc13054da"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"522e6c3951e7c9eb245c00154a0f6a5420bc349a57ea8d9738d6e2b6903fa199"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"0dde0912a42d2f8408f2b1997e693a655fc3a6e0ffcc8a741e329b886cb71d0d"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"0dfd7d67e7f02f18a28d1c86ca1b7751d7463f5efcdbe3825de0ad8cbccb3891"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2141c5fe226b94a16fbe02e2ec86ead155a4162c9181bce85c50b528e2ea49bb"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"366be49b2fbd174c490a094d8bfa2575aabf423d4f4ef648f190e7b84b3238d9"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"41147db2e2733d28b0c64e01f52586f4fb55bb6cd986bab24c562baa806593a0"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"50b70d257bdcdddec3baa5919d28eece9aa5fc8bee927735fcad09f04f6e8eb2"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"1b060e74685a3b1bf9f46337968a832c3fd69618e8fe7694ffd42c1a8126c57b"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"40908f5018b42e6629b074ebea294e73d2b843d7e6bc3b0c30188889d29b82e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"2b75197b410bf823a4ebfda91ee5eb6c78905a4940ce0736f488a5d0a4926951"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"30f4ba5d71e424074622b6e8197307914e4271aa7f995276bb910d633b0c8504"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b285d20c76b85e9a45b3465726dc6abe339af9fd96d84d525db7d5d6a7eaf9c4"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"c7a87d6a8270924226482fa82bd546a9c2f3743ad0503fa02e3c60035d69c9ba"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"22a52afda56485705584c8837044350baa0c79ccee763b463753aeefda401cd8"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"dfdc1cda5475713553f4ad55e992affa459995c9b487534c899aa4a8e339d3ca"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"d3c6509483797bc050410dc0e5504624637e407c89b266f3583b5d8315c7f09d"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"988ef615d3084063bfb3a5e0e963a06ad9a499916cdff282ac7d0ac4a2e7fb3f"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"814a4865cc24213a92ff6799a86a008ba18babd905ba0dcc0e6737a819dc1d02"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"91222f74f87fec987ca7b8a9d37d5b6e8523ea5d29073f8ad34ab961cf40b194"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"a408bb8e94cf35ae23f91c92143e577dd6d078548f59cfb98a0acdabc13054da"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"522e6c3951e7c9eb245c00154a0f6a5420bc349a57ea8d9738d6e2b6903fa199"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"3cf039533a23d91b96ff5294abf454ede8eff9b05a985c11199851dae12977e3"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"2141c5fe226b94a16fbe02e2ec86ead155a4162c9181bce85c50b528e2ea49bb"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"366be49b2fbd174c490a094d8bfa2575aabf423d4f4ef648f190e7b84b3238d9"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"41147db2e2733d28b0c64e01f52586f4fb55bb6cd986bab24c562baa806593a0"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"1b060e74685a3b1bf9f46337968a832c3fd69618e8fe7694ffd42c1a8126c57b"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"40908f5018b42e6629b074ebea294e73d2b843d7e6bc3b0c30188889d29b82e6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"2b75197b410bf823a4ebfda91ee5eb6c78905a4940ce0736f488a5d0a4926951"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"30f4ba5d71e424074622b6e8197307914e4271aa7f995276bb910d633b0c8504"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 0e9aa1048..985a3f396 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -19,6 +19,10 @@ use std::fmt; use zeroize::Zeroizing; mod acquisition; +mod candidate; +pub use candidate::{ + CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, +}; mod prerequisite; pub(crate) use acquisition::{ AcquisitionCapacity, AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, @@ -37,7 +41,7 @@ pub const EFFECT_BINDING_SCHEMA: &str = "auths.bound-effect/3"; pub const MAX_EFFECT_BYTES: usize = 65_536; /// Maximum reservations in one effect, preserving the gateway counter bound. pub const MAX_EFFECT_RESERVATIONS: usize = 34; -const COMPILER: &str = "auths.gateway-effect-compiler/7"; +const COMPILER: &str = "auths.gateway-effect-compiler/8"; const MAX_SAFE_INTEGER: u64 = (1 << 53) - 1; const APPROVAL_SCHEMA: &str = "auths.exact-effect-approval/1"; /// Maximum encoded exact human approval, checked before decoding. @@ -1088,7 +1092,10 @@ impl ApprovedEffect { pub(crate) fn recovery_target(&self) -> Option<&RecoveryReadTarget> { match &self.effect.command { CompiledEffect::Mutation(_) => None, - CompiledEffect::Acquisition(command) => Some(&command.target), + CompiledEffect::Acquisition(command) => match &command.target { + acquisition::AcquisitionTarget::Recovery(target) => Some(target), + acquisition::AcquisitionTarget::Candidate(_) => None, + }, } } @@ -1178,13 +1185,22 @@ impl ApprovedEffect { CompiledEffect::Mutation(_) => { compile_mutation_effect(installed, now, &self.effect.proof, &self.effect.action)? } - CompiledEffect::Acquisition(command) => compile_recovery_acquisition( - installed, - &command.target, - now, - &self.effect.proof, - &self.effect.action, - )?, + CompiledEffect::Acquisition(command) => match &command.target { + acquisition::AcquisitionTarget::Recovery(target) => compile_recovery_acquisition( + installed, + target, + now, + &self.effect.proof, + &self.effect.action, + )?, + acquisition::AcquisitionTarget::Candidate(target) => compile_candidate_credential( + installed, + target, + now, + &self.effect.proof, + &self.effect.action, + )?, + }, }; if fresh.binding != self.effect.binding { return Err(not_entered("gateway.effect.binding-changed")); diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 755f946ca..8709aef78 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -147,32 +147,18 @@ impl RecoveryReadTarget { Unit::ResponseBytes, )); reservations.sort_by_key(|entry| (entry.key, entry.unit)); - EffectBinding::new(BindingWire { - schema: EFFECT_BINDING_SCHEMA.to_owned(), - namespace: installed.recipe.namespace().as_str().to_owned(), - partition: installed.partition.to_owned(), - epoch: installed.epoch, - operation: operation.as_str().to_owned(), - action: action_commitment, + build_binding( + installed, + operation, + action_commitment, native_authority, - scope: Scope::Unscoped, - recipe: *installed.recipe.digest(), - compiler: COMPILER.to_owned(), - connection: connection_commitment, - credential_generation: installed.connection.credential_generation().get(), - qualification_policy: installed.qualification.as_str().to_owned(), - configuration: installed.configuration, - approval_policy: ApprovalPolicy::Exact { - approver: installed.approver, - }, - reservations, - protocol: Protocol::Acquisition { + Protocol::Acquisition { request: plan.request, projection: plan.contract, maximum_response_bytes: plan.maximum_response_bytes, }, - }) - .map_err(|_| invalid()) + reservations, + ) } /// Exact private MCP call for separate read authority. It binds the source, @@ -213,6 +199,46 @@ impl RecoveryReadTarget { } } +pub(super) fn build_binding( + installed: &EffectInstallation<'_>, + operation: &LogicalOperationId, + action_commitment: [u8; 32], + native_authority: [u8; 32], + protocol: Protocol, + reservations: Vec, +) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + let connection = Zeroizing::new( + installed + .connection + .to_canonical_cbor() + .map_err(|_| invalid())?, + ); + EffectBinding::new(BindingWire { + schema: EFFECT_BINDING_SCHEMA.to_owned(), + namespace: installed.recipe.namespace().as_str().to_owned(), + partition: installed.partition.to_owned(), + epoch: installed.epoch, + operation: operation.as_str().to_owned(), + action: action_commitment, + native_authority, + scope: Scope::Unscoped, + recipe: *installed.recipe.digest(), + compiler: COMPILER.to_owned(), + connection: commitment("auths.effect-installation/1", &connection) + .map_err(|_| invalid())?, + credential_generation: installed.connection.credential_generation().get(), + qualification_policy: installed.qualification.as_str().to_owned(), + configuration: installed.configuration, + approval_policy: ApprovalPolicy::Exact { + approver: installed.approver, + }, + reservations, + protocol, + }) + .map_err(|_| invalid()) +} + /// Private immutable journal projection of the native recovery compiler. It /// carries no proof or transport capability and is checked against the binding. #[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] @@ -368,7 +394,7 @@ impl RecoveryPlan { } impl AcquisitionCapacity { - fn reservations(&self) -> Vec { + pub(super) fn reservations(&self) -> Vec { let mut reservations = vec![ Reservation { key: self.count_key, @@ -390,8 +416,14 @@ impl AcquisitionCapacity { } } +#[derive(Clone)] +pub(super) enum AcquisitionTarget { + Recovery(Box), + Candidate(Box), +} + pub(super) struct VerifiedAcquisition { - pub(super) target: RecoveryReadTarget, + pub(super) target: AcquisitionTarget, pub(super) bound: Option, pub(super) prerequisites: Prerequisites, #[cfg(unix)] @@ -404,24 +436,37 @@ pub(super) struct VerifiedAcquisition { impl VerifiedAcquisition { pub(super) fn journal_plan(&self) -> Result { - self.target.journal_plan(&self.prerequisites) + match &self.target { + AcquisitionTarget::Recovery(target) => target.journal_plan(&self.prerequisites), + AcquisitionTarget::Candidate(_) => Err(EffectBindingError::Invalid), + } } pub(super) fn request_bytes(&self) -> Result>, EffectBindingError> { - self.target.request_bytes(&self.prerequisites) + match &self.target { + AcquisitionTarget::Recovery(target) => target.request_bytes(&self.prerequisites), + AcquisitionTarget::Candidate(target) => target.request_bytes(), + } } #[cfg(unix)] pub(super) fn private_review(&self) -> Value { - json!({ + let mut review = json!({ "protocol": "acquisition", "actors": self.actors.iter().map(auths_model::PrincipalId::as_str).collect::>(), "action_commitment": hex::encode(self.action_commitment), "arguments": self.arguments, - "method": "GET", - "recovery": self.target.contract(), + "method": match &self.target { + AcquisitionTarget::Recovery(_) => "GET", + AcquisitionTarget::Candidate(target) => target.method(), + }, "prerequisite_acquisitions": self.prerequisites, - }) + }); + match &self.target { + AcquisitionTarget::Recovery(target) => review["recovery"] = target.contract(), + AcquisitionTarget::Candidate(target) => review["candidate"] = target.contract(), + } + review } } @@ -440,14 +485,37 @@ pub fn compile_recovery_acquisition( now: u64, proof: &[u8], action: &[u8], +) -> Result { + compile_acquisition( + installed, + AcquisitionTarget::Recovery(Box::new(target.clone())), + now, + proof, + action, + ) +} + +pub(super) fn compile_acquisition( + installed: &EffectInstallation<'_>, + target: AcquisitionTarget, + now: u64, + proof: &[u8], + action: &[u8], ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) .map_err(|_| invalid())?; - if target.source.wire.partition != installed.partition - || target.source.wire.epoch != installed.epoch - { - return Err(invalid()); + match &target { + AcquisitionTarget::Recovery(target) => { + if target.source.wire.partition != installed.partition + || target.source.wire.epoch != installed.epoch + { + return Err(invalid()); + } + } + AcquisitionTarget::Candidate(target) => target + .validate_installation(installed) + .map_err(|_| invalid())?, } let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; let verified = sealed.action().ok_or_else(invalid)?; @@ -460,9 +528,15 @@ pub fn compile_recovery_acquisition( .and_then(Value::as_str) .and_then(|value| LogicalOperationId::parse(value).ok()) .ok_or_else(invalid)?; - let expected = target - .authorization_call(installed.recipe, &operation) - .map_err(|_| invalid())?; + let expected = match &target { + AcquisitionTarget::Recovery(target) => { + target.authorization_call(installed.recipe, &operation) + } + AcquisitionTarget::Candidate(target) => { + target.authorization_call(installed.recipe, &operation) + } + } + .map_err(|_| invalid())?; // Comparing the canonical call also rejects extra fields and channel-binding // representations this unscoped protocol does not yet support. if command.call() != &expected { @@ -481,24 +555,45 @@ pub fn compile_recovery_acquisition( auths_codec::encode_canonical_action(verified.canonical_action()).map_err(|_| invalid())?; let action_commitment = commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; - let prerequisites = - Prerequisites::credentials(installed.recipe, *installed.connection.account_commitment()) - .map_err(|_| invalid())?; - let binding = target.binding( - installed, - &operation, - action_commitment, - native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?, - bound.as_ref(), - &prerequisites, - )?; - let contract = target.contract(); + let prerequisites = match &target { + AcquisitionTarget::Recovery(_) => { + Prerequisites::credentials(installed.recipe, *installed.connection.account_commitment()) + .map_err(|_| invalid())? + } + AcquisitionTarget::Candidate(target) => target.prerequisites().clone(), + }; + let authority = + native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?; + let (binding, review) = match &target { + AcquisitionTarget::Recovery(target) => ( + target.binding( + installed, + &operation, + action_commitment, + authority, + bound.as_ref(), + &prerequisites, + )?, + json!({"contract": "auths.gateway-recovery-read/1", "recovery": target.contract(), + "consequences": "Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor."}), + ), + AcquisitionTarget::Candidate(target) => ( + target.binding( + installed, + &operation, + action_commitment, + authority, + bound.as_ref(), + )?, + json!({"contract": "auths.gateway-candidate-check/1", "candidate": target.contract(), + "consequences": "Check this exact candidate credential with the declared bounded reads. These reads do not authorize publication, mutation or disclosure."}), + ), + }; let effect = BoundEffect { - review: json!({"contract": "auths.gateway-recovery-read/1", "recovery": contract, - "consequences": "Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor."}), + review, binding, command: CompiledEffect::Acquisition(Box::new(VerifiedAcquisition { - target: target.clone(), + target, bound, prerequisites, #[cfg(unix)] diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs new file mode 100644 index 000000000..d902c5dc1 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -0,0 +1,265 @@ +//! Effect-free compilation of the exact credential candidate and ordered checks. +//! A target is proposed installation data, never proof of its current predecessor +//! or authority to lease, execute, or publish a credential. + +use super::acquisition::{AcquisitionTarget, build_binding, compile_acquisition}; +use super::prerequisite::Prerequisite; +use super::*; +use auths_connections::ConnectionState; +use auths_profile_mcp::McpToolCall; +use serde_json::{Value, json}; + +/// Reserved native operation for bounded candidate credential checks. +pub const CANDIDATE_CHECK_TOOL: &str = "auths_gateway_candidate_check_v1"; +const CONTRACT: &str = "auths.gateway-candidate-check/1"; +const MAX_CANDIDATE_ATTEMPTS: u64 = 16; + +/// Private immutable first-install or rotation proposal, derived only from a +/// validated connection descriptor and the installed recipe's closed reads. +/// There is no decoder and no transport capability. A later transaction must +/// establish the exact predecessor (or absence) before any candidate entry. +#[derive(Clone)] +pub struct CandidateCredentialTarget { + candidate: ConnectionRecord, + previous: Option, + recipe: [u8; 32], + namespace: String, + descriptor: Value, + prerequisites: Prerequisites, + last: Prerequisite, +} + +impl fmt::Debug for CandidateCredentialTarget { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("CandidateCredentialTarget { private: [redacted] }") + } +} + +impl CandidateCredentialTarget { + /// Compiles a staged candidate and its expected predecessor without I/O. + /// Rotation preserves the predecessor's descriptor, account, authorization + /// and state; only the credential reference, generations and time change. + /// First install starts active at generation one. The final declared read + /// is the main acquisition; all earlier checks are its ordered prerequisites. + /// + /// # Errors + /// Refuses a wrong descriptor, invalid rotation, revoked predecessor, + /// noninitial first-install record, or a recipe with no declared reads. + pub fn new( + recipe: &CompiledRecipe, + candidate: &ConnectionRecord, + previous: Option<&ConnectionRecord>, + ) -> Result { + GatewayConnectionDescriptor::from_record(candidate, recipe) + .map_err(|_| EffectBindingError::Invalid)?; + if let Some(previous) = previous { + let expected = previous + .rotated( + previous.descriptor().to_vec(), + *previous.account_commitment(), + *candidate.credential_reference_commitment(), + candidate.updated_at_unix_seconds(), + ) + .map_err(|_| EffectBindingError::Invalid)?; + if expected != *candidate { + return Err(EffectBindingError::Invalid); + } + } else if candidate.generation().get() != 1 + || candidate.credential_generation().get() != 1 + || candidate.state() != ConnectionState::Active + || candidate.created_at_unix_seconds() != candidate.updated_at_unix_seconds() + { + return Err(EffectBindingError::Invalid); + } + let (prerequisites, last) = + Prerequisites::candidate(recipe, *candidate.account_commitment())?; + let target = Self { + candidate: candidate.clone(), + previous: previous.cloned(), + recipe: *recipe.digest(), + namespace: recipe.namespace().as_str().to_owned(), + descriptor: serde_json::from_slice(candidate.descriptor()) + .map_err(|_| EffectBindingError::Invalid)?, + prerequisites, + last, + }; + canonical(&target.contract())?; + Ok(target) + } + + fn record_commitment(record: &ConnectionRecord) -> Result<[u8; 32], EffectBindingError> { + let bytes = Zeroizing::new( + record + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + commitment("auths.effect-installation/1", &bytes) + } + + pub(super) fn contract(&self) -> Value { + // Complete connection fields are part of private review, including predecessor + // state and authorization. Commitments alone would hide review fields. + let record = |record: &ConnectionRecord| { + json!({ + "provider": record.provider_kind().as_str(), "alias": record.alias().as_str(), + "connection_id": record.connection_id().as_str(), + "contract": record.contract().as_str(), "descriptor_schema": record.descriptor_schema().as_str(), + "descriptor": self.descriptor, + "account_commitment": hex::encode(record.account_commitment()), + "credential_reference_commitment": hex::encode(record.credential_reference_commitment()), + "generation": record.generation().get(), "credential_generation": record.credential_generation().get(), + "state": match record.state() { ConnectionState::Active => "active", ConnectionState::Disabled => "disabled", ConnectionState::Revoked => "revoked" }, + "allowed_workloads": record.allowed_workloads(), + "allowed_profiles": record.allowed_profiles().iter().map(|p| json!({"id": p.id().as_str(), "version": p.version()})).collect::>(), + "created_at_unix_seconds": record.created_at_unix_seconds(), "updated_at_unix_seconds": record.updated_at_unix_seconds(), + }) + }; + json!({ + "schema": CONTRACT, "candidate": record(&self.candidate), + "expected_previous": self.previous.as_ref().map(record), + "ordered_prerequisites": self.prerequisites, "final_check": self.last, + "maximum_attempts": MAX_CANDIDATE_ATTEMPTS, "disclosure": "none", + }) + } + + pub(super) fn prerequisites(&self) -> &Prerequisites { + &self.prerequisites + } + + pub(super) fn request_bytes(&self) -> Result>, EffectBindingError> { + canonical( + &json!({"request": self.last.request, "prerequisite_acquisitions": self.prerequisites}), + ) + } + + pub(super) fn method(&self) -> &str { + match &self.last.request { + ClosedPrerequisiteRead::Credential(read) => read.method().as_str(), + ClosedPrerequisiteRead::Action(_) => "GET", + } + } + + fn maximum_response_bytes(&self) -> u64 { + match &self.last.request { + ClosedPrerequisiteRead::Credential(read) => read.maximum_response_bytes() as u64, + ClosedPrerequisiteRead::Action(read) => read.maximum_response_bytes() as u64, + } + } + + pub(super) fn validate_installation( + &self, + installed: &EffectInstallation<'_>, + ) -> Result<(), EffectBindingError> { + if installed.connection != &self.candidate + || *installed.recipe.digest() != self.recipe + || installed.recipe.namespace().as_str() != self.namespace + { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + /// Returns the exact private MCP call requiring separate native authority. + /// This binds the candidate, predecessor/absence, ordered checks and limits. + /// + /// # Errors + /// Refuses a different recipe or invalid/oversized canonical projection. + pub fn authorization_call( + &self, + recipe: &CompiledRecipe, + operation: &LogicalOperationId, + ) -> Result { + if *recipe.digest() != self.recipe || recipe.namespace().as_str() != self.namespace { + return Err(EffectBindingError::Invalid); + } + let arguments = json!({ + "operation_id": operation.as_str(), "operator_namespace": self.namespace, + "recipe_digest": hex::encode(self.recipe), + "candidate_connection": hex::encode(Self::record_commitment(&self.candidate)?), + "expected_previous": self.previous.as_ref().map(Self::record_commitment).transpose()?.map(hex::encode), + "read_contract": hex::encode(commitment(CONTRACT, &canonical(&self.contract())?)?), + "maximum_response_bytes": self.maximum_response_bytes(), + }).as_object().cloned().ok_or(EffectBindingError::Invalid)?; + McpToolCall::new(recipe.service(), CANDIDATE_CHECK_TOOL, arguments) + .map_err(|_| EffectBindingError::Invalid) + } + + pub(super) fn binding( + &self, + installed: &EffectInstallation<'_>, + operation: &LogicalOperationId, + action: [u8; 32], + authority: [u8; 32], + bound: Option<&crate::bounds::BoundAdmission>, + ) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + let key = |unit| { + commitment( + "auths.candidate-capacity/1", + &canonical(&( + self.candidate.connection_id().as_str(), + self.candidate.credential_generation().get(), + self.candidate.credential_reference_commitment(), + unit, + ))?, + ) + }; + let capacity = AcquisitionCapacity { + count_key: key(Unit::AcquisitionCount).map_err(|_| invalid())?, + bytes_key: key(Unit::ResponseBytes).map_err(|_| invalid())?, + maximum_bytes: self.maximum_response_bytes(), + attempts: MAX_CANDIDATE_ATTEMPTS, + }; + let mut reservations = capacity.reservations(); + reservations.extend(managed_reservations( + bound, + Unit::AcquisitionCount, + Unit::ResponseBytes, + )); + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + build_binding( + installed, + operation, + action, + authority, + Protocol::Acquisition { + request: commitment( + "auths.effect-acquisition-request/2", + &self.request_bytes().map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?, + projection: commitment( + CONTRACT, + &canonical(&self.contract()).map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?, + maximum_response_bytes: self.maximum_response_bytes(), + }, + reservations, + ) + } +} + +/// Verifies native candidate-check authority and compiles the exact approved +/// read plan. Performs no custody, admission, provider I/O or publication. +/// The caller pins the staged candidate in `installed.connection`; current +/// predecessor validation remains an obligation of the entry transaction. +/// +/// # Errors +/// Refuses invalid native authority, substituted candidate/recipe/arguments, +/// unsupported bounds/scope or an invalid bound-effect/review projection. +pub fn compile_candidate_credential( + installed: &EffectInstallation<'_>, + target: &CandidateCredentialTarget, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + compile_acquisition( + installed, + AcquisitionTarget::Candidate(Box::new(target.clone())), + now, + proof, + action, + ) +} diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index d4fc52796..e1ac9a2ae 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -16,13 +16,13 @@ pub(crate) const MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS: u64 = 30; /// The complete ordered set for one mutation or independent recovery read. Construction is private to the /// native compiler; an application cannot append a request or select a purpose. -#[derive(Serialize)] +#[derive(Clone, Serialize)] pub(super) struct Prerequisites(Vec); -#[derive(Serialize)] -struct Prerequisite { - purpose: Purpose, - request: ClosedPrerequisiteRead, +#[derive(Clone, Serialize)] +pub(super) struct Prerequisite { + pub(super) purpose: Purpose, + pub(super) request: ClosedPrerequisiteRead, maximum_calls: u64, maximum_transport_seconds: u64, maximum_evidence_age_seconds: u64, @@ -37,7 +37,11 @@ enum Disclosure { #[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] #[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] -enum Purpose { +pub(super) enum Purpose { + Probe { + json_pointer: String, + equals: Value, + }, Account { json_pointer: String, expected_account_commitment: [u8; 32], @@ -174,6 +178,32 @@ impl Prerequisites { Ok(plan) } + pub(super) fn candidate( + recipe: &CompiledRecipe, + account: [u8; 32], + ) -> Result<(Self, Prerequisite), EffectBindingError> { + let mut plan = Self(Vec::new()); + let reads = recipe + .credential_reads() + .map_err(|_| EffectBindingError::Invalid)?; + let guard = recipe.guard_checks().ok_or(EffectBindingError::Invalid)?; + match (reads.probe(), guard.probe) { + (Some(read), Some((json_pointer, equals))) => plan.push( + Purpose::Probe { + json_pointer, + equals, + }, + ClosedPrerequisiteRead::Credential(read.clone()), + )?, + (None, None) => {} + _ => return Err(EffectBindingError::Invalid), + } + plan.0.extend(Self::credentials(recipe, account)?.0); + let last = plan.0.pop().ok_or(EffectBindingError::Invalid)?; + canonical(&plan)?; + Ok((plan, last)) + } + pub(super) fn compile( recipe: &CompiledRecipe, command: &VerifiedCommand, @@ -259,6 +289,7 @@ impl Prerequisites { /// Closed selectors address compiler-owned declarations, never caller URLs. #[derive(Clone, Copy, Eq, PartialEq)] pub(crate) enum PrerequisiteKind { + Probe, Account, DeniedCapability(u8), PreEntry, @@ -268,6 +299,7 @@ pub(crate) enum PrerequisiteKind { impl Purpose { const fn kind(&self) -> PrerequisiteKind { match self { + Self::Probe { .. } => PrerequisiteKind::Probe, Self::Account { .. } => PrerequisiteKind::Account, Self::DeniedCapability { index, .. } => PrerequisiteKind::DeniedCapability(*index), Self::PreEntry { .. } => PrerequisiteKind::PreEntry, diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs new file mode 100644 index 000000000..32ac19dee --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -0,0 +1,434 @@ +//! Native candidate compilation corpus; no candidate publication/entry claim. +use super::*; +use crate::effect::{ + CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, +}; + +#[tokio::test] +#[allow( + clippy::too_many_lines, + reason = "one signed candidate corpus and its substitution witnesses" +)] +async fn native_candidate_compilation_fixture_is_current() { + let corpus: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" + )) + .expect("recipes"); + let root = signer(h::ROOT_SEED); + let reader = signer(0x33); + let observer = signer(h::OBSERVER_SEED); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = EffectPolicy::new("synthetic-candidate".to_owned(), 1, public).expect("policy"); + let mut cases = Vec::new(); + for case in [ + "first-install", + "rotation", + "disabled-rotation", + "head-final", + "probe-only", + ] { + let mut source = corpus["bases"]["stripe"]["recipe"].clone(); + let lock = &corpus["bases"]["stripe"]["lock"]; + if case == "head-final" { + source["credential"]["guard"]["denied_reads"][1]["method"] = json!("HEAD"); + } + if case == "probe-only" { + source["credential"]["guard"] + .as_object_mut() + .expect("guard") + .remove("account"); + source["credential"]["guard"] + .as_object_mut() + .expect("guard") + .remove("denied_reads"); + } + let recipe = CompiledRecipe::compile( + &serde_json::to_vec(&source).expect("source"), + &serde_json::to_vec(lock).expect("lock"), + ) + .expect("recipe"); + for (body, valid) in [ + (br#"{"livemode":false}"#.as_slice(), true), + (br#"{"livemode":true,"livemode":false}"#.as_slice(), false), + (br#"{"livemode":true}"#.as_slice(), false), + ] { + let evidence = crate::store::PrerequisiteResponse { + kind: crate::effect::PrerequisiteKind::Probe, + response: crate::transport::ProviderResponse { + status: 200, + version_ok: true, + body: body.to_vec(), + }, + observed_at: NOW, + received_at: NOW, + }; + assert_eq!( + crate::entry::validate_credential_evidence(&recipe, [4; 32], &evidence).is_ok(), + valid + ); + } + let initial = connection_account( + &recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + let previous = match case { + "rotation" => Some(initial.clone()), + "disabled-rotation" => Some( + initial + .transition_state(ConnectionState::Disabled, NOW - 50) + .expect("disable"), + ), + _ => None, + }; + let candidate = previous.as_ref().map_or_else( + || initial.clone(), + |previous| { + previous + .rotated( + previous.descriptor().to_vec(), + *previous.account_commitment(), + [6; 32], + NOW - 10, + ) + .expect("rotation") + }, + ); + let target = + CandidateCredentialTarget::new(&recipe, &candidate, previous.as_ref()).expect("target"); + let call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse("candidate-1").expect("operation"), + ) + .expect("call"); + let trust = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("trust"); + let grant = h::grant_for_tool( + &root, + &reader.principal, + None, + window(NOW - 3_600, NOW + 3_600), + &call, + ) + .expect("grant"); + let submission = submission_for_call(&root, &reader, &grant, &call, &[]); + let installed = policy.installation( + &recipe, + &trust, + &candidate, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let compile = || { + compile_candidate_credential( + &installed, + &target, + NOW, + &submission.proof, + &submission.action, + ) + .expect("compile") + }; + let effect = compile(); + assert!(effect.private_request().is_none()); + let review: Value = serde_json::from_slice( + &effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("bytes"), + ) + .expect("JSON"); + assert_eq!( + review["native"]["actors"], + json!([reader.principal.as_str()]) + ); + let plan = &review["native"]["candidate"]; + assert_eq!( + plan["candidate"]["credential_generation"], + candidate.credential_generation().get() + ); + assert_eq!( + plan["candidate"]["state"], + if case == "disabled-rotation" { + "disabled" + } else { + "active" + } + ); + assert_eq!(plan["expected_previous"].is_null(), previous.is_none()); + assert!( + plan["candidate"]["descriptor"].is_object(), + "human-readable descriptor" + ); + if case == "probe-only" { + assert_eq!(plan["ordered_prerequisites"], json!([])); + assert_eq!(plan["final_check"]["purpose"]["kind"], "probe"); + } else { + assert_eq!( + plan["ordered_prerequisites"] + .as_array() + .expect("prefix") + .len(), + 3 + ); + assert_eq!(plan["ordered_prerequisites"][0]["purpose"]["kind"], "probe"); + assert_eq!( + plan["ordered_prerequisites"][1]["purpose"]["kind"], + "account" + ); + assert_eq!(plan["ordered_prerequisites"][2]["purpose"]["index"], 0); + assert_eq!(plan["final_check"]["purpose"]["index"], 1); + } + assert_eq!( + review["native"]["method"], + if case == "head-final" { "HEAD" } else { "GET" } + ); + let signing = effect + .approval_request(NOW, NOW + 30) + .expect("signing request"); + let signature = key + .sign(&signing.signing_message().expect("message")) + .to_bytes(); + let approval = signing.with_signature(signature); + let binding = effect.binding().to_private_bytes().expect("binding"); + assert_eq!( + EffectBinding::from_private_bytes(&binding).expect("decode"), + *effect.binding() + ); + let approved = std::sync::Arc::new( + effect + .approve(approval.clone(), &public, NOW) + .expect("approval"), + ); + approved + .validate_for_entry(&installed, NOW + 1) + .expect("same native recompile"); + assert!(approved.validate_for_entry(&installed, NOW + 31).is_err()); + assert!(approved.command().is_none()); + assert!(approved.recovery_target().is_none()); + assert!(approved.recovery_plan().is_err()); + let children = approved.prerequisite_plans().expect("membership"); + assert_eq!(children.len(), if case == "probe-only" { 0 } else { 3 }); + for child in &children { + child + .validate(approved.effect().binding()) + .expect("membership witness"); + } + // A native-approved candidate must not enter either existing root path. + let directory = tempfile::tempdir().expect("tempdir"); + let store = std::sync::Arc::new( + crate::FileGatewayAttemptStore::open( + &std::fs::canonicalize(directory.path()) + .expect("canonical") + .join("journal"), + ) + .expect("store"), + ); + let attempts = crate::GatewayAttempts::new(store, policy.clone()).expect("attempts"); + assert!( + attempts + .claim_bounded( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_err() + ); + assert!( + attempts + .claim_recovery( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_err() + ); + if !children.is_empty() { + assert!( + attempts + .claim_prerequisite( + &approved, + crate::effect::PrerequisiteKind::Probe, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_err() + ); + } + let mut refused = Vec::new(); + for field in [ + "candidate_connection", + "expected_previous", + "read_contract", + "recipe_digest", + "maximum_response_bytes", + "extra", + ] { + let mut args = call.arguments().clone(); + args.insert( + field.to_owned(), + if field == "maximum_response_bytes" { + json!(1) + } else { + json!("substituted") + }, + ); + let changed = McpToolCall::new(recipe.service(), CANDIDATE_CHECK_TOOL, args) + .expect("changed call"); + let signed = submission_for_call(&root, &reader, &grant, &changed, &[]); + assert!( + compile_candidate_credential( + &installed, + &target, + NOW, + &signed.proof, + &signed.action + ) + .is_err(), + "{field}" + ); + refused.push(field); + } + let next_call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse("candidate-2").expect("operation"), + ) + .expect("next call"); + let next = submission_for_call(&root, &reader, &grant, &next_call, &[]); + let next_effect = + compile_candidate_credential(&installed, &target, NOW, &next.proof, &next.action) + .expect("independent operation"); + let next_binding: Value = + serde_json::from_slice(&next_effect.binding().to_private_bytes().expect("binding")) + .expect("JSON"); + let original_binding: Value = serde_json::from_slice(&binding).expect("JSON"); + assert_eq!( + original_binding["reservations"], next_binding["reservations"], + "new operation cannot reset lifetime allowance" + ); + assert!( + next_effect.approve(approval, &public, NOW).is_err(), + "old exact approval cannot authorize next operation" + ); + let altered = candidate + .rotated( + candidate.descriptor().to_vec(), + *candidate.account_commitment(), + [7; 32], + NOW, + ) + .expect("altered connection"); + let changed_installation = policy.installation( + &recipe, + &trust, + &altered, + crate::QualificationPolicy::Optional, + [12; 32], + ); + assert!( + approved + .validate_for_entry(&changed_installation, NOW + 1) + .is_err() + ); + if let Some(previous) = &previous { + assert!(CandidateCredentialTarget::new(&recipe, &candidate, None).is_err()); + let changed_previous = previous + .transition_state(ConnectionState::Revoked, NOW - 20) + .expect("revoked"); + assert!( + CandidateCredentialTarget::new(&recipe, &candidate, Some(&changed_previous)) + .is_err() + ); + let changed_account = previous + .rotated(previous.descriptor().to_vec(), [8; 32], [6; 32], NOW - 10) + .expect("changed account"); + assert!( + CandidateCredentialTarget::new(&recipe, &changed_account, Some(previous)).is_err() + ); + // Retimestamping the same credential changes the target and approval, + // but cannot reset its stable lifetime charge keys. + let retimed = previous + .rotated( + previous.descriptor().to_vec(), + *previous.account_commitment(), + [6; 32], + NOW - 9, + ) + .expect("retimed"); + let retimed_target = CandidateCredentialTarget::new(&recipe, &retimed, Some(previous)) + .expect("retimed target"); + let retimed_call = retimed_target + .authorization_call( + &recipe, + &LogicalOperationId::parse("candidate-3").expect("op"), + ) + .expect("call"); + let retimed_submission = + submission_for_call(&root, &reader, &grant, &retimed_call, &[]); + let retimed_installation = policy.installation( + &recipe, + &trust, + &retimed, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let retimed_effect = compile_candidate_credential( + &retimed_installation, + &retimed_target, + NOW, + &retimed_submission.proof, + &retimed_submission.action, + ) + .expect("compile retimed"); + let retimed_binding: Value = serde_json::from_slice( + &retimed_effect + .binding() + .to_private_bytes() + .expect("binding"), + ) + .expect("JSON"); + assert_eq!( + original_binding["reservations"], + retimed_binding["reservations"] + ); + assert_ne!( + original_binding["connection"], + retimed_binding["connection"] + ); + } + // The reserved native name cannot compile as a mutation recipe. + source["tool"] = json!(CANDIDATE_CHECK_TOOL); + let mut reserved_lock = lock.clone(); + reserved_lock["tool"] = json!(CANDIDATE_CHECK_TOOL); + assert!( + CompiledRecipe::compile( + &serde_json::to_vec(&source).expect("source"), + &serde_json::to_vec(&reserved_lock).expect("lock") + ) + .is_err() + ); + cases.push(json!({"case": case, "review": review, "binding_canonical": std::str::from_utf8(&binding).expect("UTF-8"), + "substitutions_refused": refused, "native_reverification": "same effect; altered connection and expired approval refused", + "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "same_credential_new_operation_retains_lifetime_reservations": true, + "probe_predicate": "exact value accepted; wrong value and duplicate member refused" })); + } + let no_reads = recipe(&json!({}), &Value::Null); + assert!( + CandidateCredentialTarget::new(&no_reads, &connection(&no_reads), None).is_err(), + "no invented provider read for an offline recipe" + ); + let fixture = serde_json::to_vec_pretty(&json!({"schema": "auths.candidate-compilation-fixture/1", + "scope": "native signed compilation, exact approval and existing-route refusal; no candidate transport, custody, publication, installed UI or PostgreSQL claim", "cases": cases })).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/candidate-compilation.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 78a8e43b8..9d53bc35d 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -9,6 +9,9 @@ use auths_connections::{ }; use ed25519_dalek::{Signer as _, SigningKey}; +#[path = "effect_candidate_tests.rs"] +mod candidate_tests; + #[path = "effect_prerequisite_tests.rs"] mod prerequisite_tests; diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index 7296e8e5c..afcd50a53 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -212,7 +212,9 @@ pub(crate) fn validate_prerequisite_evidence( return Err(invalid); } match evidence.kind { - PrerequisiteKind::Account | PrerequisiteKind::DeniedCapability(_) => { + PrerequisiteKind::Probe + | PrerequisiteKind::Account + | PrerequisiteKind::DeniedCapability(_) => { validate_credential_evidence( installed.recipe, *installed.connection.account_commitment(), @@ -299,6 +301,10 @@ pub(crate) fn validate_credential_evidence( let invalid = "gateway.entry.prerequisite-evidence"; let guard = recipe.guard_checks().ok_or(invalid)?; let valid = match evidence.kind { + PrerequisiteKind::Probe => { + let (pointer, equals) = guard.probe.as_ref().ok_or(invalid)?; + crate::onboarding::probe_passes(Some(&evidence.response), pointer, equals) + } PrerequisiteKind::Account => { let pointer = guard.account_pointer.as_deref().ok_or(invalid)?; crate::submit::account_result(Some(&evidence.response), pointer, Some(account)) diff --git a/product/runtime/auths-gateway/src/onboarding.rs b/product/runtime/auths-gateway/src/onboarding.rs index eefae1a3a..03d8d57c5 100644 --- a/product/runtime/auths-gateway/src/onboarding.rs +++ b/product/runtime/auths-gateway/src/onboarding.rs @@ -183,10 +183,14 @@ async fn check_with_transport( /// A complete 2xx JSON response with no version mismatch whose pointer /// holds exactly the declared value. -fn probe_passes(response: Option<&ProviderResponse>, pointer: &str, equals: &Value) -> bool { +pub(crate) fn probe_passes( + response: Option<&ProviderResponse>, + pointer: &str, + equals: &Value, +) -> bool { response .and_then(ProviderResponse::usable_body) - .and_then(|body| serde_json::from_slice::(body).ok()) + .and_then(crate::recipe::parse_provider_response) .is_some_and(|document| document.pointer(pointer) == Some(equals)) } diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 6a8ea3a05..c8556a172 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -536,7 +536,11 @@ impl CompiledRecipe { serde_json::from_slice(source_bytes).map_err(|_| GatewayRecipeError::InvalidSource)?; let lock: ProfileLockFile = serde_json::from_slice(lock_bytes) .map_err(|_| GatewayRecipeError::InvalidProfileLock)?; - if source.schema != RECIPE_SOURCE_SCHEMA || source.tool == crate::effect::RECOVERY_READ_TOOL + if source.schema != RECIPE_SOURCE_SCHEMA + || matches!( + source.tool.as_str(), + crate::effect::RECOVERY_READ_TOOL | crate::effect::CANDIDATE_CHECK_TOOL + ) { return Err(GatewayRecipeError::InvalidSource); } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 831537431..25785f066 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9d0e96e0b61a8e2b2d856072de549dcbe5005e527cd1bde403887fba95de5d7c"; + "fb5fa41d4f9f04a16135e177dd86758d1d42d6e1ee776876492c2b42fc7c0415"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/application_recovery_cli.rs b/product/runtime/auths-gateway/tests/application_recovery_cli.rs index aa07c2353..cdae73c0e 100644 --- a/product/runtime/auths-gateway/tests/application_recovery_cli.rs +++ b/product/runtime/auths-gateway/tests/application_recovery_cli.rs @@ -52,6 +52,11 @@ fn native_application_recovery_cli_fixture_is_current() { Err(error) => panic!("CLI did not connect: {error}"), } }; + // Darwin can inherit O_NONBLOCK from the listener. The bounded + // read_exact protocol below needs blocking I/O with its own deadline. + stream + .set_nonblocking(false) + .expect("blocking accepted stream"); stream .set_read_timeout(Some(std::time::Duration::from_secs(5))) .expect("deadline"); From 57332c5809922352fbc427479763b5012fbc0ce9 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 10:37:15 +0000 Subject: [PATCH 038/136] feat(gateway)!: journal candidate credential acquisitions --- .../gateway/attempt-scenarios-v3.json | 2 +- .../gateway/candidate-compilation.json | 402 +++--- .../fixtures/gateway/candidate-journal.json | 1246 +++++++++++++++++ bindings/fixtures/gateway/effect-entry.json | 4 +- .../fixtures/gateway/prerequisite-entry.json | 2 +- compliance.toml | 7 +- ...017-bound-effect-and-recovery-ownership.md | 29 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 16 +- docs/plans/0074-implementation-status.md | 42 +- .../0009-bound-effect-and-recovery.md | 21 + ...ound-effects-and-recovery-state-machine.md | 13 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6577 -> 6577 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6460 -> 6460 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5732 -> 5732 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5031 -> 5031 bytes .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/candidate_runtime.rs | 214 +++ product/runtime/auths-gateway/src/effect.rs | 19 +- .../auths-gateway/src/effect/acquisition.rs | 15 + .../auths-gateway/src/effect/candidate.rs | 294 +++- .../src/effect_candidate_tests.rs | 357 ++++- .../auths-gateway/src/effect_native_tests.rs | 4 +- .../src/effect_prerequisite_tests.rs | 2 +- .../src/effect_read_budget_tests.rs | 4 +- .../src/effect_recovery_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 92 +- product/runtime/auths-gateway/src/entry.rs | 64 +- .../src/pending_vectors/attempts.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 24 +- .../auths-gateway/src/store/acquisition.rs | 191 ++- product/runtime/auths-gateway/src/submit.rs | 114 +- 40 files changed, 2805 insertions(+), 399 deletions(-) create mode 100644 bindings/fixtures/gateway/candidate-journal.json create mode 100644 product/runtime/auths-gateway/src/candidate_runtime.rs diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 88c9d6a8c..3783e22ac 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/11", + "attempt_schema": "auths.gateway-attempt/12", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/candidate-compilation.json b/bindings/fixtures/gateway/candidate-compilation.json index 2d4b76988..60d17d5f7 100644 --- a/bindings/fixtures/gateway/candidate-compilation.json +++ b/bindings/fixtures/gateway/candidate-compilation.json @@ -964,7 +964,7 @@ "extra" ], "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" }, @@ -1990,7 +1990,7 @@ "extra" ], "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" }, @@ -3016,7 +3016,7 @@ "extra" ], "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" }, @@ -3982,7 +3982,7 @@ "extra" ], "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" }, @@ -3991,38 +3991,38 @@ "review": { "binding": { "action": [ - 203, - 199, - 42, - 92, - 163, - 123, - 16, - 133, - 254, - 127, - 137, - 126, - 113, - 127, + 2, 241, - 137, - 107, - 16, - 155, - 114, - 109, - 245, - 219, - 48, + 228, + 184, + 159, + 244, + 56, + 10, + 67, 221, - 200, - 255, - 195, - 71, - 160, + 149, 42, - 193 + 101, + 12, + 185, + 192, + 41, + 4, + 115, + 134, + 162, + 161, + 57, + 145, + 209, + 136, + 226, + 44, + 63, + 133, + 168, + 241 ], "approval_policy": { "approver": [ @@ -4097,184 +4097,184 @@ 12 ], "connection": [ - 248, - 80, - 32, - 215, - 188, - 17, - 142, - 105, - 204, - 80, - 225, - 73, - 139, - 177, - 127, - 16, - 242, - 65, - 181, - 27, - 87, - 123, - 125, - 2, - 229, - 210, - 91, - 132, - 193, - 137, - 116, - 30 + 226, + 64, + 92, + 244, + 133, + 189, + 206, + 112, + 245, + 115, + 217, + 226, + 153, + 30, + 5, + 213, + 126, + 247, + 35, + 0, + 251, + 85, + 4, + 78, + 94, + 38, + 67, + 189, + 33, + 198, + 75, + 100 ], "credential_generation": 1, "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 125, - 70, - 6, - 21, - 215, - 50, - 106, + 164, + 129, + 114, + 253, 141, - 238, - 94, - 232, - 162, - 163, - 182, - 216, + 88, + 237, + 82, + 71, + 126, 178, - 100, - 246, - 17, - 46, - 94, - 55, - 66, - 217, - 120, - 231, - 163, - 191, - 225, - 139, - 107, - 134 + 81, + 103, + 60, + 87, + 72, + 92, + 103, + 130, + 187, + 183, + 138, + 219, + 24, + 110, + 11, + 186, + 11, + 194, + 99, + 193, + 189 ], "operation": "candidate-1", "partition": "synthetic-candidate", "protocol": { "kind": "acquisition", - "maximum_response_bytes": 16384, + "maximum_response_bytes": 8192, "projection": [ - 165, - 34, - 65, - 132, - 42, - 233, - 126, - 82, - 190, - 0, - 147, - 158, - 208, - 50, - 92, 10, - 27, - 234, - 60, - 180, - 44, - 165, - 137, - 152, - 154, - 224, - 237, - 255, + 19, + 169, + 28, + 7, + 92, + 106, + 176, + 225, + 149, + 91, + 163, + 246, + 31, + 140, + 87, + 64, + 38, + 50, + 206, + 105, + 108, + 100, + 168, + 25, + 252, + 161, + 158, + 131, 172, - 113, - 127, - 90 + 135, + 66 ], "request": [ - 241, - 182, - 47, - 99, - 123, - 228, - 160, - 59, - 120, - 136, + 34, + 21, + 75, + 72, + 97, + 66, + 130, + 128, + 193, + 230, + 226, + 46, + 167, + 112, + 197, + 118, + 191, + 254, + 64, 148, - 142, - 105, - 198, - 9, - 105, - 38, - 136, - 173, - 50, - 179, - 137, - 247, - 255, - 100, + 222, + 106, + 27, + 149, + 37, + 194, + 63, + 102, + 134, 202, - 46, - 8, - 201, - 97, - 14, - 37 + 3, + 229 ] }, "qualification_policy": "optional", "recipe": [ - 11, - 94, - 7, - 167, - 129, - 255, - 110, - 72, - 214, - 230, - 115, - 168, - 217, - 64, - 223, - 184, - 144, - 39, - 88, - 250, 180, - 93, - 255, - 155, + 218, + 234, + 81, + 78, + 245, + 231, + 55, + 19, + 82, + 69, + 198, + 222, + 117, + 228, + 219, 10, - 11, - 235, - 180, - 5, - 89, - 143, - 224 + 112, + 223, + 228, + 83, + 72, + 31, + 224, + 39, + 90, + 223, + 111, + 16, + 140, + 61, + 102 ], "reservations": [ { @@ -4320,8 +4320,8 @@ } }, { - "amount": 16384, - "ceiling": 262144, + "amount": 8192, + "ceiling": 131072, "key": [ 246, 115, @@ -4367,8 +4367,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[203,199,42,92,163,123,16,133,254,127,137,126,113,127,241,137,107,16,155,114,109,245,219,48,221,200,255,195,71,160,42,193],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[248,80,32,215,188,17,142,105,204,80,225,73,139,177,127,16,242,65,181,27,87,123,125,2,229,210,91,132,193,137,116,30],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[125,70,6,21,215,50,106,141,238,94,232,162,163,182,216,178,100,246,17,46,94,55,66,217,120,231,163,191,225,139,107,134],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[165,34,65,132,42,233,126,82,190,0,147,158,208,50,92,10,27,234,60,180,44,165,137,152,154,224,237,255,172,113,127,90],\"request\":[241,182,47,99,123,228,160,59,120,136,148,142,105,198,9,105,38,136,173,50,179,137,247,255,100,202,46,8,201,97,14,37]},\"qualification_policy\":\"optional\",\"recipe\":[11,94,7,167,129,255,110,72,214,230,115,168,217,64,223,184,144,39,88,250,180,93,255,155,10,11,235,180,5,89,143,224],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "84f7dabed2310a480eb2f0503ea5b9a1f77bc941c686b26bffcdcb91b07988eb", + "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[164,129,114,253,141,88,237,82,71,126,178,81,103,60,87,72,92,103,130,187,183,138,219,24,110,11,186,11,194,99,193,189],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "901f6f7627b65d7208a8f605d52135d6ecb8499a9187a9eb638c3e58908c8403", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -4377,18 +4377,18 @@ "provider": "airtable" }, "native": { - "action_commitment": "cbc72a5ca37b1085fe7f897e717ff1896b109b726df5db30ddc8ffc347a02ac1", + "action_commitment": "02f1e4b89ff4380a43dd952a650cb9c029047386a2a13991d188e22c3f85a8f1", "actors": [ "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" ], "arguments": { - "candidate_connection": "f85020d7bc118e69cc50e1498bb17f10f241b51b577b7d02e5d25b84c189741e", + "candidate_connection": "e2405cf485bdce70f573d9e2991e05d57ef72300fb55044e5e2643bd21c64b64", "expected_previous": null, - "maximum_response_bytes": 16384, + "maximum_response_bytes": 8192, "operation_id": "candidate-1", "operator_namespace": "stripe-refunds", - "read_contract": "a52241842ae97e52be00939ed0325c0a1bea3cb42ca589989ae0edffac717f5a", - "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0" + "read_contract": "0a13a91c075c6ab0e1955ba3f61f8c57402632ce696c64a819fca19e83ac8742", + "recipe_digest": "b4daea514ef5e737135245c6de75e4db0a70dfe453481fe0275adf6f108c3d66" }, "candidate": { "candidate": { @@ -4413,7 +4413,7 @@ "kind": "bearer" }, "operator_namespace": "stripe-refunds", - "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0", + "recipe_digest": "b4daea514ef5e737135245c6de75e4db0a70dfe453481fe0275adf6f108c3d66", "schema": "auths.gateway-connection-descriptor/1" }, "descriptor_schema": "auths.gateway-connection-descriptor/1", @@ -4441,7 +4441,7 @@ "2025-03-31.basil" ] ], - "maximum_response_bytes": 16384, + "maximum_response_bytes": 8192, "method": "GET", "url": "https://api.stripe.com/v1/balance" } @@ -4480,7 +4480,7 @@ "kind": "bearer" }, "operator_namespace": "stripe-refunds", - "recipe_digest": "0b5e07a781ff6e48d6e673a8d940dfb8902758fab45dff9b0a0bebb405598fe0", + "recipe_digest": "b4daea514ef5e737135245c6de75e4db0a70dfe453481fe0275adf6f108c3d66", "schema": "auths.gateway-connection-descriptor/1" }, "descriptor_schema": "auths.gateway-connection-descriptor/1", @@ -4508,7 +4508,7 @@ "2025-03-31.basil" ] ], - "maximum_response_bytes": 16384, + "maximum_response_bytes": 8192, "method": "GET", "url": "https://api.stripe.com/v1/balance" } @@ -4522,7 +4522,7 @@ "prerequisite_acquisitions": [] } }, - "binding_canonical": "{\"action\":[203,199,42,92,163,123,16,133,254,127,137,126,113,127,241,137,107,16,155,114,109,245,219,48,221,200,255,195,71,160,42,193],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[248,80,32,215,188,17,142,105,204,80,225,73,139,177,127,16,242,65,181,27,87,123,125,2,229,210,91,132,193,137,116,30],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[125,70,6,21,215,50,106,141,238,94,232,162,163,182,216,178,100,246,17,46,94,55,66,217,120,231,163,191,225,139,107,134],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[165,34,65,132,42,233,126,82,190,0,147,158,208,50,92,10,27,234,60,180,44,165,137,152,154,224,237,255,172,113,127,90],\"request\":[241,182,47,99,123,228,160,59,120,136,148,142,105,198,9,105,38,136,173,50,179,137,247,255,100,202,46,8,201,97,14,37]},\"qualification_policy\":\"optional\",\"recipe\":[11,94,7,167,129,255,110,72,214,230,115,168,217,64,223,184,144,39,88,250,180,93,255,155,10,11,235,180,5,89,143,224],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[164,129,114,253,141,88,237,82,71,126,178,81,103,60,87,72,92,103,130,187,183,138,219,24,110,11,186,11,194,99,193,189],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", @@ -4532,7 +4532,7 @@ "extra" ], "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" } diff --git a/bindings/fixtures/gateway/candidate-journal.json b/bindings/fixtures/gateway/candidate-journal.json new file mode 100644 index 000000000..75bb1608a --- /dev/null +++ b/bindings/fixtures/gateway/candidate-journal.json @@ -0,0 +1,1246 @@ +{ + "schema": "auths.candidate-journal-fixture/1", + "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; no installed provider, publication or PostgreSQL claim", + "cases": [ + { + "target": "first-install", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "rotation", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "disabled-rotation", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "head-final", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "probe-only", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "restart_preserves_facts_and_charges": true + } + ] + } + ], + "cross_proposal_capacity": [ + { + "case": "first-install", + "shared_credential_capacity": "one retained allocation" + }, + { + "case": "head-final", + "shared_credential_capacity": "one retained allocation" + }, + { + "case": "probe-only", + "shared_credential_capacity": "changed ceiling refused without record" + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index 553064fba..ef4818d40 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -21,7 +21,7 @@ "read_at": 1790000061 } }, - "schema": "auths.effect-entry/2", + "schema": "auths.effect-entry/3", "granted_at": 1790000061, "effect_id": "a661f5e2dabf4bb995b06976f81e693e40633469f162909e786506ce79d3202c", "dependencies": [ @@ -41,7 +41,7 @@ "authorization_started_at": 1790000000, "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}", "pre_entry": null, - "schema": "auths.effect-entry/2", + "schema": "auths.effect-entry/3", "granted_at": 1790000000, "effect_id": "ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8", "dependencies": [] diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 7f047a708..e0ce510f0 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/11", + "attempt_schema": "auths.gateway-attempt/12", "cases": [ { "recipe": "stripe", diff --git a/compliance.toml b/compliance.toml index f93a0342d..2c59972f9 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/11", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/12", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1600,7 +1600,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/2", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/11", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-acquisition = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", +] candidate-compilation = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 258c7a3a8..1efaa2ff5 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -655,3 +655,32 @@ ceiling and declared one-call child allowances. Current native count/byte polici also apply. This checkpoint adds compilation and review only. Candidate staging, fresh absent/current-record fencing, shared journal admission, actual checks and publication are required before production onboarding can use this target. + + +## Candidate acquisition admission and execution + +Candidate checks now use a typed plan in the existing acquisition journal. +Their source dependency is the exact expected connection row, including a +fenced absence for first install. The same native entry checker handles a +published connection or a sealed candidate; candidate reads may preserve a +disabled predecessor, but require the pinned workload/profile and refuse +revocation or any predecessor change. Child entry checks both its reserved +parent and the candidate's current connection dependency. Final primary entry +also checks all retained child predicates and freshness. + +The source and native connection dependency can name the same physical row. +The fence reads it once and maps that snapshot to both checks. This is index +bookkeeping, not a second validation authority. Entry audit `/3` records a +checked absence as null, distinct from a present record's commitment. Journal +`/12` rejects the superseded encoding. No missing dependency is implicitly +accepted; the typed candidate predicate alone admits first-install absence. + +Lifetime allocations are append-only and retain a fixed byte ceiling for one +credential identity. A competing proposal with that identity cannot change the +ceiling after an allocation exists. The shared read runtime executes ordered +prerequisites, evaluates retained native evidence, consumes one primary permit +and records response/unknown. Mutation prerequisites, recovery and candidates +use the same helper. `acquire_candidate_credential` leases only the exact already +staged candidate and returns redacted acquisition facts. It does not publish the +credential. CLI staging, final-purpose validation, safely fenced publication and +removal of the old onboarding/rotation read routes remain required. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 7b57f2a5e..2a8c58e96 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -104,12 +104,14 @@ content, locators, echo and private commitments. Installed transport/fault coverage, the authenticated approval frontend, ancillary acquisition cutovers and full acceptance evidence remain open AP074 requirements. -Compiler `/8` additionally exposes a native candidate-check compilation API for -an exact staged first-install or rotation descriptor. Its private review binds -the predecessor (or absence), probe/account/capability order and read limits. -This API does not publish credentials or grant provider entry. The onboarding -and rotation CLI execution cutover is still pending; do not treat compilation -or an operator attestation as proof that candidate reads passed. +Compiler `/8` exposes native candidate-check compilation for an exact staged +first-install or rotation descriptor. The corresponding engine acquisition API +now uses journal `/12` and entry audit `/3`: predecessor/absence, current native +authority and all earlier check evidence are fenced before reads. It leases only +the exact already-staged credential and returns redacted acquisition facts. +This API does not publish credentials. The onboarding/rotation CLI staging and +publication cutover is still pending; a recorded HTTP response alone does not +mean that the final check passed or that a rotation is authorized. A production installation names its operator only through a signed `auths.gateway-operator-attestation/2` statement. `operator-request` prints @@ -186,7 +188,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/11`; a store holding obsolete records is refused as + `auths.gateway-attempt/12`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index b999c2fc0..cbf7947bd 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -814,6 +814,46 @@ closure regeneration passed after that correction (one artifact-generation test) on `15b3cad1` plus this source. No broad local gate or hosted CI was run; no A01–A22 acceptance criterion closes. +## Candidate acquisition journal/runtime checkpoint + +- Journal `/12` adds candidate source plans to the shared acquisition owner. + Admission pins the actual expected predecessor or first-install absence; + ordinary and candidate entry share native verification/configuration/approval + checks. Candidate checks preserve disabled state and still require the exact + workload/profile. Revocation or any predecessor replacement prevents later + child and primary grants. The source/native dependency on the same connection + row is read once, with both predicates evaluated against that snapshot. +- Entry audit `/3` records absence separately from a present record commitment. + Native candidate histories exposed the previous all-present audit assumption; + the explicit layout change makes first-install grants representable without + weakening mandatory dependency checks. Old layouts are refused. +- The engine candidate acquisition API leases the exact staged credential after + admission and uses the shared ordered-read helper. It validates earlier probe, + account and capability responses before primary entry; final entry repeats + their actual predicates/freshness. Response/unknown facts retain allocations + and never grant publication. Cross-proposal allocation collision checks prevent + a credential identity from changing its already established byte ceiling. +- The native candidate artifact generator covers first install, active/disabled + rotation, HEAD-final and probe-only variants using actual native fence checking + and real file state. Histories cover missing/bad/stale children, predecessor + changes before admission/child/main entry, lost main permits, replay and reopen. + Configuration/clock and response bodies are synthetic; no installed provider, + publication or PostgreSQL claim is made. A capacity fixture initially reused + equal limits; its probe-only recipe now changes the limit to exercise refusal. +- Artifact construction passed on `f0a364fd` plus this source: 36 candidate + journal histories and three cross-proposal capacity cases; recovery/prerequisite + compilation, binding/approval, actual prerequisite predicates, admission/entry, + replay, attempt, code/custody, application frame/CLI and final semantic closure. + One extraction build required correcting a moved helper's module qualifier; + the new capacity case required actually differing byte ceilings. These were + corrected before successful regeneration. No broad local suite or hosted CI + was run or observed. +- Remaining onboarding work: durable staging/authoring CLI, retained final-purpose + validation and safely fenced publication, then removal of the old raw check + paths. General acquisition/disclosure/ACK, safe recovery credential replacement, + Python-owner removal, authenticated UI/bindings and full acceptance evidence + remain open. No A01–A22 criterion is fully closed. + ## Phase gates | Phase | State | Outstanding gate | @@ -821,7 +861,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation execution (candidate compilation authored), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation staging/publication (candidate acquisition API wired), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 009a182d0..751375de8 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -406,3 +406,24 @@ recovery and orphan-child routes. It is compiler/predicate and route-refusal evidence only. The candidate journal admission, staged custody, ordered current or absence validation, transport and publication cutover remain required; this checkpoint does not promote an operator attestation into native read authority. + + +## Candidate acquisition runtime checkpoint + +The candidate plan is now another closed source alternative of the existing +acquisition owner, with connection/predecessor eligibility kept distinct from +recovery's source mutation. Physical dependency deduplication preserves both +source and native checks on the same snapshot. Native authority, qualification, +exact approval and workload/profile checks remain in `entry.rs`; disabled +candidate rotation is explicit and cannot authorize an ordinary mutation. +The shared acquisition runtime consumes the same permits and retained-response +predicates. There is no new reducer, provider callback or public content path. + +`candidate-journal.json` records actual native fenced validation with signed +proofs and real file persistence for first install, active/disabled rotation, +HEAD-final and probe-only plans. Histories cover absent/changed predecessors, +changes before child/main grants, missing/bad/stale child evidence, lost main +permits and restart. Cross-proposal capacity checks preserve the credential's +first byte ceiling. Configuration and time are test-controlled; provider bodies +are synthetic. These artifacts do not establish installed provider execution, +PostgreSQL conformance, final-check acceptance or credential publication. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 61f26812a..0b67d2154 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -263,7 +263,18 @@ cannot establish predecessor freshness, enter transport or publish a credential; the runtime must fence predecessor/absence and retain the checks through safe publication in the same authoritative journal contract. -The concrete journal encoding is `auths.gateway-attempt/11`. Each prerequisite +Candidate journal admission uses the expected connection row as a source +rather than an invented source mutation. Both admission and every child/primary +entry must recheck predecessor/absence, exact native authority, configuration, +approval and qualification under the same fence. Root source and native checks +share one snapshot when they address the same row. Entry audit +`auths.effect-entry/3` records checked absence explicitly, separately from a +present record's digest. A candidate's source-lifetime byte ceiling cannot +change once its credential identity has an allocation. Candidate acquisition +returns retained response/unknown facts; publication remains a separate operator +action requiring the final purpose and complete fresh retained evidence. + +The concrete journal encoding is `auths.gateway-attempt/12`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index c739a7090..5f77fc2ae 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 943a3a869..970ae734f 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index a9fccca4a..5216cace9 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index e2de1f19a..c02a7fb52 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index ecc7f4ff0..07b7b9fd0 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/11","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/2","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 45eeadcdf0f2d36d944bd89a90b9fb87ffd1af59..5f8e775cfbd94213edfe50268a2637a2fcac1487 100644 GIT binary patch delta 36 mcmdmJywP}qF{9B&6KyU=U<3fmb_(PG delta 36 mcmdmEw8vU<3fmC<@>J diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index 1700a451f24c1b09e50bd95acce415028f31b162..e00709661dba534e5caf8f94f4bb41ff274bbc77 100644 GIT binary patch delta 32 lcmaE&^F(KYF{9DuubijYH~(Y*#t3F>b1@okRupk&0s!GJ3&H>Z delta 32 lcmaE&^F(KYF{9z;ubijYH~(Y*#t3F>b1@oiRupk&0s!Fy3%>vW diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index 251d1904511e1ed605b57507221d0cf6e5432460..adea1cb8273a3cebe89d01cc5d1ae14b0675628e 100644 GIT binary patch delta 24 gcmZ3kzFd8RF{9Dqubdp4O*jrPG8%3E%DIUX0BmvyivR!s delta 24 gcmZ3kzFd8RF{9z)ubdp4O*jrPG8%6F%DIUX0Bl Result { + self.check_candidate_predecessor(target) + .await + .map_err(not_entered)?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + compile_candidate_credential( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + target.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + target, + now, + proof, + action, + ) + } + + async fn check_candidate_predecessor( + &self, + target: &CandidateCredentialTarget, + ) -> Result<(), &'static str> { + self.check_effect_configuration().await?; + let record = target.record(); + if record.provider_kind() != self.connection.provider() + || record.alias() != self.connection.alias() + || record.state() == ConnectionState::Revoked + || !record.allowed_workloads().contains(&self.workload_id) + || !record.allowed_profiles().contains(&self.profile) + { + return Err("gateway.connection.unavailable"); + } + let current = self.connection.load().await.map_err(|error| match error { + SharedConnectionError::Rollback => "gateway.connection.restore-rollback", + _ => "gateway.connection.unavailable", + })?; + if !target.predecessor_matches(current.as_ref().map(LoadedConnection::private_bytes)) { + return Err("gateway.connection.changed"); + } + Ok(()) + } + + /// Durably admits and executes native-approved candidate checks using the + /// exact credential already staged in custody. Returns redacted journal + /// facts only. It does not install, rotate or disclose a credential/content. + /// A recorded final response still needs its purpose evaluated before any + /// separately fenced publication; HTTP success alone is insufficient. + /// + /// # Errors + /// Refuses changed predecessor/configuration, invalid authority/approval, + /// unavailable staged custody, bad prerequisites or exhausted capacity. + /// An uncertain grant retains its charges and cannot be retried implicitly. + pub async fn acquire_candidate_credential( + &self, + target: &CandidateCredentialTarget, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self.compile_candidate_effect(target, proof, action).await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + if let Some(snapshot) = self + .attempts + .read_acquisition(&approved) + .await + .map_err(|_| not_entered("gateway.attempt.state-unavailable"))? + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot); + } + let descriptor = GatewayConnectionDescriptor::from_record(target.record(), &self.recipe) + .map_err(|_| not_entered("gateway.connection.recipe-mismatch"))?; + let io = CandidateIo { + engine: self, + target, + transport: self.prepare_transport(&descriptor).map_err(not_entered)?, + started, + }; + let reserved = match self + .attempts + .claim_candidate( + &approved, + now, + io.acquisition_validation().map_err(not_entered)?, + ) + .await + { + Ok(crate::AcquisitionClaim::Existing(snapshot)) => return Ok(snapshot), + Ok(crate::AcquisitionClaim::Reserved(reserved)) => reserved, + Err(crate::GatewayAttemptError::BindingConflict) => { + return Err(not_entered("gateway.effect.operation-conflict")); + } + Err(_) => return self.recovery_projection(&approved).await, + }; + let result = async { + let _flight = submit::InFlight::enter(&io); + self.check_candidate_predecessor(target).await?; + self.qualification.check()?; + self.execution_witness.lease(); + let lease = self + .credentials + .lease_secret( + &target.record().credential_binding(), + Instant::now() + Duration::from_secs(30), + ) + .await + .map_err(|_| "gateway.credential.unavailable")?; + if self.recipe.guard_checks().as_ref().is_some_and(|guard| { + !lease + .expose(Instant::now()) + .is_ok_and(|secret| guard.admits_secret(secret)) + }) { + return Err("gateway.credential.mode-guard"); + } + submit::complete_acquisition( + &self.attempts, + &self.recipe, + Arc::clone(&approved), + *reserved, + &io, + &lease, + ) + .await + } + .await; + match result { + Ok(snapshot) => Ok(snapshot), + Err(_) => self.recovery_projection(&approved).await, + } + } +} + +struct CandidateIo<'a> { + engine: &'a GatewayEngine, + target: &'a CandidateCredentialTarget, + transport: GatewayHttpTransport, + started: Instant, +} + +impl AcquisitionIo for CandidateIo<'_> { + type Lease = StoredSecretLease; + fn acquisition_enter(&self) { + self.engine.in_flight.fetch_add(1, Ordering::SeqCst); + } + fn acquisition_leave(&self) { + self.engine.in_flight.fetch_sub(1, Ordering::SeqCst); + } + fn acquisition_clock(&self) -> Option { + self.engine.qualification.effect_time() + } + fn acquisition_validation(&self) -> Result { + Ok(crate::entry::EntryValidation::Installed(Box::new( + crate::entry::InstalledEntry { + recipe: self.engine.recipe.clone(), + trust: self.engine.trusted_context.clone(), + observer: None, + policy: self.engine.effect_policy.clone(), + configuration: self.engine.shared_configuration()?, + connection: crate::entry::EntryConnection::Candidate(Box::new(self.target.clone())), + connection_key: crate::connection_key( + self.engine.connection.provider(), + self.engine.connection.alias(), + ), + qualification: Arc::clone(&self.engine.qualification), + workload: self.engine.workload_id.clone(), + profile: self.engine.profile.clone(), + started: self.started, + #[cfg(unix)] + commissioning: None, + }, + ))) + } + async fn acquisition_send( + &self, + lease: &Self::Lease, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + self.transport.acquire(permit, lease).await + } +} diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 985a3f396..426f374e1 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -20,6 +20,7 @@ use zeroize::Zeroizing; mod acquisition; mod candidate; +pub(crate) use candidate::CandidatePlan; pub use candidate::{ CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, }; @@ -1089,6 +1090,22 @@ impl ApprovedEffect { } } + pub(crate) fn candidate_target(&self) -> Option<&CandidateCredentialTarget> { + match &self.effect.command { + CompiledEffect::Acquisition(command) => match &command.target { + acquisition::AcquisitionTarget::Candidate(target) => Some(target), + acquisition::AcquisitionTarget::Recovery(_) => None, + }, + CompiledEffect::Mutation(_) => None, + } + } + + pub(crate) fn candidate_plan(&self) -> Result { + self.candidate_target() + .ok_or(EffectBindingError::Invalid)? + .journal_plan() + } + pub(crate) fn recovery_target(&self) -> Option<&RecoveryReadTarget> { match &self.effect.command { CompiledEffect::Mutation(_) => None, @@ -1099,7 +1116,7 @@ impl ApprovedEffect { } } - pub(crate) fn recovery_bound(&self) -> Option<&crate::bounds::BoundAdmission> { + pub(crate) fn acquisition_bound(&self) -> Option<&crate::bounds::BoundAdmission> { match &self.effect.command { CompiledEffect::Mutation(_) => None, CompiledEffect::Acquisition(command) => command.bound.as_ref(), diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 8709aef78..8ccde1d31 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -263,19 +263,29 @@ pub(crate) struct RecoveryPlan { )] pub(crate) enum AcquisitionPlan { Recovery(RecoveryPlan), + Candidate(super::candidate::CandidatePlan), Prerequisite(PrerequisitePlan), } impl AcquisitionPlan { + pub(crate) fn source_id(&self) -> Result<[u8; 32], EffectBindingError> { + match self { + Self::Candidate(plan) => plan.source_id(), + _ => Ok(*self.source()?.id().as_bytes()), + } + } + pub(crate) fn source(&self) -> Result { match self { Self::Recovery(plan) => plan.source(), + Self::Candidate(_) => Err(EffectBindingError::Invalid), Self::Prerequisite(plan) => plan.source(), } } pub(crate) fn capacity(&self) -> Result { match self { Self::Recovery(plan) => plan.capacity(), + Self::Candidate(plan) => plan.capacity(), Self::Prerequisite(plan) => plan.capacity(), } } @@ -285,6 +295,7 @@ impl AcquisitionPlan { ) -> Result { match self { Self::Recovery(plan) => plan.validate(binding), + Self::Candidate(plan) => plan.validate(binding), Self::Prerequisite(plan) => plan.validate(binding), } } @@ -495,6 +506,10 @@ pub fn compile_recovery_acquisition( ) } +#[allow( + clippy::too_many_lines, + reason = "one native verification path retains the two closed acquisition target contracts" +)] pub(super) fn compile_acquisition( installed: &EffectInstallation<'_>, target: AcquisitionTarget, diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs index d902c5dc1..a4b210357 100644 --- a/product/runtime/auths-gateway/src/effect/candidate.rs +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -87,6 +87,44 @@ impl CandidateCredentialTarget { Ok(target) } + pub(crate) fn record(&self) -> &ConnectionRecord { + &self.candidate + } + + pub(crate) fn predecessor_matches(&self, bytes: Option<&[u8]>) -> bool { + match (&self.previous, bytes) { + (None, None) => true, + (Some(previous), Some(bytes)) => previous + .to_canonical_cbor() + .is_ok_and(|expected| expected == bytes), + _ => false, + } + } + + pub(crate) fn final_request(&self) -> &ClosedPrerequisiteRead { + &self.last.request + } + + pub(crate) fn journal_plan(&self) -> Result { + Ok(CandidatePlan { + candidate: hex::encode( + self.candidate + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ), + previous: self + .previous + .as_ref() + .map(|record| record.to_canonical_cbor().map(hex::encode)) + .transpose() + .map_err(|_| EffectBindingError::Invalid)?, + transport: String::from_utf8(self.request_bytes()?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + contract: String::from_utf8(canonical(&self.contract())?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + }) + } + fn record_commitment(record: &ConnectionRecord) -> Result<[u8; 32], EffectBindingError> { let bytes = Zeroizing::new( record @@ -99,21 +137,7 @@ impl CandidateCredentialTarget { pub(super) fn contract(&self) -> Value { // Complete connection fields are part of private review, including predecessor // state and authorization. Commitments alone would hide review fields. - let record = |record: &ConnectionRecord| { - json!({ - "provider": record.provider_kind().as_str(), "alias": record.alias().as_str(), - "connection_id": record.connection_id().as_str(), - "contract": record.contract().as_str(), "descriptor_schema": record.descriptor_schema().as_str(), - "descriptor": self.descriptor, - "account_commitment": hex::encode(record.account_commitment()), - "credential_reference_commitment": hex::encode(record.credential_reference_commitment()), - "generation": record.generation().get(), "credential_generation": record.credential_generation().get(), - "state": match record.state() { ConnectionState::Active => "active", ConnectionState::Disabled => "disabled", ConnectionState::Revoked => "revoked" }, - "allowed_workloads": record.allowed_workloads(), - "allowed_profiles": record.allowed_profiles().iter().map(|p| json!({"id": p.id().as_str(), "version": p.version()})).collect::>(), - "created_at_unix_seconds": record.created_at_unix_seconds(), "updated_at_unix_seconds": record.updated_at_unix_seconds(), - }) - }; + let record = |record: &ConnectionRecord| connection_review(record, &self.descriptor); json!({ "schema": CONTRACT, "candidate": record(&self.candidate), "expected_previous": self.previous.as_ref().map(record), @@ -193,23 +217,8 @@ impl CandidateCredentialTarget { bound: Option<&crate::bounds::BoundAdmission>, ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); - let key = |unit| { - commitment( - "auths.candidate-capacity/1", - &canonical(&( - self.candidate.connection_id().as_str(), - self.candidate.credential_generation().get(), - self.candidate.credential_reference_commitment(), - unit, - ))?, - ) - }; - let capacity = AcquisitionCapacity { - count_key: key(Unit::AcquisitionCount).map_err(|_| invalid())?, - bytes_key: key(Unit::ResponseBytes).map_err(|_| invalid())?, - maximum_bytes: self.maximum_response_bytes(), - attempts: MAX_CANDIDATE_ATTEMPTS, - }; + let capacity = candidate_capacity(&self.candidate, self.maximum_response_bytes()) + .map_err(|_| invalid())?; let mut reservations = capacity.reservations(); reservations.extend(managed_reservations( bound, @@ -263,3 +272,224 @@ pub fn compile_candidate_credential( action, ) } + +fn candidate_capacity( + candidate: &ConnectionRecord, + maximum_bytes: u64, +) -> Result { + if !(1..=65_536).contains(&maximum_bytes) { + return Err(EffectBindingError::Invalid); + } + let key = |unit| { + commitment( + "auths.candidate-capacity/1", + &canonical(&( + candidate.connection_id().as_str(), + candidate.credential_generation().get(), + candidate.credential_reference_commitment(), + unit, + ))?, + ) + }; + Ok(AcquisitionCapacity { + count_key: key(Unit::AcquisitionCount)?, + bytes_key: key(Unit::ResponseBytes)?, + maximum_bytes, + attempts: MAX_CANDIDATE_ATTEMPTS, + }) +} + +/// Private immutable audit projection; decoding never creates a transport target. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct CandidatePlan { + candidate: String, + previous: Option, + transport: String, + contract: String, +} + +impl CandidatePlan { + pub(crate) fn connection(&self) -> Result { + if self.candidate.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let bytes = hex::decode(&self.candidate).map_err(|_| EffectBindingError::Invalid)?; + if hex::encode(&bytes) != self.candidate { + return Err(EffectBindingError::Invalid); + } + ConnectionRecord::from_canonical_cbor(&bytes).map_err(|_| EffectBindingError::Invalid) + } + + pub(crate) fn source_key(&self) -> Result { + let record = self.connection()?; + Ok(crate::connection_key( + record.provider_kind(), + record.alias(), + )) + } + + pub(crate) fn source_id(&self) -> Result<[u8; 32], EffectBindingError> { + let record = self.connection()?; + commitment( + "auths.candidate-source/1", + &canonical(&( + record.connection_id().as_str(), + record.credential_generation().get(), + record.credential_reference_commitment(), + ))?, + ) + } + + pub(crate) fn source_matches( + &self, + bytes: Option<&[u8]>, + ) -> Result<(bool, u64), EffectBindingError> { + match (&self.previous, bytes) { + (None, None) => Ok((true, self.connection()?.created_at_unix_seconds())), + (Some(expected), Some(bytes)) => { + let expected_bytes = + hex::decode(expected).map_err(|_| EffectBindingError::Invalid)?; + let previous = ConnectionRecord::from_canonical_cbor(&expected_bytes) + .map_err(|_| EffectBindingError::Invalid)?; + Ok(( + expected_bytes == bytes, + self.connection()? + .updated_at_unix_seconds() + .max(previous.updated_at_unix_seconds()), + )) + } + _ => Ok((false, 0)), + } + } + + fn witness(&self) -> Result { + if self.transport.len() > MAX_EFFECT_BYTES + || self.contract.len() > MAX_EFFECT_BYTES + || self.candidate.len() > MAX_EFFECT_BYTES + || self + .previous + .as_ref() + .is_some_and(|v| v.len() > MAX_EFFECT_BYTES) + { + return Err(EffectBindingError::Invalid); + } + let contract: Value = + serde_json::from_str(&self.contract).map_err(|_| EffectBindingError::Invalid)?; + if canonical(&contract)?.as_slice() != self.contract.as_bytes() + || canonical(&json!({"request": contract["final_check"]["request"], "prerequisite_acquisitions": contract["ordered_prerequisites"]}))?.as_slice() != self.transport.as_bytes() { + return Err(EffectBindingError::Invalid); + } + Ok(contract) + } + + pub(crate) fn capacity(&self) -> Result { + let contract = self.witness()?; + candidate_capacity( + &self.connection()?, + contract["final_check"]["request"]["maximum_response_bytes"] + .as_u64() + .ok_or(EffectBindingError::Invalid)?, + ) + } + + pub(crate) fn validate( + &self, + binding: &EffectBinding, + ) -> Result { + let capacity = self.capacity()?; + let candidate = self.connection()?; + let previous = self + .previous + .as_ref() + .map(|s| hex::decode(s).map_err(|_| EffectBindingError::Invalid)) + .transpose()?; + // Pin predecessor bytes in the signed contract, including absence. Its + // actual current value is checked separately under the adapter fence. + let contract = self.witness()?; + let proposed = contract["candidate"].clone(); + let validate_record = + |value: &Value, record: &ConnectionRecord| -> Result<(), EffectBindingError> { + let descriptor: Value = serde_json::from_slice(record.descriptor()) + .map_err(|_| EffectBindingError::Invalid)?; + if *value != connection_review(record, &descriptor) { + return Err(EffectBindingError::Invalid); + } + Ok(()) + }; + validate_record(&proposed, &candidate)?; + if let Some(bytes) = previous { + let previous = ConnectionRecord::from_canonical_cbor(&bytes) + .map_err(|_| EffectBindingError::Invalid)?; + validate_record(&contract["expected_previous"], &previous)?; + if previous + .rotated( + previous.descriptor().to_vec(), + *previous.account_commitment(), + *candidate.credential_reference_commitment(), + candidate.updated_at_unix_seconds(), + ) + .map_err(|_| EffectBindingError::Invalid)? + != candidate + { + return Err(EffectBindingError::Invalid); + } + } else if !contract["expected_previous"].is_null() + || candidate.generation().get() != 1 + || candidate.state() != ConnectionState::Active + || candidate.created_at_unix_seconds() != candidate.updated_at_unix_seconds() + { + return Err(EffectBindingError::Invalid); + } + if contract["schema"] != CONTRACT + || contract["maximum_attempts"] != MAX_CANDIDATE_ATTEMPTS + || contract["disclosure"] != "none" + || binding.wire.connection != CandidateCredentialTarget::record_commitment(&candidate)? + || binding.wire.credential_generation != candidate.credential_generation().get() + || binding.wire.protocol + != (Protocol::Acquisition { + request: commitment( + "auths.effect-acquisition-request/2", + self.transport.as_bytes(), + )?, + projection: commitment(CONTRACT, self.contract.as_bytes())?, + maximum_response_bytes: capacity.maximum_bytes, + }) + || binding + .wire + .reservations + .iter() + .filter(|r| r.window == ReservationWindow::SourceLifetime) + .cloned() + .collect::>() + != capacity.reservations() + || binding.wire.reservations.iter().any(|r| { + matches!(r.window, ReservationWindow::Fixed { .. }) + && match r.unit { + Unit::AcquisitionCount => r.amount != 1, + Unit::ResponseBytes => r.amount != capacity.maximum_bytes, + _ => true, + } + }) + { + return Err(EffectBindingError::Invalid); + } + Ok(capacity) + } +} + +fn connection_review(record: &ConnectionRecord, descriptor: &Value) -> Value { + json!({ + "provider": record.provider_kind().as_str(), "alias": record.alias().as_str(), + "connection_id": record.connection_id().as_str(), + "contract": record.contract().as_str(), "descriptor_schema": record.descriptor_schema().as_str(), + "descriptor": descriptor, + "account_commitment": hex::encode(record.account_commitment()), + "credential_reference_commitment": hex::encode(record.credential_reference_commitment()), + "generation": record.generation().get(), "credential_generation": record.credential_generation().get(), + "state": match record.state() { ConnectionState::Active => "active", ConnectionState::Disabled => "disabled", ConnectionState::Revoked => "revoked" }, + "allowed_workloads": record.allowed_workloads(), + "allowed_profiles": record.allowed_profiles().iter().map(|p| json!({"id": p.id().as_str(), "version": p.version()})).collect::>(), + "created_at_unix_seconds": record.created_at_unix_seconds(), "updated_at_unix_seconds": record.updated_at_unix_seconds(), + }) +} diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index 32ac19dee..5b61f0a96 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -21,6 +21,19 @@ async fn native_candidate_compilation_fixture_is_current() { let public = key.verifying_key().to_bytes(); let policy = EffectPolicy::new("synthetic-candidate".to_owned(), 1, public).expect("policy"); let mut cases = Vec::new(); + let mut journal_cases = Vec::new(); + let mut capacity_cases = Vec::new(); + let capacity_directory = tempfile::tempdir().expect("capacity directory"); + let capacity_store = std::sync::Arc::new( + crate::FileGatewayAttemptStore::open( + &std::fs::canonicalize(capacity_directory.path()) + .expect("path") + .join("journal"), + ) + .expect("store"), + ); + let capacity_attempts = + crate::GatewayAttempts::new(capacity_store, policy.clone()).expect("capacity attempts"); for case in [ "first-install", "rotation", @@ -34,6 +47,7 @@ async fn native_candidate_compilation_fixture_is_current() { source["credential"]["guard"]["denied_reads"][1]["method"] = json!("HEAD"); } if case == "probe-only" { + source["credential"]["guard"]["probe"]["maximum_response_bytes"] = json!(8192); source["credential"]["guard"] .as_object_mut() .expect("guard") @@ -185,7 +199,7 @@ async fn native_candidate_compilation_fixture_is_current() { if case == "head-final" { "HEAD" } else { "GET" } ); let signing = effect - .approval_request(NOW, NOW + 30) + .approval_request(NOW, NOW + 60) .expect("signing request"); let signature = key .sign(&signing.signing_message().expect("message")) @@ -204,7 +218,7 @@ async fn native_candidate_compilation_fixture_is_current() { approved .validate_for_entry(&installed, NOW + 1) .expect("same native recompile"); - assert!(approved.validate_for_entry(&installed, NOW + 31).is_err()); + assert!(approved.validate_for_entry(&installed, NOW + 61).is_err()); assert!(approved.command().is_none()); assert!(approved.recovery_target().is_none()); assert!(approved.recovery_plan().is_err()); @@ -259,6 +273,66 @@ async fn native_candidate_compilation_fixture_is_current() { .is_err() ); } + journal_cases.push( + candidate_journal( + case, + &approved, + &installed, + &policy, + &target, + previous.as_ref(), + ) + .await, + ); + if previous.is_none() { + let call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse(&format!("capacity-{case}")).expect("operation"), + ) + .expect("call"); + let signed = submission_for_call(&root, &reader, &grant, &call, &[]); + let effect = compile_candidate_credential( + &installed, + &target, + NOW, + &signed.proof, + &signed.action, + ) + .expect("capacity effect"); + let request = effect.approval_request(NOW, NOW + 60).expect("request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approved = std::sync::Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW) + .expect("capacity approval"), + ); + let result = capacity_attempts + .claim_candidate( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await; + if case == "probe-only" { + assert!( + matches!(result, Err(crate::GatewayAttemptError::BindingConflict)), + "same credential cannot change its previously allocated byte ceiling" + ); + assert!( + capacity_attempts + .read_acquisition(&approved) + .await + .expect("read") + .is_none() + ); + } else { + assert!(matches!(result, Ok(crate::AcquisitionClaim::Reserved(_)))); + } + capacity_cases.push(json!({"case": case, "shared_credential_capacity": if case == "probe-only" { "changed ceiling refused without record" } else { "one retained allocation" }})); + } let mut refused = Vec::new(); for field in [ "candidate_connection", @@ -414,7 +488,7 @@ async fn native_candidate_compilation_fixture_is_current() { ); cases.push(json!({"case": case, "review": review, "binding_canonical": std::str::from_utf8(&binding).expect("UTF-8"), "substitutions_refused": refused, "native_reverification": "same effect; altered connection and expired approval refused", - "admission": "mutation, recovery and orphan child refused; candidate runtime not implemented", + "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, "probe_predicate": "exact value accepted; wrong value and duplicate member refused" })); } @@ -431,4 +505,281 @@ async fn native_candidate_compilation_fixture_is_current() { std::fs::write(&path, &fixture).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), fixture); + let fixture = serde_json::to_vec_pretty(&json!({"schema": "auths.candidate-journal-fixture/1", "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; no installed provider, publication or PostgreSQL claim", "cases": journal_cases, "cross_proposal_capacity": capacity_cases})).expect("fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/candidate-journal.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} + +#[allow( + clippy::too_many_lines, + reason = "ordered native fence histories keep state and evidence together" +)] +async fn candidate_journal( + name: &str, + approved: &std::sync::Arc, + installed: &EffectInstallation<'_>, + policy: &EffectPolicy, + target: &CandidateCredentialTarget, + previous: Option<&ConnectionRecord>, +) -> Value { + use crate::effect::PrerequisiteKind; + use std::sync::Arc; + let mut histories = Vec::new(); + for case in [ + "recorded", + "lost-main-permit", + "missing-child", + "bad-probe", + "stale-child", + "changed-before-admission", + "changed-before-child", + "changed-before-main", + ] { + if matches!( + case, + "missing-child" | "bad-probe" | "stale-child" | "changed-before-child" + ) && approved.prerequisite_plans().expect("plans").is_empty() + { + continue; + } + let directory = tempfile::tempdir().expect("directory"); + let path = std::fs::canonicalize(directory.path()) + .expect("path") + .join("journal"); + let store: Arc = + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("store")); + let attempts = + crate::GatewayAttempts::new(Arc::clone(&store), policy.clone()).expect("attempts"); + let connection = crate::SharedConnection::new( + Arc::clone(&store), + target.record().provider_kind().clone(), + target.record().alias().clone(), + ); + if let Some(previous) = previous { + connection.insert(previous).await.expect("predecessor"); + } + let clock = Arc::new(crate::FixedClock::at(NOW)); + let qualification = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::clone(&clock)), + auths_recipe_qualification::VerifierState::default(), + )); + let configuration = crate::configuration::SharedConfiguration::new( + Arc::clone(&store), + policy + .configuration_key(installed.recipe.namespace()) + .expect("key"), + installed.configuration, + ); + configuration + .initialize(&qualification) + .expect("initialize"); + let validation = || { + crate::entry::EntryValidation::Installed(Box::new(crate::entry::InstalledEntry { + recipe: installed.recipe.clone(), + trust: installed.context.clone(), + observer: None, + policy: policy.clone(), + configuration: configuration.clone(), + connection: crate::entry::EntryConnection::Candidate(Box::new(target.clone())), + connection_key: crate::connection_key( + target.record().provider_kind(), + target.record().alias(), + ), + qualification: Arc::clone(&qualification), + workload: "gateway".to_owned(), + profile: ConnectionProfile::new( + SemanticId::parse("auths.mcp").expect("profile"), + 2, + ) + .expect("profile"), + started: std::time::Instant::now(), + #[cfg(unix)] + commissioning: None, + })) + }; + if case == "changed-before-admission" { + change_predecessor(&connection, target, previous).await; + assert!( + attempts + .claim_candidate(approved, NOW, validation()) + .await + .is_err() + ); + assert!( + attempts + .read_acquisition(approved) + .await + .expect("read") + .is_none() + ); + histories.push(json!({"case": case, "claim": "refused", "no_record": true})); + continue; + } + let crate::AcquisitionClaim::Reserved(reserved) = attempts + .claim_candidate(approved, NOW, validation()) + .await + .expect("native admission") + else { + panic!("reservation"); + }; + let before = reserved.snapshot().expect("snapshot"); + assert_eq!(before.reserved_calls, 1); + assert!(matches!( + attempts + .claim_candidate(approved, NOW, validation()) + .await + .expect("replay"), + crate::AcquisitionClaim::Reserved(_) + )); + assert_eq!( + attempts + .read_acquisition(approved) + .await + .expect("read") + .expect("snapshot"), + before + ); + if case == "changed-before-child" { + change_predecessor(&connection, target, previous).await; + } + let mut children = Vec::new(); + for plan in approved.prerequisite_plans().expect("plans") { + let kind = plan.kind().expect("purpose"); + if case == "missing-child" { + break; + } + let admission = attempts + .claim_prerequisite(approved, kind, NOW, validation()) + .await; + if case == "changed-before-child" { + assert!(admission.is_err()); + break; + } + let crate::AcquisitionClaim::Reserved(child) = admission.expect("child admission") + else { + panic!("child reservation"); + }; + let (granted, permit) = child + .grant_entry(Arc::clone(approved), validation(), NOW) + .await + .expect("native child entry"); + drop(permit); + let (status, body) = match kind { + PrerequisiteKind::Probe if case == "bad-probe" => { + (200, br#"{"livemode":true}"#.as_slice()) + } + PrerequisiteKind::Probe => (200, br#"{"livemode":false}"#.as_slice()), + PrerequisiteKind::Account => (200, br#"{"id":"acct_TESTACCOUNT01"}"#.as_slice()), + PrerequisiteKind::DeniedCapability(_) => (403, b"".as_slice()), + _ => panic!("credential-only checks"), + }; + children.push( + granted + .record_response(status, true, body, NOW) + .await + .expect("record child"), + ); + } + if case == "changed-before-main" { + change_predecessor(&connection, target, previous).await; + } + if case == "stale-child" { + clock.set(NOW + 31); + } + let granted = reserved + .grant_entry( + Arc::clone(approved), + validation(), + if case == "stale-child" { NOW + 31 } else { NOW }, + ) + .await; + if matches!( + case, + "missing-child" + | "bad-probe" + | "stale-child" + | "changed-before-child" + | "changed-before-main" + ) { + assert!(granted.is_err(), "{case}"); + } else { + let (granted, permit) = granted.expect("native main entry"); + let crate::store::AcquisitionRequest::Prerequisite(request) = permit.request() else { + panic!("candidate request"); + }; + assert_eq!( + serde_json::to_value(request).expect("request"), + serde_json::to_value(target.final_request()).expect("compiled request") + ); + drop(permit); + if case == "recorded" { + granted + .record_response(403, true, b"", NOW) + .await + .expect("record primary"); + } else { + drop(granted); + } + } + let snapshot = attempts + .read_acquisition(approved) + .await + .expect("read") + .expect("snapshot"); + let reopened = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen")), + policy.clone(), + ) + .expect("attempts"); + assert_eq!( + reopened + .read_acquisition(approved) + .await + .expect("read reopened") + .expect("snapshot"), + snapshot + ); + if matches!(case, "recorded" | "lost-main-permit") { + assert!(matches!( + reopened + .claim_candidate(approved, NOW, validation()) + .await + .expect("terminal replay"), + crate::AcquisitionClaim::Existing(_) + )); + } + assert_eq!(snapshot.reserved_calls, 1); + assert_eq!(snapshot.reserved_bytes, before.reserved_bytes); + histories.push(json!({"case": case, "snapshot": snapshot, "children": children, "restart_preserves_facts_and_charges": true})); + } + json!({"target": name, "histories": histories}) +} + +async fn change_predecessor( + connection: &crate::SharedConnection, + target: &CandidateCredentialTarget, + previous: Option<&ConnectionRecord>, +) { + if let Some(previous) = previous { + let current = connection.load().await.expect("load").expect("previous"); + let revoked = previous + .transition_state(ConnectionState::Revoked, NOW) + .expect("revoke"); + connection + .replace(¤t, &revoked) + .await + .expect("replace"); + } else { + connection + .insert(target.record()) + .await + .expect("race first publication"); + } } diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 9d53bc35d..5ea21527a 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -576,7 +576,7 @@ async fn exercise_recovery_journal( let mut retained_bytes = 0; for approved in &reads { let snapshot = reopened - .read_recovery(approved) + .read_acquisition(approved) .await .expect("read history") .expect("record"); @@ -660,7 +660,7 @@ async fn exercise_recovery_refinement( let mut available = Vec::new(); for read in reads { if attempts - .read_recovery(read) + .read_acquisition(read) .await .expect("read") .expect("record") diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index ca9ca5f55..9294ae45a 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -239,7 +239,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/11", + "attempt_schema": "auths.gateway-attempt/12", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/effect_read_budget_tests.rs b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs index ea53985c2..3853441a0 100644 --- a/product/runtime/auths-gateway/src/effect_read_budget_tests.rs +++ b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs @@ -177,7 +177,7 @@ pub(super) async fn corpus( compile("budget-read-1", NOW + 2), compile("budget-read-2", NOW + 2), ]; - let compiled = reads[0].recovery_bound().expect("managed budget"); + let compiled = reads[0].acquisition_bound().expect("managed budget"); assert_eq!(compiled.argument, maximum); assert_eq!(compiled.counts.len(), 1); assert_eq!(compiled.sums.len(), usize::from(sum_calls.is_some())); @@ -223,7 +223,7 @@ pub(super) async fn corpus( assert_eq!(refused.len(), 1); let (winner, handle) = winners.pop().expect("winner"); let approved = &reads[winner]; - let compiled = approved.recovery_bound().expect("bound"); + let compiled = approved.acquisition_bound().expect("bound"); let counter_key = crate::GatewayAttemptKey::from_bytes(crate::bounds::count_slot_key( &compiled.counts[0].key, prior_slots, diff --git a/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs index 1f8c89509..98a403765 100644 --- a/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs @@ -305,7 +305,7 @@ pub(super) async fn fixture( ) .expect("attempts"); let snapshot = reopened - .read_recovery(&approved) + .read_acquisition(&approved) .await .expect("history") .expect("parent"); diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 95f6c569b..1f9d95b91 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -57,6 +57,9 @@ pub use commissioning::{ CommissioningSession, CommissioningSessionInputs, commissioning_principal_sha256, }; +#[path = "candidate_runtime.rs"] +mod candidate; + const MAX_PROOF_BYTES: usize = 4 * 1024 * 1024; const MAX_ACTION_BYTES: usize = 64 * 1024; const MAX_CONTEXT_BYTES: usize = 4 * 1024 * 1024; @@ -1340,18 +1343,18 @@ impl GatewayEngine { started: Instant, ) -> Result { // Retained terminal history never needs preparation or custody. - if let Some(snapshot) = self - .attempts - .read_recovery(&approved) - .await - .map_err(|error| match error { - crate::GatewayAttemptError::BindingConflict => { - not_entered("gateway.effect.operation-conflict") - } - _ => GatewaySubmitResult::Indeterminate { - code: "gateway.attempt.state-unavailable".to_owned(), - }, - })? + if let Some(snapshot) = + self.attempts + .read_acquisition(&approved) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => { + not_entered("gateway.effect.operation-conflict") + } + _ => GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }, + })? && snapshot.stage != crate::AcquisitionStage::Reserved { return Ok(snapshot); @@ -1473,7 +1476,7 @@ impl GatewayEngine { approved: &ApprovedEffect, ) -> Result { self.attempts - .read_recovery(approved) + .read_acquisition(approved) .await .ok() .flatten() @@ -1498,45 +1501,8 @@ impl GatewayEngine { { return Err("gateway.credential.mode-guard"); } - for plan in approved - .prerequisite_plans() - .map_err(|_| "gateway.acquisition.binding")? - { - let kind = plan.kind().map_err(|_| "gateway.acquisition.binding")?; - let evidence = - submit::acquire_prerequisite(&self.attempts, &approved, kind, io, &lease) - .await - .ok_or("gateway.entry.prerequisite-evidence")?; - crate::entry::validate_credential_evidence( - &self.recipe, - *approved.connection().account_commitment(), - &evidence, - )?; - } - let validation = io.entry_validation()?; - let now = io.clock().ok_or("gateway.verify.clock-unavailable")?; - let (granted, permit) = reserved - .grant_entry(approved, validation, now) + submit::complete_acquisition(&self.attempts, &self.recipe, approved, reserved, io, &lease) .await - .map_err(|_| "gateway.entry.unavailable")?; - let prepared = io.prepared.get().ok_or("gateway.entry.unprepared")?; - match prepared.transport.acquire(permit, &lease).await { - Some(response) => match io.clock() { - Some(received_at) => { - granted - .record_response( - response.status, - response.version_ok, - &response.body, - received_at, - ) - .await - } - None => granted.record_unknown().await, - }, - None => granted.record_unknown().await, - } - .map_err(|_| "gateway.attempt.state-unavailable") } async fn recovery_compilation_target( @@ -1665,6 +1631,16 @@ impl GatewayEngine { if self.holds(record).await.is_err() { return Err("gateway.connection.credential-generation-missing"); } + Ok(PreparedEntry { + loaded, + transport: self.prepare_transport(&descriptor)?, + }) + } + + fn prepare_transport( + &self, + descriptor: &GatewayConnectionDescriptor, + ) -> Result { #[cfg(feature = "loopback-provider")] if let Some(port) = self.loopback_port { return GatewayHttpTransport::prepare_loopback( @@ -1672,17 +1648,11 @@ impl GatewayEngine { descriptor.credential(), port, ) - .map(|transport| PreparedEntry { - loaded, - transport: transport.with_witness(Arc::clone(&self.execution_witness)), - }) + .map(|transport| transport.with_witness(Arc::clone(&self.execution_witness))) .map_err(|_| "gateway.transport.preparation"); } GatewayHttpTransport::prepare(&self.recipe, descriptor.credential()) - .map(|transport| PreparedEntry { - loaded, - transport: transport.with_witness(Arc::clone(&self.execution_witness)), - }) + .map(|transport| transport.with_witness(Arc::clone(&self.execution_witness))) .map_err(|_| "gateway.transport.preparation") } @@ -1813,7 +1783,9 @@ impl SubmitIo for EngineIo<'_> { .map(|observer| observer.principal().clone()), policy: self.engine.effect_policy.clone(), configuration: self.engine.shared_configuration()?, - connection: prepared.loaded.clone(), + connection: crate::entry::EntryConnection::Installed(Box::new( + prepared.loaded.clone(), + )), connection_key: crate::connection_key( self.engine.connection.provider(), self.engine.connection.alias(), diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index afcd50a53..9766bee7e 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -12,13 +12,58 @@ use std::{ time::{Duration, Instant}, }; +/// Exact published connection or unpublished credential candidate. Both are +/// checked against the one current connection row under the writer fence. +pub(crate) enum EntryConnection { + Installed(Box), + Candidate(Box), +} + +impl EntryConnection { + fn record(&self) -> &auths_connections::ConnectionRecord { + match self { + Self::Installed(loaded) => loaded.record(), + Self::Candidate(target) => target.record(), + } + } + + fn validate( + &self, + approved: &ApprovedEffect, + bytes: Option<&[u8]>, + workload: &str, + profile: &ConnectionProfile, + ) -> bool { + match self { + Self::Installed(loaded) => { + approved.candidate_target().is_none() + && bytes == Some(loaded.private_bytes()) + && crate::connection::authorizes_entry(loaded.record(), workload, profile) + } + Self::Candidate(target) => { + target.predecessor_matches(bytes) + && target.journal_plan().is_ok_and(|plan| { + approved.candidate_plan().is_ok_and(|bound| bound == plan) + }) + && target.record().state() != auths_connections::ConnectionState::Revoked + && target + .record() + .allowed_workloads() + .iter() + .any(|allowed| allowed == workload) + && target.record().allowed_profiles().contains(profile) + } + } + } +} + pub(crate) struct InstalledEntry { pub(crate) recipe: CompiledRecipe, pub(crate) trust: TrustedContext, pub(crate) observer: Option, pub(crate) policy: EffectPolicy, pub(crate) configuration: SharedConfiguration, - pub(crate) connection: LoadedConnection, + pub(crate) connection: EntryConnection, pub(crate) connection_key: GatewayAttemptKey, pub(crate) qualification: Arc, pub(crate) workload: String, @@ -101,10 +146,12 @@ impl EntryValidation { if snapshots.len() != self.dependencies().len() { return Err("gateway.entry.dependencies-unavailable"); } - let connection = snapshots[0] - .as_deref() - .ok_or("gateway.connection.unavailable")?; - if connection != entry.connection.private_bytes() { + if !entry.connection.validate( + approved, + snapshots[0].as_deref(), + &entry.workload, + &entry.profile, + ) { return Err("gateway.connection.changed"); } let configuration = snapshots[1] @@ -121,13 +168,6 @@ impl EntryValidation { { return Err("gateway.entry.deadline"); } - if !crate::connection::authorizes_entry( - entry.connection.record(), - &entry.workload, - &entry.profile, - ) { - return Err("gateway.connection.unavailable"); - } #[cfg(unix)] match &entry.commissioning { Some(authority) => authority.check( diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 0fc1e12e2..5a94685c3 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/11"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/12"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index e2575c409..69876f5b7 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/11"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/12"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 4cfee5775..a8034b4ba 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/11", + "store_schema": "auths.gateway-attempt/12", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 8bbea975e..db3393122 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/11"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/12"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/11", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/12", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 25785f066..fd39ae2bf 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "fb5fa41d4f9f04a16135e177dd86758d1d42d6e1ee776876492c2b42fc7c0415"; + "43c7323e4699c7487e99f39b442f4b064635cbdb7aba619646dd6764adac868c"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 8f4b2cd47..8f5fafac4 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/11`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/12`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/11"; +const SCHEMA: &str = "auths.gateway-attempt/12"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -586,7 +586,7 @@ impl Record { return Err(GatewayAttemptError::Corrupt); } if self.entry.as_ref().is_some_and(|entry| { - entry.schema != "auths.effect-entry/2" + entry.schema != "auths.effect-entry/3" || entry.revision < 2 || entry.revision > self.revision || entry.authorization_started_at < self.evaluated_at @@ -598,6 +598,7 @@ impl Record { || entry .dependencies .iter() + .flatten() .any(|value| digest_bytes(value).is_err()) }) { return Err(GatewayAttemptError::Corrupt); @@ -652,16 +653,20 @@ impl Record { .to_vec(), ) .map_err(|_| GatewayAttemptError::Corrupt)?, - schema: "auths.effect-entry/2".to_owned(), + schema: "auths.effect-entry/3".to_owned(), granted_at: now, effect_id: hex::encode(approved.effect().binding().id().as_bytes()), dependencies: dependencies .iter() .map(|bytes| { - let bytes = bytes.as_deref().ok_or(GatewayAttemptError::Corrupt)?; - auths_codec::domain_commitment("auths.effect-entry-dependency/1", bytes) - .map(|digest| hex::encode(digest.as_bytes())) - .map_err(|_| GatewayAttemptError::Corrupt) + bytes + .as_deref() + .map(|bytes| { + auths_codec::domain_commitment("auths.effect-entry-dependency/1", bytes) + .map(|digest| hex::encode(digest.as_bytes())) + .map_err(|_| GatewayAttemptError::Corrupt) + }) + .transpose() }) .collect::, _>>()?, }); @@ -774,7 +779,8 @@ struct EntryAudit { schema: String, granted_at: u64, effect_id: String, - dependencies: Vec, + // None records an explicitly checked absence, distinct from empty bytes. + dependencies: Vec>, } /// The fields no transition may change, in a fixed order. diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index a1c8c5b46..06b66950b 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -155,7 +155,10 @@ impl JournalProtocol for AcquisitionState { .map_err(|_| GatewayAttemptError::Corrupt)?; let counters = capacity::decode_counters(&record.state.counters)?; if record.state.allocation.is_some() - && matches!(record.state.plan, AcquisitionPlan::Recovery(_)) + && matches!( + record.state.plan, + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + ) { let counts: Vec<_> = counters .iter() @@ -298,7 +301,7 @@ impl Allocation { key: GatewayAttemptKey, slot: u64, ) -> Result { - let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let source = plan.source_id().map_err(|_| GatewayAttemptError::Corrupt)?; let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; if slot >= capacity.attempts { return Err(GatewayAttemptError::InvalidTransition); @@ -306,7 +309,7 @@ impl Allocation { Ok(Self { schema: ALLOCATION_SCHEMA.to_owned(), claim: hex::encode(key.as_bytes()), - source: hex::encode(source.id().as_bytes()), + source: hex::encode(source), count_key: hex::encode(capacity.count_key), bytes_key: hex::encode(capacity.bytes_key), slot, @@ -421,11 +424,11 @@ impl GatewayAttempts { /// # Errors /// Refuses a different protocol, operation binding or installed partition, /// and corrupt/unavailable state. - pub async fn read_recovery( + pub async fn read_acquisition( &self, approved: &ApprovedEffect, ) -> Result, GatewayAttemptError> { - if approved.recovery_target().is_none() + if (approved.recovery_target().is_none() && approved.candidate_target().is_none()) || !self.policy.contains(approved.effect().binding()) { return Err(GatewayAttemptError::BindingConflict); @@ -475,6 +478,21 @@ impl GatewayAttempts { .await } + pub(crate) async fn claim_candidate( + &self, + approved: &Arc, + evaluated_at: u64, + validation: crate::entry::EntryValidation, + ) -> Result { + let plan = AcquisitionPlan::Candidate( + approved + .candidate_plan() + .map_err(|_| GatewayAttemptError::InvalidTransition)?, + ); + self.claim_acquisition(approved, plan, evaluated_at, validation) + .await + } + pub(crate) async fn claim_prerequisite( &self, approved: &Arc, @@ -514,16 +532,30 @@ impl GatewayAttempts { let operation = LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; let key = self.key(&namespace, &operation)?; - let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; - let source_operation = LogicalOperationId::parse(source.journal_identity().1) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let source_key = self.key(&namespace, &source_operation)?; + let (source_kind, source_key) = match &plan { + AcquisitionPlan::Candidate(plan) => ( + GatewayRecordKind::Connection, + plan.source_key() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + _ => { + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let operation = LogicalOperationId::parse(source.journal_identity().1) + .map_err(|_| GatewayAttemptError::Corrupt)?; + ( + GatewayRecordKind::Attempt, + self.key(&namespace, &operation)?, + ) + } + }; let key = match &plan { - AcquisitionPlan::Recovery(_) => key, + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => key, AcquisitionPlan::Prerequisite(plan) => prerequisite_key(source_key, plan.index()), }; let bound = match &plan { - AcquisitionPlan::Recovery(_) => approved.recovery_bound().cloned(), + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => { + approved.acquisition_bound().cloned() + } AcquisitionPlan::Prerequisite(_) => None, }; let expected_plan = plan.clone(); @@ -540,8 +572,8 @@ impl GatewayAttempts { validation, authorization_started_at: evaluated_at, }; - let mut dependencies = vec![(GatewayRecordKind::Attempt, source_key)]; - dependencies.extend(admission.dependencies()); + let mut dependencies = vec![(source_kind, source_key)]; + let native_indices = append_dependencies(&mut dependencies, &admission.dependencies()); let reserved = blocking(move || { if store.load(GatewayRecordKind::Attempt, &key)?.is_some() { return Err(existing_binding(&*store, key, &expected)); @@ -606,7 +638,7 @@ impl GatewayAttempts { &entries, &dependencies, &admission, - source_key, + &native_indices, if refusal.is_none() { candidate.as_ref() } else { @@ -620,7 +652,33 @@ impl GatewayAttempts { GatewayInsert::Exists { index: 0 } => { return Err(existing_binding(&*store, key, &base.binding_canonical)); } - GatewayInsert::Exists { index: 1 } if refusal.is_none() => slot += 1, + GatewayInsert::Exists { index: 1 } if refusal.is_none() => { + // Lifetime allocations are append-only. A credential + // cannot restart its byte ceiling through another recipe + // proposal while retaining the same custody identity. + let bytes = store + .load( + GatewayRecordKind::EffectAllocation, + &allocation_key(&capacity, slot), + )? + .ok_or(GatewayAttemptError::Corrupt)?; + let occupied: Allocation = serde_json::from_slice(&bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let expected = Allocation::new(&record.state.plan, key, slot)?; + if canonical(&occupied)? != bytes + || digest_bytes(&occupied.claim).is_err() + || occupied.schema != expected.schema + || occupied.source != expected.source + || occupied.count_key != expected.count_key + || occupied.bytes_key != expected.bytes_key + || occupied.slot != slot + || occupied.calls != 1 + || occupied.bytes != expected.bytes + { + return Err(GatewayAttemptError::BindingConflict); + } + slot += 1; + } GatewayInsert::Exists { index } if refusal.is_none() => { candidate .as_mut() @@ -699,6 +757,20 @@ impl ReservedAcquisition { AcquisitionRequest::Recovery(target.closed_request().clone()), ) } + AcquisitionPlan::Candidate(_) => ( + AcquisitionPlan::Candidate( + approved + .candidate_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Prerequisite( + approved + .candidate_target() + .ok_or(GatewayAttemptError::InvalidTransition)? + .final_request() + .clone(), + ), + ), AcquisitionPlan::Prerequisite(plan) => { let kind = plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?; let (plan, read) = approved @@ -721,18 +793,25 @@ impl ReservedAcquisition { let dependencies = validation.dependencies(); let mut keys = vec![ (GatewayRecordKind::Attempt, attempt.key), - (GatewayRecordKind::Attempt, self.source_key), + ( + if matches!(plan, AcquisitionPlan::Candidate(_)) { + GatewayRecordKind::Connection + } else { + GatewayRecordKind::Attempt + }, + self.source_key, + ), ( GatewayRecordKind::EffectAllocation, allocation_key(&capacity, slot), ), ]; - keys.extend_from_slice(&dependencies); + let native_indices = append_dependencies(&mut keys, &dependencies); let native_end = keys.len(); keys.extend(capacity::dependencies(&attempt.record.state.counters)?); let counter_end = keys.len(); let prerequisites = match &plan { - AcquisitionPlan::Recovery(_) => approved + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => approved .prerequisite_plans() .map_err(|_| GatewayAttemptError::Corrupt)?, AcquisitionPlan::Prerequisite(_) => Vec::new(), @@ -762,11 +841,8 @@ impl ReservedAcquisition { { return Err(GatewayAttemptError::BindingConflict); } - let source = snapshots[1] - .as_deref() - .ok_or(GatewayAttemptError::Corrupt)?; let (source_matches, _) = - eligible_source(&plan, source, self.source_key, attempt.key)?; + eligible_source(&plan, snapshots[1].as_deref(), self.source_key, attempt.key)?; if !source_matches || snapshots[2].as_deref() != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) @@ -776,12 +852,14 @@ impl ReservedAcquisition { let now = validation .validate( &approved, - &snapshots[3..native_end], + &select_snapshots(snapshots, &native_indices)?, authorization_started_at, ) .map_err(|_| GatewayAttemptError::InvalidTransition)?; let bound = match &plan { - AcquisitionPlan::Recovery(_) => approved.recovery_bound(), + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => { + approved.acquisition_bound() + } AcquisitionPlan::Prerequisite(_) => None, }; capacity::validate_reservations( @@ -800,7 +878,10 @@ impl ReservedAcquisition { &snapshots[counter_end..], now, )?; - if matches!(plan, AcquisitionPlan::Recovery(_)) { + if matches!( + plan, + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + ) { validation .validate_prerequisite_evidence( &approved, @@ -960,13 +1041,16 @@ pub(super) fn validate_prerequisites( fn eligible_source( plan: &AcquisitionPlan, - source_bytes: &[u8], + source_bytes: Option<&[u8]>, source_key: GatewayAttemptKey, key: GatewayAttemptKey, ) -> Result<(bool, u64), GatewayAttemptError> { match plan { + AcquisitionPlan::Candidate(plan) => plan + .source_matches(source_bytes) + .map_err(|_| GatewayAttemptError::Corrupt), AcquisitionPlan::Recovery(plan) => { - let source = decode(source_bytes)?; + let source = decode(source_bytes.ok_or(GatewayAttemptError::Corrupt)?)?; Ok(( plan.matches_target(&source.recovery_target()?) .map_err(|_| GatewayAttemptError::Corrupt)?, @@ -974,6 +1058,7 @@ fn eligible_source( )) } AcquisitionPlan::Prerequisite(plan) => { + let source_bytes = source_bytes.ok_or(GatewayAttemptError::Corrupt)?; let expected = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; let (binding, reserved, entered, evaluated_at) = if expected.is_mutation() { let source = decode(source_bytes)?; @@ -987,8 +1072,10 @@ fn eligible_source( let source: Record = decode_as(source_bytes)?; ( source.validate_header()?, - matches!(source.state.plan, AcquisitionPlan::Recovery(_)) - && matches!(source.state.phase, AcquisitionPhase::Reserved), + matches!( + source.state.plan, + AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + ) && matches!(source.state.phase, AcquisitionPhase::Reserved), source.entry.is_some(), source.evaluated_at, ) @@ -1010,10 +1097,11 @@ fn insert_acquisition( entries: &[GatewayRecordEntry], dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], admission: &Admission, - source_key: GatewayAttemptKey, + native_indices: &[usize], candidate: Option<&capacity::CapacityCandidate<'_>>, ) -> Result { let key = entries.first().ok_or(GatewayAttemptError::Corrupt)?.key; + let source_key = dependencies.first().ok_or(GatewayAttemptError::Corrupt)?.1; let native_end = dependencies.len(); let mut dependencies = dependencies.to_vec(); if let Some(candidate) = candidate { @@ -1023,14 +1111,12 @@ fn insert_acquisition( if snapshots.len() != dependencies.len() || snapshots.is_empty() { return Err(GatewayAttemptError::Corrupt); } - let source = snapshots[0] - .as_deref() - .ok_or(GatewayAttemptError::Corrupt)?; - let (eligible, source_at) = eligible_source(&record.state.plan, source, source_key, key)?; + let (eligible, source_at) = + eligible_source(&record.state.plan, snapshots[0].as_deref(), source_key, key)?; if !eligible { return Err(GatewayAttemptError::InvalidTransition); } - admission.stamp(record, &snapshots[1..native_end])?; + admission.stamp(record, &select_snapshots(snapshots, native_indices)?)?; if let Some(candidate) = candidate { candidate.validate_predecessors(&snapshots[native_end..])?; } @@ -1040,3 +1126,38 @@ fn insert_acquisition( encode(record) }) } + +/// A source connection can also be a native dependency. Read it once under the +/// fence and retain each consumer's index; never drop either validation. +fn append_dependencies( + keys: &mut Vec<(GatewayRecordKind, GatewayAttemptKey)>, + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], +) -> Vec { + dependencies + .iter() + .map(|dependency| { + if let Some(index) = keys.iter().position(|key| key == dependency) { + index + } else { + let index = keys.len(); + keys.push(*dependency); + index + } + }) + .collect() +} + +fn select_snapshots( + snapshots: &[Option>], + indices: &[usize], +) -> Result>>, GatewayAttemptError> { + indices + .iter() + .map(|index| { + snapshots + .get(*index) + .cloned() + .ok_or(GatewayAttemptError::Corrupt) + }) + .collect() +} diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 8c30a84db..9ab7068fc 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -115,32 +115,70 @@ pub(crate) trait SubmitIo { ) -> Option; } +/// Narrow port for the common prerequisite acquisition sequence. It adds no +/// authorization or transition semantics; the journal remains the sole owner. +pub(crate) trait AcquisitionIo { + type Lease; + fn acquisition_enter(&self); + fn acquisition_leave(&self); + fn acquisition_clock(&self) -> Option; + fn acquisition_validation(&self) -> Result; + async fn acquisition_send( + &self, + lease: &Self::Lease, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option; +} + +impl AcquisitionIo for T { + type Lease = T::Lease; + fn acquisition_enter(&self) { + self.enter(); + } + fn acquisition_leave(&self) { + self.leave(); + } + fn acquisition_clock(&self) -> Option { + self.clock() + } + fn acquisition_validation(&self) -> Result { + self.entry_validation() + } + async fn acquisition_send( + &self, + lease: &Self::Lease, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + self.acquire(lease, permit).await + } +} + /// Acquire one compiler-selected prerequisite through the shared journal and /// consumed permit. Both mutation and recovery use this transport sequence. -pub(crate) async fn acquire_prerequisite( +pub(crate) async fn acquire_prerequisite( attempts: &GatewayAttempts, approved: &std::sync::Arc, kind: PrerequisiteKind, io: &I, lease: &I::Lease, ) -> Option { - let started = io.clock()?; - let validation = io.entry_validation().ok()?; + let started = io.acquisition_clock()?; + let validation = io.acquisition_validation().ok()?; match attempts .claim_prerequisite(approved, kind, started, validation) .await .ok()? { crate::AcquisitionClaim::Reserved(reserved) => { - let validation = io.entry_validation().ok()?; - let entry_started = io.clock()?; + let validation = io.acquisition_validation().ok()?; + let entry_started = io.acquisition_clock()?; let (granted, permit) = reserved .grant_entry(std::sync::Arc::clone(approved), validation, entry_started) .await .ok()?; - match io.acquire(lease, permit).await { + match io.acquisition_send(lease, permit).await { Some(response) => { - let received_at = io.clock()?; + let received_at = io.acquisition_clock()?; granted .record_response( response.status, @@ -161,11 +199,61 @@ pub(crate) async fn acquire_prerequisite( } // Only acknowledged, retained evidence is usable. Replays keep the // original receipt time and cannot create another provider invocation. - let now = io.clock()?; + let now = io.acquisition_clock()?; let recorded = attempts.read_prerequisite(approved, kind, now).await.ok()?; (recorded.observed_at <= recorded.received_at && recorded.received_at <= now) .then_some(recorded) } +/// Runs the same ordered credential prerequisites and primary read for recovery +/// and staged candidates. Only durably retained responses feed native predicates. +pub(crate) async fn complete_acquisition( + attempts: &GatewayAttempts, + recipe: &CompiledRecipe, + approved: std::sync::Arc, + reserved: crate::ReservedAcquisition, + io: &I, + lease: &I::Lease, +) -> Result { + for plan in approved + .prerequisite_plans() + .map_err(|_| "gateway.acquisition.binding")? + { + let kind = plan.kind().map_err(|_| "gateway.acquisition.binding")?; + let evidence = acquire_prerequisite(attempts, &approved, kind, io, lease) + .await + .ok_or("gateway.entry.prerequisite-evidence")?; + crate::entry::validate_credential_evidence( + recipe, + *approved.connection().account_commitment(), + &evidence, + )?; + } + let validation = io.acquisition_validation()?; + let now = io + .acquisition_clock() + .ok_or("gateway.verify.clock-unavailable")?; + let (granted, permit) = reserved + .grant_entry(approved, validation, now) + .await + .map_err(|_| "gateway.entry.unavailable")?; + match io.acquisition_send(lease, permit).await { + Some(response) => match io.acquisition_clock() { + Some(received_at) => { + granted + .record_response( + response.status, + response.version_ok, + &response.body, + received_at, + ) + .await + } + None => granted.record_unknown().await, + }, + None => granted.record_unknown().await, + } + .map_err(|_| "gateway.attempt.state-unavailable") +} /// The installation one submission runs against. pub(crate) struct SubmitContext<'a> { @@ -265,20 +353,20 @@ pub(crate) fn denied_result(response: Option<&ProviderResponse>, refused: &[u16] /// Ends the in-flight count of one entry when dropped, so a count taken /// before the final reload is released on every path. -pub(crate) struct InFlight<'a, I: SubmitIo> { +pub(crate) struct InFlight<'a, I: AcquisitionIo> { io: &'a I, } -impl<'a, I: SubmitIo> InFlight<'a, I> { +impl<'a, I: AcquisitionIo> InFlight<'a, I> { pub(crate) fn enter(io: &'a I) -> Self { - io.enter(); + io.acquisition_enter(); Self { io } } } -impl Drop for InFlight<'_, I> { +impl Drop for InFlight<'_, I> { fn drop(&mut self) { - self.io.leave(); + self.io.acquisition_leave(); } } From 03ca6b0d951a0d40611e7e10fda1df72f672c1f5 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 10:53:55 +0000 Subject: [PATCH 039/136] feat(gateway): fence candidate credential publication --- .../fixtures/gateway/candidate-journal.json | 2572 +++++++++++++++-- compliance.toml | 3 + ...017-bound-effect-and-recovery-ownership.md | 20 + docs/plans/0074-implementation-status.md | 28 +- .../0009-bound-effect-and-recovery.md | 18 + ...ound-effects-and-recovery-state-machine.md | 15 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/candidate_runtime.rs | 157 +- .../auths-gateway/src/effect/candidate.rs | 8 + .../auths-gateway/src/effect/prerequisite.rs | 2 +- .../src/effect_candidate_tests.rs | 146 +- product/runtime/auths-gateway/src/entry.rs | 37 + product/runtime/auths-gateway/src/lib.rs | 19 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 5 +- .../auths-gateway/src/store/acquisition.rs | 12 +- .../src/store/acquisition/candidate.rs | 169 ++ 17 files changed, 2942 insertions(+), 273 deletions(-) create mode 100644 product/runtime/auths-gateway/src/store/acquisition/candidate.rs diff --git a/bindings/fixtures/gateway/candidate-journal.json b/bindings/fixtures/gateway/candidate-journal.json index 75bb1608a..8484e2cd0 100644 --- a/bindings/fixtures/gateway/candidate-journal.json +++ b/bindings/fixtures/gateway/candidate-journal.json @@ -1,6 +1,6 @@ { "schema": "auths.candidate-journal-fixture/1", - "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; no installed provider, publication or PostgreSQL claim", + "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; includes fenced operator publication; no installed provider, custody or PostgreSQL claim", "cases": [ { "target": "first-install", @@ -53,6 +53,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -103,6 +104,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -119,6 +121,7 @@ "response_version_ok": null }, "children": [], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -169,6 +172,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -219,6 +223,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -240,6 +245,7 @@ "response_version_ok": null }, "children": [], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -290,15 +296,11 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true - } - ] - }, - { - "target": "rotation", - "histories": [ + }, { - "case": "recorded", + "case": "publish-success", "snapshot": { "revision": 3, "stage": "response-recorded", @@ -345,20 +347,25 @@ "response_version_ok": true } ], + "publication": { + "result": "published", + "replay": "already-current", + "exact_candidate": true + }, "restart_preserves_facts_and_charges": true }, { - "case": "lost-main-permit", + "case": "publish-bad-final", "snapshot": { - "revision": 2, - "stage": "unknown", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 0, + "response_version_ok": true }, "children": [ { @@ -395,86 +402,24 @@ "response_version_ok": true } ], - "restart_preserves_facts_and_charges": true - }, - { - "case": "missing-child", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null - }, - "children": [], - "restart_preserves_facts_and_charges": true - }, - { - "case": "bad-probe", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "publication": { + "result": "refused", + "connection_unchanged": true }, - "children": [ - { - "revision": 3, - "stage": "response-recorded", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": 200, - "response_bytes": 17, - "response_version_ok": true - }, - { - "revision": 3, - "stage": "response-recorded", - "reserved_calls": 1, - "reserved_bytes": 65536, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": 200, - "response_bytes": 27, - "response_version_ok": true - }, - { - "revision": 3, - "stage": "response-recorded", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": 403, - "response_bytes": 0, - "response_version_ok": true - } - ], "restart_preserves_facts_and_charges": true }, { - "case": "stale-child", + "case": "publish-bad-version", "snapshot": { - "revision": 1, - "stage": "reserved", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 403, + "response_bytes": 0, + "response_version_ok": false }, "children": [ { @@ -511,34 +456,17 @@ "response_version_ok": true } ], - "restart_preserves_facts_and_charges": true - }, - { - "case": "changed-before-admission", - "claim": "refused", - "no_record": true - }, - { - "case": "changed-before-child", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "publication": { + "result": "refused", + "connection_unchanged": true }, - "children": [], "restart_preserves_facts_and_charges": true }, { - "case": "changed-before-main", + "case": "publish-unknown", "snapshot": { - "revision": 1, - "stage": "reserved", + "revision": 2, + "stage": "unknown", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, @@ -582,15 +510,14 @@ "response_version_ok": true } ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, "restart_preserves_facts_and_charges": true - } - ] - }, - { - "target": "disabled-rotation", - "histories": [ + }, { - "case": "recorded", + "case": "publish-stale-primary", "snapshot": { "revision": 3, "stage": "response-recorded", @@ -637,20 +564,24 @@ "response_version_ok": true } ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, "restart_preserves_facts_and_charges": true }, { - "case": "lost-main-permit", + "case": "publish-stale-child", "snapshot": { - "revision": 2, - "stage": "unknown", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true }, "children": [ { @@ -687,36 +618,24 @@ "response_version_ok": true } ], - "restart_preserves_facts_and_charges": true - }, - { - "case": "missing-child", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "publication": { + "result": "refused", + "connection_unchanged": true }, - "children": [], "restart_preserves_facts_and_charges": true }, { - "case": "bad-probe", + "case": "publish-expired-approval", "snapshot": { - "revision": 1, - "stage": "reserved", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true }, "children": [ { @@ -727,7 +646,7 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 17, + "response_bytes": 18, "response_version_ok": true }, { @@ -753,20 +672,24 @@ "response_version_ok": true } ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, "restart_preserves_facts_and_charges": true }, { - "case": "stale-child", + "case": "publish-changed-configuration", "snapshot": { - "revision": 1, - "stage": "reserved", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true }, "children": [ { @@ -803,41 +726,24 @@ "response_version_ok": true } ], - "restart_preserves_facts_and_charges": true - }, - { - "case": "changed-before-admission", - "claim": "refused", - "no_record": true - }, - { - "case": "changed-before-child", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 16384, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "publication": { + "result": "refused", + "connection_unchanged": true }, - "children": [], "restart_preserves_facts_and_charges": true }, { - "case": "changed-before-main", + "case": "publish-changed-predecessor", "snapshot": { - "revision": 1, - "stage": "reserved", + "revision": 3, + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true }, "children": [ { @@ -874,12 +780,16 @@ "response_version_ok": true } ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, "restart_preserves_facts_and_charges": true } ] }, { - "target": "head-final", + "target": "rotation", "histories": [ { "case": "recorded", @@ -929,6 +839,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -979,6 +890,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -995,6 +907,7 @@ "response_version_ok": null }, "children": [], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -1045,6 +958,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -1095,6 +1009,7 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -1116,6 +1031,7 @@ "response_version_ok": null }, "children": [], + "publication": null, "restart_preserves_facts_and_charges": true }, { @@ -1166,64 +1082,2288 @@ "response_version_ok": true } ], + "publication": null, "restart_preserves_facts_and_charges": true - } - ] - }, - { - "target": "probe-only", - "histories": [ + }, { - "case": "recorded", + "case": "publish-success", "snapshot": { "revision": 3, "stage": "response-recorded", "reserved_calls": 1, - "reserved_bytes": 8192, + "reserved_bytes": 16384, "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 403, "response_bytes": 0, "response_version_ok": true }, - "children": [], - "restart_preserves_facts_and_charges": true - }, - { - "case": "lost-main-permit", - "snapshot": { - "revision": 2, - "stage": "unknown", - "reserved_calls": 1, - "reserved_bytes": 8192, - "policy_count_counters": 0, - "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null - }, - "children": [], - "restart_preserves_facts_and_charges": true - }, - { - "case": "changed-before-admission", - "claim": "refused", - "no_record": true - }, - { - "case": "changed-before-main", - "snapshot": { - "revision": 1, - "stage": "reserved", - "reserved_calls": 1, - "reserved_bytes": 8192, - "policy_count_counters": 0, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "published", + "replay": "already-current", + "exact_candidate": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-final", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-version", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": false + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-unknown", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-primary", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-child", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-expired-approval", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-configuration", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-predecessor", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "disabled-rotation", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-success", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "published", + "replay": "already-current", + "exact_candidate": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-final", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-version", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": false + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-unknown", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-primary", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-child", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-expired-approval", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-configuration", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-predecessor", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "head-final", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "missing-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "bad-probe", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "stale-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-child", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-success", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "published", + "replay": "already-current", + "exact_candidate": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-final", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-version", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": false + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-unknown", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-primary", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-child", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-expired-approval", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-configuration", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-predecessor", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + }, + "children": [ + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 65536, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 27, + "response_version_ok": true + }, + { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 0, + "response_version_ok": true + } + ], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + } + ] + }, + { + "target": "probe-only", + "histories": [ + { + "case": "recorded", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "lost-main-permit", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "changed-before-admission", + "claim": "refused", + "no_record": true + }, + { + "case": "changed-before-main", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "children": [], + "publication": null, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-success", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "published", + "replay": "already-current", + "exact_candidate": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-final", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 17, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-bad-version", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": false + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-unknown", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": null, "response_bytes": null, "response_version_ok": null }, "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-stale-primary", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-expired-approval", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-configuration", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, + "restart_preserves_facts_and_charges": true + }, + { + "case": "publish-changed-predecessor", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 8192, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 18, + "response_version_ok": true + }, + "children": [], + "publication": { + "result": "refused", + "connection_unchanged": true + }, "restart_preserves_facts_and_charges": true } ] diff --git a/compliance.toml b/compliance.toml index 2c59972f9..fb2738d15 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-publication = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", +] candidate-acquisition = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 1efaa2ff5..6c35dbd8a 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -684,3 +684,23 @@ use the same helper. `acquire_candidate_credential` leases only the exact alread staged candidate and returns redacted acquisition facts. It does not publish the credential. CLI staging, final-purpose validation, safely fenced publication and removal of the old onboarding/rotation read routes remain required. + + +## Candidate credential publication + +Publication uses the existing insert/replace writer fence over the connection, +root and child acquisition records/allocations and native dependencies. It is an +explicit trusted operator action, with no application route and no new lifecycle +state. The primary response now receives its actual recipe purpose check, just +like each retained child. All timestamps remain original; publication cannot +renew evidence or spend capacity again. Missing/unknown, bad and stale evidence, +changed configuration and changed predecessor refuse the write. + +The runtime verifies exact staged custody, invokes this fence and reloads the +published connection through the generation-floor owner before scheduling +superseded credential retirement. Independent custody availability is not part +of the store's atomicity guarantee. Every later lease still checks the exact +credential binding. `AlreadyCurrent` is an exact-state observation for an +explicit retry, including lost acknowledgement; it makes no causal claim and +issues no capability. Staging/CLI cutover and installed custody/transport fault +coverage remain separate required work. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index cbf7947bd..d65f4e657 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -854,6 +854,32 @@ closure regeneration passed after that correction (one artifact-generation test) Python-owner removal, authenticated UI/bindings and full acceptance evidence remain open. No A01–A22 criterion is fully closed. +## Candidate publication checkpoint + +- The operator API publishes exact staged candidate records through the existing + store writer fence. It validates the root/child records and allocations, fresh + native authority/approval/configuration/qualification, actual final and child + credential predicates, and predecessor/absence before connection insertion or + replacement. No acquisition state, charge or evidence timestamp changes. +- Exact already-current state has a separate result with no causal attribution, + capability or evidence refresh. The runtime checks exact custody beforehand + and reloads through the generation-floor owner before scheduling retirement. + Independent custody availability is not claimed atomic with shared state. + Publication errors do not claim the connection write definitely did not occur. +- Candidate artifact construction passed on `57332c58` plus this source: 80 + native file-journal histories, including publication success/replay and + refusals for bad final purpose/version, unknown primary, stale primary/child, + expired approval, changed configuration and changed predecessor. Response + bodies, clock and installed configuration remain synthetic. This is not + installed provider/custody, process-fault or PostgreSQL evidence. +- Code inventory and final semantic-closure artifact construction also passed. + No broad local gate was run. The publication API is an operator method only; + no application framing or existing provider request identity changes. +- Durable staging/proposal CLI and removal of raw onboarding/rotation paths + remain next. General acquisition/disclosure/ACK, safe recovery replacement, + Python-owner removal, authenticated UI/bindings and full acceptance evidence + remain open. No A01–A22 criterion is closed and no hosted CI was observed. + ## Phase gates | Phase | State | Outstanding gate | @@ -861,7 +887,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation staging/publication (candidate acquisition API wired), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation staging and CLI cutover (candidate acquisition/publication APIs wired), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 751375de8..5afcdd4e6 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -427,3 +427,21 @@ permits and restart. Cross-proposal capacity checks preserve the credential's first byte ceiling. Configuration and time are test-controlled; provider bodies are synthetic. These artifacts do not establish installed provider execution, PostgreSQL conformance, final-check acceptance or credential publication. + + +### Retained candidate evidence at publication + +The candidate publication change composes the existing connection insert/replace +fence, typed acquisition evidence and concrete credential-purpose predicates. +It adds no acquisition phase, callback-based lifecycle or provider-specific +publication policy. First install checks absence; rotation checks exact previous +bytes and preserves administrative state. The common native fence validates the +same proof, approval, configuration and qualification used at entry, while +retained primary/child grants bound evidence age. Exact already-current state is +reported without asserting fresh evidence or attributing publication to a retry. + +The native file corpus adds successful publication/replay and refusals for bad +final purpose/version, unknown primary, stale primary/children, expired approval, +changed configuration and changed predecessor. Acquisition snapshots and charges +remain unchanged across publication. This evidence remains narrower than process +faults, installed custody/provider execution or PostgreSQL conformance. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 0b67d2154..ab2321922 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -274,6 +274,21 @@ change once its credential identity has an allocation. Candidate acquisition returns retained response/unknown facts; publication remains a separate operator action requiring the final purpose and complete fresh retained evidence. +The trusted operator publication API fences the exact candidate root, its +permanent allocation, every child response/allocation, native configuration +and expected predecessor (or absence) with the connection replacement/insertion. +It re-evaluates every actual check purpose, including the primary response, +and measures evidence age from the retained grant time. Missing, unknown, +failed or stale evidence cannot publish. Publication creates no transport permit, +changes no acquisition fact and resets no charge. `Published` means the store +acknowledged this transition. `AlreadyCurrent` means only that exact candidate +bytes were observed as current; it does not attribute causation or refresh +checks. This distinction permits explicit observation after acknowledgement +loss. The operator channel supplies publication authority separately from native +read proof/approval. Custody is checked for the exact staged reference before +publication; independently stored custody and connection state are not claimed +to be one atomic transaction. + The concrete journal encoding is `auths.gateway-attempt/12`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index b066da97b..4de7c30a0 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"cf851a1d57396cfc3e86397eb6c961f503cb32f768583315582b6f70e06b65d0"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"f4d74fe9b79d2f25aa20847b5a72ee72d9895609b9326fe62b6829c43a5a1259"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"dfdc1cda5475713553f4ad55e992affa459995c9b487534c899aa4a8e339d3ca"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"0fc4c365b10bc12a44f44fc0b2dc9b05616a0a48caa6929a387df7ebb85d6a05"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"dd793454291d5858d0787ca09065595af235a5eae14dda3e2de6fa7c07482cb7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"7d222a411766777c945a43cafae70f1e3b3c20be539140c4fbf6c935aaa4b23d"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a6ab82620c23d28e7eebe1e87e0df308482d1e2a14fd5e362cc1b7f9e3453f1a"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"941d59ed31880b27cb02e72952b54541df5a46592596cc071b56c72ae829cd43"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"0bdc2b051ba4cef632ea92ebf490986ef741e3a40ed47fc62e6c78adfe8b7ccd"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"6558cda21bdf40cf779f0d6f4195a503ed082b2823128b451a0b3dc7d0ead7b5"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"123cf88f35ddc3395a18c7598f46c7fca3fb3a4dd45d9d9f164c587d69f67940"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"732ce474c8662fe2b150e90d2a142a828a259b62d601eeacf5ed658a2715232d"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"dd793454291d5858d0787ca09065595af235a5eae14dda3e2de6fa7c07482cb7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index 6630d76d0..543326551 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -1,5 +1,5 @@ //! Candidate checks use the shared acquisition owner and exact staged custody. -//! A response remains evidence; this module does not publish a connection. +//! Publication is a separate operator action over complete retained evidence. use super::*; use crate::effect::{BoundEffect, CandidateCredentialTarget, compile_candidate_credential}; @@ -22,6 +22,15 @@ impl GatewayEngine { self.check_candidate_predecessor(target) .await .map_err(not_entered)?; + self.compile_candidate_target(target, proof, action) + } + + fn compile_candidate_target( + &self, + target: &CandidateCredentialTarget, + proof: &[u8], + action: &[u8], + ) -> Result { let now = self .qualification .effect_time() @@ -46,6 +55,21 @@ impl GatewayEngine { target: &CandidateCredentialTarget, ) -> Result<(), &'static str> { self.check_effect_configuration().await?; + self.check_candidate_location(target)?; + let current = self.connection.load().await.map_err(|error| match error { + SharedConnectionError::Rollback => "gateway.connection.restore-rollback", + _ => "gateway.connection.unavailable", + })?; + if !target.predecessor_matches(current.as_ref().map(LoadedConnection::private_bytes)) { + return Err("gateway.connection.changed"); + } + Ok(()) + } + + fn check_candidate_location( + &self, + target: &CandidateCredentialTarget, + ) -> Result<(), &'static str> { let record = target.record(); if record.provider_kind() != self.connection.provider() || record.alias() != self.connection.alias() @@ -55,14 +79,111 @@ impl GatewayEngine { { return Err("gateway.connection.unavailable"); } - let current = self.connection.load().await.map_err(|error| match error { - SharedConnectionError::Rollback => "gateway.connection.restore-rollback", - _ => "gateway.connection.unavailable", - })?; - if !target.predecessor_matches(current.as_ref().map(LoadedConnection::private_bytes)) { + Ok(()) + } + + /// Publishes an exact staged credential using complete, fresh journaled + /// checks. Only the trusted operator service may call this method; a read + /// proof and approval do not grant connection administration authority. + /// Native authority/configuration, retained check purposes and exact + /// predecessor/absence are checked together under the store writer fence. + /// No provider request or new allocation occurs. `AlreadyCurrent` reports + /// exact state without attributing it to this invocation. + /// + /// # Errors + /// Refuses missing custody, incomplete/failed/stale checks, invalid native + /// authority or approval, and changed predecessor/configuration. A failed + /// durability acknowledgement cannot report publication; retry observes + /// current state and cannot recreate transport permits. Errors report + /// unavailability, never that a connection write definitely did not occur. + pub async fn publish_candidate_credential( + &self, + target: &CandidateCredentialTarget, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + self.check_effect_configuration().await?; + self.check_candidate_location(target)?; + let current = self + .connection + .load() + .await + .map_err(|_| "gateway.connection.unavailable")?; + if !target.predecessor_matches(current.as_ref().map(LoadedConnection::private_bytes)) + && !current + .as_ref() + .is_some_and(|loaded| loaded.record() == target.record()) + { return Err("gateway.connection.changed"); } - Ok(()) + let effect = self + .compile_candidate_target(target, proof, action) + .map_err(|_| "gateway.admin.transition-unavailable")?; + let now = self + .qualification + .effect_time() + .ok_or("gateway.verify.clock-unavailable")?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| "gateway.effect.approval")?, + ); + self.holds(target.record()) + .await + .map_err(|_| "gateway.credential.unavailable")?; + let disposition = self + .attempts + .publish_candidate(approved, self.candidate_validation(target, started)?, now) + .await + .map_err(|_| "gateway.admin.transition-unavailable")?; + // Loading advances the independently retained generation floor. A + // concurrent later update is not represented as this candidate. + let current = self + .connection + .load() + .await + .map_err(|_| "gateway.connection.unavailable")? + .ok_or("gateway.connection.unavailable")?; + if current.record() != target.record() { + return Err("gateway.connection.changed"); + } + self.schedule_retirement( + target.record(), + target + .previous() + .map(ConnectionRecord::credential_generation), + ); + self.delete_superseded_credentials(target.record()).await; + Ok(disposition) + } + + fn candidate_validation( + &self, + target: &CandidateCredentialTarget, + started: Instant, + ) -> Result { + Ok(crate::entry::EntryValidation::Installed(Box::new( + crate::entry::InstalledEntry { + recipe: self.recipe.clone(), + trust: self.trusted_context.clone(), + observer: None, + policy: self.effect_policy.clone(), + configuration: self.shared_configuration()?, + connection: crate::entry::EntryConnection::Candidate(Box::new(target.clone())), + connection_key: crate::connection_key( + self.connection.provider(), + self.connection.alias(), + ), + qualification: Arc::clone(&self.qualification), + workload: self.workload_id.clone(), + profile: self.profile.clone(), + started, + #[cfg(unix)] + commissioning: None, + }, + ))) } /// Durably admits and executes native-approved candidate checks using the @@ -183,27 +304,9 @@ impl AcquisitionIo for CandidateIo<'_> { self.engine.qualification.effect_time() } fn acquisition_validation(&self) -> Result { - Ok(crate::entry::EntryValidation::Installed(Box::new( - crate::entry::InstalledEntry { - recipe: self.engine.recipe.clone(), - trust: self.engine.trusted_context.clone(), - observer: None, - policy: self.engine.effect_policy.clone(), - configuration: self.engine.shared_configuration()?, - connection: crate::entry::EntryConnection::Candidate(Box::new(self.target.clone())), - connection_key: crate::connection_key( - self.engine.connection.provider(), - self.engine.connection.alias(), - ), - qualification: Arc::clone(&self.engine.qualification), - workload: self.engine.workload_id.clone(), - profile: self.engine.profile.clone(), - started: self.started, - #[cfg(unix)] - commissioning: None, - }, - ))) + self.engine.candidate_validation(self.target, self.started) } + async fn acquisition_send( &self, lease: &Self::Lease, diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs index a4b210357..caec39b88 100644 --- a/product/runtime/auths-gateway/src/effect/candidate.rs +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -101,6 +101,14 @@ impl CandidateCredentialTarget { } } + pub(crate) fn previous(&self) -> Option<&ConnectionRecord> { + self.previous.as_ref() + } + + pub(crate) fn final_kind(&self) -> PrerequisiteKind { + self.last.purpose.kind() + } + pub(crate) fn final_request(&self) -> &ClosedPrerequisiteRead { &self.last.request } diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index e1ac9a2ae..a6a9925c7 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -297,7 +297,7 @@ pub(crate) enum PrerequisiteKind { } impl Purpose { - const fn kind(&self) -> PrerequisiteKind { + pub(super) const fn kind(&self) -> PrerequisiteKind { match self { Self::Probe { .. } => PrerequisiteKind::Probe, Self::Account { .. } => PrerequisiteKind::Account, diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index 5b61f0a96..db74b8d72 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -1,4 +1,4 @@ -//! Native candidate compilation corpus; no candidate publication/entry claim. +//! Native candidate compilation, acquisition and fenced publication corpus. use super::*; use crate::effect::{ CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, @@ -505,7 +505,7 @@ async fn native_candidate_compilation_fixture_is_current() { std::fs::write(&path, &fixture).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), fixture); - let fixture = serde_json::to_vec_pretty(&json!({"schema": "auths.candidate-journal-fixture/1", "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; no installed provider, publication or PostgreSQL claim", "cases": journal_cases, "cross_proposal_capacity": capacity_cases})).expect("fixture"); + let fixture = serde_json::to_vec_pretty(&json!({"schema": "auths.candidate-journal-fixture/1", "scope": "native signed authority and actual fenced entry predicates with real file journal; synthetic configuration, clock and provider bodies; includes fenced operator publication; no installed provider, custody or PostgreSQL claim", "cases": journal_cases, "cross_proposal_capacity": capacity_cases})).expect("fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/candidate-journal.json"); if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { @@ -538,10 +538,23 @@ async fn candidate_journal( "changed-before-admission", "changed-before-child", "changed-before-main", + "publish-success", + "publish-bad-final", + "publish-bad-version", + "publish-unknown", + "publish-stale-primary", + "publish-stale-child", + "publish-expired-approval", + "publish-changed-configuration", + "publish-changed-predecessor", ] { if matches!( case, - "missing-child" | "bad-probe" | "stale-child" | "changed-before-child" + "missing-child" + | "bad-probe" + | "stale-child" + | "changed-before-child" + | "publish-stale-child" ) && approved.prerequisite_plans().expect("plans").is_empty() { continue; @@ -690,15 +703,14 @@ async fn candidate_journal( if case == "changed-before-main" { change_predecessor(&connection, target, previous).await; } - if case == "stale-child" { - clock.set(NOW + 31); - } + let main_time = match case { + "stale-child" => NOW + 31, + "publish-stale-child" => NOW + 30, + _ => NOW, + }; + clock.set(main_time); let granted = reserved - .grant_entry( - Arc::clone(approved), - validation(), - if case == "stale-child" { NOW + 31 } else { NOW }, - ) + .grant_entry(Arc::clone(approved), validation(), main_time) .await; if matches!( case, @@ -719,9 +731,24 @@ async fn candidate_journal( serde_json::to_value(target.final_request()).expect("compiled request") ); drop(permit); - if case == "recorded" { + if case == "recorded" || (case.starts_with("publish-") && case != "publish-unknown") { + let (status, body): (u16, &[u8]) = match target.final_kind() { + PrerequisiteKind::Probe => (200, br#"{"livemode":false}"#), + PrerequisiteKind::Account => (200, br#"{"id":"acct_TESTACCOUNT01"}"#), + PrerequisiteKind::DeniedCapability(_) => (403, b""), + _ => panic!("credential final purpose"), + }; + let (status, body) = if case == "publish-bad-final" { + match target.final_kind() { + PrerequisiteKind::Probe => (200, br#"{"livemode":true}"#.as_slice()), + PrerequisiteKind::Account => (200, br#"{"id":"wrong"}"#.as_slice()), + _ => (200, b"".as_slice()), + } + } else { + (status, body) + }; granted - .record_response(403, true, b"", NOW) + .record_response(status, case != "publish-bad-version", body, main_time) .await .expect("record primary"); } else { @@ -755,9 +782,100 @@ async fn candidate_journal( crate::AcquisitionClaim::Existing(_) )); } + let mut publication = Value::Null; + if case.starts_with("publish-") { + let publish_time = match case { + "publish-stale-primary" | "publish-stale-child" => NOW + 31, + "publish-expired-approval" => NOW + 61, + _ => NOW, + }; + clock.set(publish_time); + if case == "publish-changed-configuration" { + let changed = crate::configuration::SharedConfiguration::new( + Arc::clone(&store), + policy + .configuration_key(installed.recipe.namespace()) + .expect("key"), + [99; 32], + ); + changed + .activate( + configuration.current_revision().expect("revision"), + &qualification, + ) + .expect("activate"); + } + if case == "publish-changed-predecessor" { + if previous.is_some() { + change_predecessor(&connection, target, previous).await; + } else { + let revoked = target + .record() + .transition_state(ConnectionState::Revoked, NOW) + .expect("revoked"); + connection + .insert(&revoked) + .await + .expect("conflicting installation"); + } + } + let connection_key = + crate::connection_key(target.record().provider_kind(), target.record().alias()); + let before_publish = store + .load(crate::GatewayRecordKind::Connection, &connection_key) + .expect("before"); + let result = reopened + .publish_candidate(Arc::clone(approved), validation(), publish_time) + .await; + if case == "publish-success" { + assert_eq!( + result.expect("publish"), + crate::CandidatePublication::Published + ); + let bytes = target.record().to_canonical_cbor().expect("bytes"); + assert_eq!( + store + .load(crate::GatewayRecordKind::Connection, &connection_key) + .expect("after"), + Some(bytes.clone()) + ); + // Losing the caller's acknowledgement cannot cause provider I/O, + // reallocation or evidence renewal on the next explicit action. + assert_eq!( + reopened + .publish_candidate(Arc::clone(approved), validation(), publish_time) + .await + .expect("repeat"), + crate::CandidatePublication::AlreadyCurrent + ); + assert_eq!( + store + .load(crate::GatewayRecordKind::Connection, &connection_key) + .expect("repeat bytes"), + Some(bytes) + ); + publication = json!({"result": "published", "replay": "already-current", "exact_candidate": true}); + } else { + assert!(result.is_err(), "publication must refuse {name}/{case}"); + assert_eq!( + store + .load(crate::GatewayRecordKind::Connection, &connection_key) + .expect("after"), + before_publish + ); + publication = json!({"result": "refused", "connection_unchanged": true}); + } + assert_eq!( + reopened + .read_acquisition(approved) + .await + .expect("unchanged root"), + Some(snapshot.clone()) + ); + } assert_eq!(snapshot.reserved_calls, 1); assert_eq!(snapshot.reserved_bytes, before.reserved_bytes); - histories.push(json!({"case": case, "snapshot": snapshot, "children": children, "restart_preserves_facts_and_charges": true})); + histories.push(json!({"case": case, "snapshot": snapshot, "children": children, "publication": publication, "restart_preserves_facts_and_charges": true})); } json!({"target": name, "histories": histories}) } diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index 9766bee7e..ff59273af 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -112,6 +112,43 @@ impl EntryValidation { } } + /// Publication is a trusted operator action. Native read evidence still + /// must satisfy its exact final purpose; HTTP status is not that predicate. + pub(crate) fn validate_candidate_evidence( + &self, + approved: &ApprovedEffect, + acquired: &[crate::store::PrerequisiteResponse], + primary: &crate::store::PrerequisiteResponse, + now: u64, + ) -> Result<(), &'static str> { + let invalid = "gateway.entry.prerequisite-evidence"; + let target = approved.candidate_target().ok_or(invalid)?; + if target.final_kind() != primary.kind + || primary.observed_at > primary.received_at + || primary.received_at > now + || !now + .checked_sub(primary.observed_at) + .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + { + return Err(invalid); + } + self.validate_prerequisite_evidence( + approved, + &crate::GatewayPreEntry::default(), + acquired, + now, + )?; + match self { + Self::Installed(entry) => validate_credential_evidence( + &entry.recipe, + *target.record().account_commitment(), + primary, + ), + #[cfg(any(test, feature = "testkit-harness"))] + Self::Oracle { .. } => Ok(()), + } + } + pub(crate) fn dependencies(&self) -> Vec<(GatewayRecordKind, GatewayAttemptKey)> { match self { Self::Installed(entry) => { diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 144359136..2b2eab232 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -138,15 +138,16 @@ pub use separation::{ principals_overlap, }; pub use store::{ - AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, ClaimedGatewayAttempt, - FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptSnapshot, - GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, GatewayCounterEntry, - GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, GatewayInsert, - GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, - GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, - ObservableGatewayAttempt, PostgresGatewayAttemptStore, PrivateDirectoryError, - RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, - check_private_directory, check_private_directory_owned_by, pre_entry_digest, + AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, + ClaimedGatewayAttempt, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, + GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, + GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, + GatewayInsert, GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, + GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, + GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, + PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, + ReservedAcquisition, check_private_directory, check_private_directory_owned_by, + pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index fd39ae2bf..8bbb808af 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "43c7323e4699c7487e99f39b442f4b064635cbdb7aba619646dd6764adac868c"; + "9f1a1d2e39ddc9bb582f0f3067f543c835b1d4daed50863b77940a8be6ccac20"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 8f5fafac4..508c602d0 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -709,8 +709,9 @@ enum ProtocolState { mod acquisition; mod capacity; pub use acquisition::{ - AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, GatewayRecoveryReport, - RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, + AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, + GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, + ReservedAcquisition, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 06b66950b..34319e883 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -7,6 +7,8 @@ use crate::effect::{ AcquisitionCapacity, AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, }; +mod candidate; +pub use candidate::CandidatePublication; mod recovery; pub(super) use recovery::RecoveryEvidenceLink; pub use recovery::{ @@ -349,6 +351,14 @@ impl Record { let AcquisitionPlan::Prerequisite(plan) = &self.state.plan else { return Err(GatewayAttemptError::BindingConflict); }; + self.response_evidence(plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?, now) + } + + fn response_evidence( + &self, + kind: PrerequisiteKind, + now: u64, + ) -> Result { let AcquisitionPhase::ResponseRecorded { response } = &self.state.phase else { return Err(GatewayAttemptError::InvalidTransition); }; @@ -373,7 +383,7 @@ impl Record { .capacity() .map_err(|_| GatewayAttemptError::Corrupt)?; Ok(PrerequisiteResponse { - kind: plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?, + kind, response: crate::transport::ProviderResponse { status: response.status, version_ok: response.version_ok, diff --git a/product/runtime/auths-gateway/src/store/acquisition/candidate.rs b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs new file mode 100644 index 000000000..f089e28bc --- /dev/null +++ b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs @@ -0,0 +1,169 @@ +//! Publication is an explicit operator action over retained candidate evidence. +//! It changes only the connection row; acquisition facts and charges stay immutable. + +use super::*; + +/// Result of an explicit operator publication; neither variant grants I/O. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub enum CandidatePublication { + /// The exact predecessor/absence and complete fresh evidence were checked + /// under the writer fence before the connection commit was acknowledged. + Published, + /// The exact candidate is already current. This is a state observation, + /// not a claim that this invocation published it or refreshed its evidence. + AlreadyCurrent, +} + +impl GatewayAttempts { + /// No public/application route may call this as a substitute for operator + /// publication authority. The native read proof authorizes only its reads. + pub(crate) async fn publish_candidate( + &self, + approved: Arc, + validation: crate::entry::EntryValidation, + authorization_started_at: u64, + ) -> Result { + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let target = approved + .candidate_target() + .ok_or(GatewayAttemptError::InvalidTransition)?; + let plan = approved + .candidate_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let capacity = plan + .validate(binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let replacement = target + .record() + .to_canonical_cbor() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let is_first = target.previous().is_none(); + let kind = target.final_kind(); + let connection_key = plan + .source_key() + .map_err(|_| GatewayAttemptError::Corrupt)?; + let (namespace, operation, _, _) = binding.journal_identity(); + let key = self.key( + &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, + &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, + )?; + let store = Arc::clone(&self.store); + blocking(move || { + let root_bytes = store + .load(GatewayRecordKind::Attempt, &key)? + .ok_or(GatewayAttemptError::Unavailable)?; + let root: Record = decode_as(&root_bytes)?; + if root.state.plan != AcquisitionPlan::Candidate(plan.clone()) + || root.validate_header()? != *approved.effect().binding() + { + return Err(GatewayAttemptError::BindingConflict); + } + // A replay observes current state without refreshing old evidence or + // giving a second publication any causal attribution. + if store + .load(GatewayRecordKind::Connection, &connection_key)? + .as_deref() + == Some(replacement.as_slice()) + { + return Ok(CandidatePublication::AlreadyCurrent); + } + let slot = root + .state + .allocation + .ok_or(GatewayAttemptError::InvalidTransition)?; + let mut keys = vec![ + (GatewayRecordKind::Connection, connection_key), + (GatewayRecordKind::Attempt, key), + ( + GatewayRecordKind::EffectAllocation, + allocation_key(&capacity, slot), + ), + ]; + let native_indices = append_dependencies(&mut keys, &validation.dependencies()); + let native_end = keys.len(); + let prerequisites = approved + .prerequisite_plans() + .map_err(|_| GatewayAttemptError::Corrupt)?; + keys.extend(prerequisite_dependencies(key, &prerequisites)?); + let mut disposition = CandidatePublication::Published; + let mut decide = |snapshots: &[Option>]| { + if snapshots.len() != keys.len() + || snapshots[1].as_deref() != Some(root_bytes.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + if snapshots[0].as_deref() == Some(replacement.as_slice()) { + disposition = CandidatePublication::AlreadyCurrent; + return Ok(replacement.clone()); + } + if !plan + .source_matches(snapshots[0].as_deref()) + .map_err(|_| GatewayAttemptError::Corrupt)? + .0 + || snapshots[2].as_deref() + != Some( + canonical(&Allocation::new(&root.state.plan, key, slot)?)?.as_slice(), + ) + { + return Err(GatewayAttemptError::BindingConflict); + } + let now = validation + .validate( + &approved, + &select_snapshots(snapshots, &native_indices)?, + authorization_started_at, + ) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + let acquired = validate_prerequisites( + key, + approved.effect().binding(), + &prerequisites, + &snapshots[native_end..], + now, + )?; + let primary = root.response_evidence(kind, now)?; + validation + .validate_candidate_evidence(&approved, &acquired, &primary, now) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + Ok(replacement.clone()) + }; + if is_first { + let entry = GatewayRecordEntry { + kind: GatewayRecordKind::Connection, + key: connection_key, + record: replacement.clone(), + expires_at: None, + }; + // The insertion target itself is held absent by the same fence. + // Reconstruct that explicit snapshot for the shared decision. + match store.fenced_insert_all(&[entry], &keys[1..], &mut |snapshots| { + let mut all = Vec::with_capacity(snapshots.len() + 1); + all.push(None); + all.extend_from_slice(snapshots); + decide(&all) + })? { + GatewayInsert::Inserted => {} + GatewayInsert::Exists { index: 0 } => { + if store + .load(GatewayRecordKind::Connection, &connection_key)? + .as_deref() + != Some(replacement.as_slice()) + { + return Err(GatewayAttemptError::BindingConflict); + } + return Ok(CandidatePublication::AlreadyCurrent); + } + GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), + } + } else { + store.fenced_replace(&keys, &mut decide)?; + } + Ok(disposition) + }) + .await + } +} From 861271a3a59ce12613e0776a2368d6d5612a408a Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 10:57:38 +0000 Subject: [PATCH 040/136] feat(gateway): persist exact private credential proposals --- .../gateway/candidate-compilation.json | 55 ++++++++++++++ compliance.toml | 7 +- ...017-bound-effect-and-recovery-ownership.md | 12 +++ docs/plans/0074-implementation-status.md | 21 ++++++ ...ound-effects-and-recovery-state-machine.md | 9 +++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/effect/candidate.rs | 27 ++++--- .../src/effect/candidate/proposal.rs | 75 +++++++++++++++++++ .../src/effect_candidate_tests.rs | 49 +++++++++++- .../auths-gateway/src/semantic_closure.rs | 2 +- 10 files changed, 244 insertions(+), 15 deletions(-) create mode 100644 product/runtime/auths-gateway/src/effect/candidate/proposal.rs diff --git a/bindings/fixtures/gateway/candidate-compilation.json b/bindings/fixtures/gateway/candidate-compilation.json index 60d17d5f7..ee9c3fb0d 100644 --- a/bindings/fixtures/gateway/candidate-compilation.json +++ b/bindings/fixtures/gateway/candidate-compilation.json @@ -954,6 +954,17 @@ ] } }, + "candidate_proposal_canonical": "{\"candidate\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2235623738643535363436396534356365396366343963613865656261333838376239663835666165303163623132303031623661353266386530343331656139222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d0858208bf531b9aa23075722347a6cfd573ea20b0f9b826e3793f420664c4265a3131c095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582005050505050505050505050505050505050505050505050505050505050505050b010c666163746976650d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b1c11f61201\",\"previous\":null,\"recipe\":\"5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9\",\"schema\":\"auths.gateway-credential-candidate/1\"}", + "invalid_proposals_refused": [ + "schema", + "recipe", + "candidate", + "previous", + "extra", + "duplicate", + "noncanonical", + "oversized" + ], "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[208,38,165,192,10,42,38,233,209,20,238,107,255,90,14,183,169,73,131,188,221,241,38,133,233,99,194,253,224,246,24,8],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", @@ -1980,6 +1991,17 @@ ] } }, + "candidate_proposal_canonical": "{\"candidate\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2235623738643535363436396534356365396366343963613865656261333838376239663835666165303163623132303031623661353266386530343331656139222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d0858208bf531b9aa23075722347a6cfd573ea20b0f9b826e3793f420664c4265a3131c095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582006060606060606060606060606060606060606060606060606060606060606060b020c666163746976650d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b7611f61202\",\"previous\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2235623738643535363436396534356365396366343963613865656261333838376239663835666165303163623132303031623661353266386530343331656139222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d0858208bf531b9aa23075722347a6cfd573ea20b0f9b826e3793f420664c4265a3131c095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582005050505050505050505050505050505050505050505050505050505050505050b010c666163746976650d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b1c11f61201\",\"recipe\":\"5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9\",\"schema\":\"auths.gateway-credential-candidate/1\"}", + "invalid_proposals_refused": [ + "schema", + "recipe", + "candidate", + "previous", + "extra", + "duplicate", + "noncanonical", + "oversized" + ], "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[20,112,47,231,171,55,86,99,134,148,142,70,205,192,14,222,179,148,167,180,95,4,144,198,9,165,232,10,59,26,192,22],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", @@ -3006,6 +3028,17 @@ ] } }, + "candidate_proposal_canonical": "{\"candidate\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2235623738643535363436396534356365396366343963613865656261333838376239663835666165303163623132303031623661353266386530343331656139222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d0858208bf531b9aa23075722347a6cfd573ea20b0f9b826e3793f420664c4265a3131c095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582006060606060606060606060606060606060606060606060606060606060606060b030c6864697361626c65640d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b7611f61203\",\"previous\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2235623738643535363436396534356365396366343963613865656261333838376239663835666165303163623132303031623661353266386530343331656139222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d0858208bf531b9aa23075722347a6cfd573ea20b0f9b826e3793f420664c4265a3131c095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582005050505050505050505050505050505050505050505050505050505050505050b020c6864697361626c65640d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b4e11f61201\",\"recipe\":\"5b78d556469e45ce9cf49ca8eeba3887b9f85fae01cb12001b6a52f8e0431ea9\",\"schema\":\"auths.gateway-credential-candidate/1\"}", + "invalid_proposals_refused": [ + "schema", + "recipe", + "candidate", + "previous", + "extra", + "duplicate", + "noncanonical", + "oversized" + ], "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[189,8,239,231,198,100,77,232,190,74,108,205,187,236,170,175,242,154,124,105,134,160,172,63,141,189,45,89,10,209,144,38],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", @@ -3972,6 +4005,17 @@ ] } }, + "candidate_proposal_canonical": "{\"candidate\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2262346336373039653062373865663133623434323466326330343133383232383530396365633234343134366562333765363133343964366632343465373163222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d085820a4c1c36e662449bcaecec12cd9fe918628fbcbbfbe52fee1023528d0e76b3034095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582005050505050505050505050505050505050505050505050505050505050505050b010c666163746976650d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b1c11f61201\",\"previous\":null,\"recipe\":\"b4c6709e0b78ef13b4424f2c04138228509cec244146eb37e61349d6f244e71c\",\"schema\":\"auths.gateway-credential-candidate/1\"}", + "invalid_proposals_refused": [ + "schema", + "recipe", + "candidate", + "previous", + "extra", + "duplicate", + "noncanonical", + "oversized" + ], "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[188,236,232,4,135,50,61,56,161,5,123,148,8,217,87,15,39,29,126,63,139,160,132,69,10,105,40,52,17,98,228,169],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", @@ -4522,6 +4566,17 @@ "prerequisite_acquisitions": [] } }, + "candidate_proposal_canonical": "{\"candidate\":\"b2010202686169727461626c65036973796e74686574696304781b636f6e6e5f4141414141414141414141414141414141414141414105781961757468732e676174657761792d6f7065726174696f6e2f3106782561757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f310758ca7b2263726564656e7469616c223a7b226b696e64223a22626561726572227d2c226f70657261746f725f6e616d657370616365223a227374726970652d726566756e6473222c227265636970655f646967657374223a2262346461656135313465663565373337313335323435633664653735653464623061373064666534353334383166653032373561646636663130386333643636222c22736368656d61223a2261757468732e676174657761792d636f6e6e656374696f6e2d64657363726970746f722f31227d08582049f2aca52d40557ac2334753e9deeb80be5e7e1f539bb78191464481059c2a5f095820d3898dfaeefb90fbf48af98b5a5b6eaeb8917ddaf8f61a58f422a99f2f13e8240a582005050505050505050505050505050505050505050505050505050505050505050b010c666163746976650d8167676174657761790e81826961757468732e6d6370020f1a6ab13b1c101a6ab13b1c11f61201\",\"previous\":null,\"recipe\":\"b4daea514ef5e737135245c6de75e4db0a70dfe453481fe0275adf6f108c3d66\",\"schema\":\"auths.gateway-credential-candidate/1\"}", + "invalid_proposals_refused": [ + "schema", + "recipe", + "candidate", + "previous", + "extra", + "duplicate", + "noncanonical", + "oversized" + ], "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[164,129,114,253,141,88,237,82,71,126,178,81,103,60,87,72,92,103,130,187,183,138,219,24,110,11,186,11,194,99,193,189],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", diff --git a/compliance.toml b/compliance.toml index fb2738d15..56c655dc8 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1600,8 +1600,8 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1611,6 +1611,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-proposal = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", +] candidate-publication = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 6c35dbd8a..fa1983f9c 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -704,3 +704,15 @@ credential binding. `AlreadyCurrent` is an exact-state observation for an explicit retry, including lost acknowledgement; it makes no causal claim and issues no capability. Staging/CLI cutover and installed custody/transport fault coverage remain separate required work. + + +## Private candidate proposal persistence + +`auths.gateway-credential-candidate/1` stores exact canonical candidate and +predecessor connection bytes plus the pinned recipe digest. The bounded native +decoder reconstructs only proposal data and derives the closed check plan from +the installed recipe. It validates the first-install or rotation relationship +and rejects noncanonical/duplicate/unknown/obsolete data. No persisted proof of +current custody, predecessor, authority or completed checks is implied. This +format prepares the operator CLI to retain a stable target across approval and +restart without adding a second execution path or serializable capability. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d65f4e657..2a730c745 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -880,6 +880,27 @@ closure regeneration passed after that correction (one artifact-generation test) Python-owner removal, authenticated UI/bindings and full acceptance evidence remain open. No A01–A22 criterion is closed and no hosted CI was observed. +## Private candidate proposal checkpoint + +- Added `auths.gateway-credential-candidate/1`, bounded canonical private JSON + containing exact candidate/predecessor CBOR and recipe digest. It preserves + the target for future CLI approval/restart steps without serializing authority, + custody, a check result or a transport capability. The native decoder derives + the plan from the pinned recipe and revalidates the connection relationship. +- The five-target native generator now passes the decoded proposal into every + signed compilation and journal/publication history. It authors exact-roundtrip + and wrong-schema/recipe/record/predecessor, unknown/duplicate/noncanonical and + oversize refusals. Initial artifact compilation exposed a test assertion's + demand for private-plan Debug; the assertion now compares equality without + adding a private-data Debug implementation. +- Native candidate artifact generation passed after the assertion correction: + five proposal roundtrips/negative sets and all 80 journal/publication histories. + Final semantic closure is regenerated with this source. No broad local gate + or hosted CI was run; no acceptance criterion closes at this checkpoint. +- Staging and CLI cutover remain pending; this format alone does not implement + them. No new schema migration, legacy reader or alternate execution path was + added. Existing candidate compiler/binding/journal identities are unchanged. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index ab2321922..f37ec6ffd 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -263,6 +263,15 @@ cannot establish predecessor freshness, enter transport or publish a credential; the runtime must fence predecessor/absence and retain the checks through safe publication in the same authoritative journal contract. +The private operator proposal format `auths.gateway-credential-candidate/1` +retains canonical connection/predecessor bytes and the exact recipe digest, +bounded to 65,536 bytes. Decode rejects duplicate, unknown, noncanonical, +obsolete-schema, wrong-recipe and invalid-relationship data and reconstructs +checks only from the installed recipe. The proposal contains no provider secret +and grants no native authority, custody lease, transport or publication. It is +private operator data suitable for preserving an exact target across approval +and restart; the journal and fresh fences remain authoritative. + Candidate journal admission uses the expected connection row as a source rather than an invented source mutation. Both admission and every child/primary entry must recheck predecessor/absence, exact native authority, configuration, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 4de7c30a0..d7edb6150 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"6558cda21bdf40cf779f0d6f4195a503ed082b2823128b451a0b3dc7d0ead7b5"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"123cf88f35ddc3395a18c7598f46c7fca3fb3a4dd45d9d9f164c587d69f67940"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"732ce474c8662fe2b150e90d2a142a828a259b62d601eeacf5ed658a2715232d"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"dd793454291d5858d0787ca09065595af235a5eae14dda3e2de6fa7c07482cb7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"6558cda21bdf40cf779f0d6f4195a503ed082b2823128b451a0b3dc7d0ead7b5"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"2632418325436b5c2f57a57181d162c390bb7fc3311c08e69e71016b1d9c311a"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"dd793454291d5858d0787ca09065595af235a5eae14dda3e2de6fa7c07482cb7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs index caec39b88..aa3a13e69 100644 --- a/product/runtime/auths-gateway/src/effect/candidate.rs +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -11,13 +11,16 @@ use serde_json::{Value, json}; /// Reserved native operation for bounded candidate credential checks. pub const CANDIDATE_CHECK_TOOL: &str = "auths_gateway_candidate_check_v1"; +mod proposal; + const CONTRACT: &str = "auths.gateway-candidate-check/1"; const MAX_CANDIDATE_ATTEMPTS: u64 = 16; /// Private immutable first-install or rotation proposal, derived only from a /// validated connection descriptor and the installed recipe's closed reads. -/// There is no decoder and no transport capability. A later transaction must -/// establish the exact predecessor (or absence) before any candidate entry. +/// Private proposal decoding reconstructs only this data, with no transport +/// capability. A later transaction must establish the exact predecessor (or +/// absence) before any candidate entry. #[derive(Clone)] pub struct CandidateCredentialTarget { candidate: ConnectionRecord, @@ -319,14 +322,7 @@ pub(crate) struct CandidatePlan { impl CandidatePlan { pub(crate) fn connection(&self) -> Result { - if self.candidate.len() > MAX_EFFECT_BYTES { - return Err(EffectBindingError::Invalid); - } - let bytes = hex::decode(&self.candidate).map_err(|_| EffectBindingError::Invalid)?; - if hex::encode(&bytes) != self.candidate { - return Err(EffectBindingError::Invalid); - } - ConnectionRecord::from_canonical_cbor(&bytes).map_err(|_| EffectBindingError::Invalid) + decode_connection(&self.candidate) } pub(crate) fn source_key(&self) -> Result { @@ -501,3 +497,14 @@ fn connection_review(record: &ConnectionRecord, descriptor: &Value) -> Value { "created_at_unix_seconds": record.created_at_unix_seconds(), "updated_at_unix_seconds": record.updated_at_unix_seconds(), }) } + +fn decode_connection(encoded: &str) -> Result { + if encoded.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let bytes = hex::decode(encoded).map_err(|_| EffectBindingError::Invalid)?; + if hex::encode(&bytes) != encoded { + return Err(EffectBindingError::Invalid); + } + ConnectionRecord::from_canonical_cbor(&bytes).map_err(|_| EffectBindingError::Invalid) +} diff --git a/product/runtime/auths-gateway/src/effect/candidate/proposal.rs b/product/runtime/auths-gateway/src/effect/candidate/proposal.rs new file mode 100644 index 000000000..26824ee8f --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/candidate/proposal.rs @@ -0,0 +1,75 @@ +//! Private candidate persistence for explicit operator review and restart. +//! Decoding reconstructs proposed data only; it grants no custody or I/O. + +use super::*; + +const SCHEMA: &str = "auths.gateway-credential-candidate/1"; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Proposal { + schema: String, + recipe: String, + candidate: String, + previous: Option, +} + +impl CandidateCredentialTarget { + /// Encodes the exact proposed connection, predecessor/absence and recipe + /// commitment as canonical private JSON, bounded by `MAX_EFFECT_BYTES`. + /// It contains private connection data, never the provider secret. Store + /// these bytes on the operator plane, separate from public activity output. + /// + /// # Errors + /// Refuses an encoding failure or an oversized proposal. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + let encode = |record: &ConnectionRecord| { + record + .to_canonical_cbor() + .map(hex::encode) + .map_err(|_| EffectBindingError::Invalid) + }; + canonical(&Proposal { + schema: SCHEMA.to_owned(), + recipe: hex::encode(self.recipe), + candidate: encode(&self.candidate)?, + previous: self.previous.as_ref().map(encode).transpose()?, + }) + } + + /// Decodes bounded canonical private proposal bytes against the exact + /// installed recipe and reconstructs its closed check plan. This is data, + /// not verified authority. Callers still need native proof, exact approval, + /// staged custody and current predecessor checks before any acquisition; + /// publication separately requires operator authority and retained evidence. + /// No obsolete-schema decoder or caller-supplied check plan is accepted. + /// + /// # Errors + /// Refuses malformed, duplicate, noncanonical, oversized, wrong-schema or + /// wrong-recipe data, invalid records and invalid first-install/rotation + /// relationships. No provider, credential or shared store is accessed. + pub fn from_private_bytes( + recipe: &CompiledRecipe, + bytes: &[u8], + ) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let proposal: Proposal = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + if proposal.schema != SCHEMA || proposal.recipe != hex::encode(recipe.digest()) { + return Err(EffectBindingError::Invalid); + } + let candidate = decode_connection(&proposal.candidate)?; + let previous = proposal + .previous + .as_deref() + .map(decode_connection) + .transpose()?; + let target = Self::new(recipe, &candidate, previous.as_ref())?; + if target.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(target) + } +} diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index db74b8d72..5c2680b6d 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -110,6 +110,53 @@ async fn native_candidate_compilation_fixture_is_current() { ); let target = CandidateCredentialTarget::new(&recipe, &candidate, previous.as_ref()).expect("target"); + let proposal = target.to_private_bytes().expect("private proposal"); + let decoded = CandidateCredentialTarget::from_private_bytes(&recipe, &proposal) + .expect("decode proposal"); + assert!( + decoded.journal_plan().expect("decoded plan") + == target.journal_plan().expect("original plan"), + "private proposal preserves its complete compiled plan" + ); + assert_eq!( + decoded.to_private_bytes().expect("canonical roundtrip"), + proposal + ); + let proposal_value: Value = serde_json::from_slice(&proposal).expect("proposal JSON"); + let mut invalid_proposals = Vec::new(); + for field in ["schema", "recipe", "candidate", "previous", "extra"] { + let mut changed = proposal_value.clone(); + changed[field] = json!("invalid"); + assert!( + CandidateCredentialTarget::from_private_bytes( + &recipe, + &serde_json_canonicalizer::to_vec(&changed).expect("changed proposal") + ) + .is_err(), + "{field}" + ); + invalid_proposals.push(field); + } + let duplicate = format!( + "{{\"schema\":\"auths.gateway-credential-candidate/1\",{}", + std::str::from_utf8(&proposal[1..]).expect("UTF-8") + ); + assert!( + CandidateCredentialTarget::from_private_bytes(&recipe, duplicate.as_bytes()).is_err() + ); + let mut padded = proposal.to_vec(); + padded.push(b' '); + assert!(CandidateCredentialTarget::from_private_bytes(&recipe, &padded).is_err()); + assert!( + CandidateCredentialTarget::from_private_bytes( + &recipe, + &vec![b' '; crate::effect::MAX_EFFECT_BYTES + 1] + ) + .is_err() + ); + invalid_proposals.extend(["duplicate", "noncanonical", "oversized"]); + // All subsequent signed compilation/journal cases use the decoded data. + let target = decoded; let call = target .authorization_call( &recipe, @@ -486,7 +533,7 @@ async fn native_candidate_compilation_fixture_is_current() { ) .is_err() ); - cases.push(json!({"case": case, "review": review, "binding_canonical": std::str::from_utf8(&binding).expect("UTF-8"), + cases.push(json!({"case": case, "review": review, "candidate_proposal_canonical": std::str::from_utf8(&proposal).expect("UTF-8"), "invalid_proposals_refused": invalid_proposals, "binding_canonical": std::str::from_utf8(&binding).expect("UTF-8"), "substitutions_refused": refused, "native_reverification": "same effect; altered connection and expired approval refused", "admission": "mutation, recovery and orphan child refused; candidate runtime admission tested separately", "same_credential_new_operation_retains_lifetime_reservations": true, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 8bbb808af..551d44f3b 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9f1a1d2e39ddc9bb582f0f3067f543c835b1d4daed50863b77940a8be6ccac20"; + "0d479f49488df1cf1724933505c120f2bc1a367d0243f722f5d7a42e65a0ef84"; #[cfg(test)] mod tests { From 1c23ca31e2a0d95d5502d15a7fc7edc15decad38 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 11:21:31 +0000 Subject: [PATCH 041/136] feat(gateway)!: stage approved credential rotations --- bindings/fixtures/gateway/candidate-cli.json | 14 + .../fixtures/gateway/candidate-staging.json | 40 +++ bindings/fixtures/gateway/codes.json | 8 + compliance.toml | 8 + ...017-bound-effect-and-recovery-ownership.md | 22 ++ docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md | 41 ++- docs/plans/0074-implementation-status.md | 50 ++- .../0009-bound-effect-and-recovery.md | 19 + ...ound-effects-and-recovery-state-machine.md | 13 + .../auths-connections/src/credential.rs | 155 +++++++-- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 198 ++++++++++- .../auths-gateway/src/candidate_runtime.rs | 77 ++++ .../runtime/auths-gateway/src/connection.rs | 18 +- .../src/effect_candidate_staging_tests.rs | 266 ++++++++++++++ .../src/effect_candidate_tests.rs | 13 + product/runtime/auths-gateway/src/engine.rs | 80 +++-- .../src/pending_vectors/codes.rs | 1 + .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/candidate_cli.rs | 328 ++++++++++++++++++ 20 files changed, 1259 insertions(+), 96 deletions(-) create mode 100644 bindings/fixtures/gateway/candidate-cli.json create mode 100644 bindings/fixtures/gateway/candidate-staging.json create mode 100644 product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs create mode 100644 product/runtime/auths-gateway/tests/candidate_cli.rs diff --git a/bindings/fixtures/gateway/candidate-cli.json b/bindings/fixtures/gateway/candidate-cli.json new file mode 100644 index 000000000..e2e9a8f68 --- /dev/null +++ b/bindings/fixtures/gateway/candidate-cli.json @@ -0,0 +1,14 @@ +{ + "schema": "auths.candidate-cli-fixture/1", + "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", + "competing_processes_one_staging_winner": true, + "held_custody_fence_refuses_without_proposal": true, + "staged_generation": 2, + "current_record_unchanged": true, + "proposal_and_call_mode": "0600", + "existing_proposal_refused_without_overwrite": true, + "different_secret_same_generation_refused": true, + "reopened_custody_holds_exact_candidate": true, + "authored_call_matches_native": true, + "permissive_proposal_refused": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/candidate-staging.json b/bindings/fixtures/gateway/candidate-staging.json new file mode 100644 index 000000000..65b032228 --- /dev/null +++ b/bindings/fixtures/gateway/candidate-staging.json @@ -0,0 +1,40 @@ +{ + "schema": "auths.candidate-staging-fixture/1", + "scope": "actual engine, persistent file custody, generation floor and cleanup journal; fixed deployment clock; no provider execution, process crash or PostgreSQL claim", + "cases": [ + { + "case": "active", + "staged_generation": 2, + "same_secret_idempotent": true, + "different_secret_refused": true, + "reopen_retains_current_and_candidate": true, + "cleanup_notes_retained": true, + "preexisting_reader_refreshes_custody": true, + "stale_writer_cannot_overwrite": true, + "completed_delete_visible_to_stale_reader": true + }, + { + "case": "disabled", + "staged_generation": 3, + "same_secret_idempotent": true, + "different_secret_refused": true, + "reopen_retains_current_and_candidate": true, + "cleanup_notes_retained": true, + "preexisting_reader_refreshes_custody": true, + "stale_writer_cannot_overwrite": true, + "completed_delete_visible_to_stale_reader": true + }, + { + "case": "revoked", + "refused_without_custody_change": true + }, + { + "case": "missing-journal", + "refused_without_custody_change": true + }, + { + "case": "bad-prefix", + "refused_without_custody_change": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 0588abcec..0e0c28591 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -128,6 +128,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.admin.candidate-approval-required", + "owner": "admin", + "stage": "admin", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.admin.credential-account", "owner": "admin", diff --git a/compliance.toml b/compliance.toml index 56c655dc8..a5fe3290a 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1582,6 +1582,10 @@ configuration_inputs = ["connection-alias", "credential-store-kind", "provider-k security_state = ["connection-generation", "credential-generation", "credential-reference", "provider-account-commitment"] [packages.auths-connections.claims] +file-custody-process-serialization = [ + "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", +] independent-semantic-implementation = [ "product/runtime/auths-connections/src/model.rs#canonical_record_round_trip_is_byte_exact", "product/runtime/auths-connections/src/model.rs#state_changes_keep_and_rotations_set_the_credential_generation", @@ -1611,6 +1615,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-staging = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", + "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", +] candidate-proposal = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index fa1983f9c..7fae85310 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -716,3 +716,25 @@ and rejects noncanonical/duplicate/unknown/obsolete data. No persisted proof of current custody, predecessor, authority or completed checks is implied. This format prepares the operator CLI to retain a stable target across approval and restart without adding a second execution path or serializable capability. + + +## Candidate staging and operator CLI + +Rotation staging now records cleanup obligations before a non-overwriting +custody replace, preserving the current connection and secret. The exact native +proposal feeds call authoring, `effect-review --candidate`, acquisition under +runtime read identity and publication under operator identity. Read-bearing +recipes refuse the old unapproved rotation/commit routes; no-read recipes retain +an explicit offline operator flow. Joining an already-published secret uses +exact reference confirmation and does not acquire new provider evidence. + +Independent CLI processes exposed a local file-custody lifetime problem: +previous handles retained snapshots that could overwrite a later successor. +The existing persistent custody owner now uses a stable sidecar lock, reloads +bounded canonical state under it, and fails immediately on lock contention. +Atomic database rename remains the persistence boundary. Readers refresh before +selecting the exact credential; a completed deletion cannot be hidden by a stale +process cache. This is a store mechanism, with no change to credential identity, +read authorization or publication policy. Staged/CLI fixtures cover real file +custody, independent competing processes, held-lock refusal and stale handles; +they do not establish AWS, PostgreSQL or full process-crash qualification. diff --git a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md index 697615a5e..83a0e2cbc 100644 --- a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md +++ b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md @@ -51,11 +51,42 @@ the write-only operator identity. The operator process reads with the former and creates/deletes with the latter; the serving process keeps only its read-only identity. Neither role needs broader permissions. -Use the operator identity and `rotate-prepare --operator-process ---credential-stdin --state-dir ...`, piping the new provider secret. It runs -the recipe's fixed credential checks and stores a successor without publishing -it. Retain only the returned reference commitment. Then use `rotate-commit ---operator-process --state-dir ... --commitment ...` to atomically publish it. +For a recipe with credential reads, use the approved candidate workflow: + +1. Under operator identity, pipe the secret to `candidate-stage-rotation + --credential-stdin --state-dir ... --proposal-out /private/candidate.json`. + The absolute output must be new. Staging writes cleanup notes and custody, + preserves the live record, and performs no credential lease or provider read. +2. Run `effect-candidate-call --state-dir ... --candidate /private/candidate.json + --operation ... --call-out /private/call.json`. Use the normal native authoring + flow to obtain proof/action for this exact call. The proposal is private data, + not authorization. +3. Run `effect-review --candidate /private/candidate.json --state-dir ... + --proof ... --action ... --not-before ... --expires-at ... --request-out ...`. + Review the actual requests and connection/predecessor, obtain the reviewer's + signature, and assemble the exact envelope with `effect-approval`. +4. Under runtime read identity, run `candidate-acquire --state-dir ... + --candidate /private/candidate.json --proof ... --action ... --approval ...`. + It returns retained response/unknown facts. An unknown result does not permit + blind retry or publication. +5. Under operator identity, run `candidate-publish` with the same state directory, + proposal, proof, action and approval. The connection changes only if fresh + native authorization and every retained credential predicate pass under the + writer fence. Evidence expires 30 seconds after its original grant, including + earlier children. `AlreadyCurrent` reports exact state without attributing a + prior publication to this invocation. + +Keep the exact private proposal across restart. A different secret at an already +staged generation is refused; staging never deletes it implicitly. Local file +custody serializes independent processes with a stable lock and refreshes state; +lock contention returns unavailable without a write. The current read-bearing +rotation API refuses `rotate`, `rotate-prepare` and commitment-only +`rotate-commit` with `gateway.admin.candidate-approval-required`. Those commands +remain the offline operator flow for recipes declaring no credential reads. +Joining an already-published connection confirms the exact committed secret +without acquiring new provider evidence. First-install candidate staging and +full installed provider/custody qualification remain unfinished AP074 work. + Check status on both hosts; each must see the same shared generation and hold the exact committed credential generation. The old generation remains for at least the fixed 20-second retirement delay. Run `credential-collect --state-dir diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 2a730c745..214a92e8a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -901,6 +901,54 @@ closure regeneration passed after that correction (one artifact-generation test) them. No new schema migration, legacy reader or alternate execution path was added. Existing candidate compiler/binding/journal identities are unchanged. +## Candidate rotation staging and CLI checkpoint + +- `stage_candidate_rotation` checks installed configuration, current exact + connection, non-revocation, prefix, read plan, current custody and generations + before storing a successor. Durable cleanup notes precede the custody write. + It never leases, reads a provider, publishes, or discards another staged secret. + The fixed deployment-clock proposal can be persisted through approval/restart. +- Added production `candidate-stage-rotation`, `effect-candidate-call`, + `effect-review --candidate`, `candidate-acquire` and `candidate-publish` CLI + commands using native owners. Stage/publish use operator custody identity; + acquisition uses runtime read identity. Proposals/calls are new mode-0600 + files. Existing output and permissive proposal files are refused. +- Read-bearing recipes now refuse the old `rotate`/`rotate-prepare`/ + commitment-only `rotate-commit` routes before I/O. Recipes without reads keep + the offline operator path. Joining an already-published connection confirms + its exact credential reference without any provider read. First-install raw + checks and maintained deployment/qualification journey cutovers remain open. +- Independent operator processes exposed persistent file-custody snapshot + overwrites. The existing custody owner now reloads bounded canonical state + under a stable cross-process sidecar lock. File-lock contention fails + immediately; stale handles cannot overwrite committed candidates or hide a + completed deletion. Reads allocate once into zeroizing buffers, with length + bounds and exact EOF checks. No new dependency, credential identity or + lifecycle owner is introduced; shared connection/custody atomicity is not claimed. +- Native artifact construction passed on `861271a3` plus this source: five + durable staging cases (active/disabled, revoked, missing cleanup journal, + bad prefix), same-secret replay/different-secret refusal, custody reopen, + unchanged connection/witness and refusal of unapproved guarded rotation. + The 80 native candidate journal/publication histories and code/custody + inventories passed as well. Initial generator errors were a missing semicolon + and a fixture directory lacking mode 0700; both were corrected. +- The production CLI artifact passed with actual competing processes, one + staging winner, held-custody-lock refusal, exact native call bytes, output + preservation and owner-private permissions. Its initial compile required a + borrowed operation string; its synthetic installation then needed the same + pinned qualification root and empty loaded bundle as the production loader. + Those fixture inputs were corrected instead of weakening configuration checks. +- After the file-custody change, native staging regeneration passed again, + including stale-reader observation of a completed deletion; the independent + CLI process generator also passed again. Final source closure was regenerated + after all source edits. +- These are scoped file/CLI facts, not a fully approved installed provider + rotation, AWS/PostgreSQL conformance or process-crash qualification. First + installation, full approved provider journeys, safe recovery credentials, + general acquisition/disclosure/ACK, Python-owner removal, authenticated UI and + complete fault/formal/performance/hosted evidence remain required. No A01–A22 + acceptance criterion closes. No broad local gate or hosted CI was run. + ## Phase gates | Phase | State | Outstanding gate | @@ -908,7 +956,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Onboarding/rotation staging and CLI cutover (candidate acquisition/publication APIs wired), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | First-install staging, maintained deployment and full approved rotation journeys (candidate CLI wired), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 5afcdd4e6..c4fd5ff7e 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -445,3 +445,22 @@ final purpose/version, unknown primary, stale primary/children, expired approval changed configuration and changed predecessor. Acquisition snapshots and charges remain unchanged across publication. This evidence remains narrower than process faults, installed custody/provider execution or PostgreSQL conformance. + + +### Staging and local custody serialization + +The staged rotation path preserves the existing concrete connection/credential +relationship. It records the cleanup generation, stores without overwriting a +candidate, and hands its private proposal to the shared native read owner. +No provider semantics move into custody. The operator CLI directly uses native +call compilation, review, acquisition and publication; unapproved rotation is +limited to recipes with no network checks. Published-secret join is exact +credential confirmation without acquisition. + +The persistent file credential store now orders operations with a stable +cross-process sidecar lock and reloads bounded state. This is an existing store +mechanism correction needed by independent operator/runtime processes, not a +new lifecycle owner. The production CLI corpus drives two competing staging +processes and a held-lock refusal. Native staging evidence checks stale handle +refresh and conflicting successor refusal. Broader fault and adapter evidence +remains required before AP074 acceptance closes. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index f37ec6ffd..7d0259650 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -272,6 +272,19 @@ and grants no native authority, custody lease, transport or publication. It is private operator data suitable for preserving an exact target across approval and restart; the journal and fresh fences remain authoritative. +Rotation staging stores a successor only after validating the live predecessor, +recipe, secret prefix, custody and generation and recording its durable cleanup +obligation. It performs no provider read or lease, never deletes an existing +successor, and returns the private proposal for native authorization. The CLI +exposes staging, native call authoring, candidate review, acquisition and operator +publication as separate steps. Read-bearing recipes cannot use commitment-only +rotation; recipes with no reads retain their offline operator path. A join of +an already-published connection confirms its exact credential binding without +re-running provider checks. Local file custody reloads state under a stable +cross-process lock for each operation; contention is bounded by immediate +refusal, and stale handles cannot overwrite a successor or serve a generation +already removed by a completed custody mutation. + Candidate journal admission uses the expected connection row as a source rather than an invented source mutation. Both admission and every child/primary entry must recheck predecessor/absence, exact native authority, configuration, diff --git a/product/runtime/auths-connections/src/credential.rs b/product/runtime/auths-connections/src/credential.rs index 744c4bc84..4e8bd4815 100644 --- a/product/runtime/auths-connections/src/credential.rs +++ b/product/runtime/auths-connections/src/credential.rs @@ -6,11 +6,11 @@ use std::{ collections::BTreeMap, convert::Infallible, fmt, - fs::{self, File}, - io::Write as _, + fs::{self, File, OpenOptions}, + io::{Read as _, Write as _}, num::NonZeroU64, path::{Path, PathBuf}, - sync::{Mutex, RwLock}, + sync::{Mutex, MutexGuard, RwLock}, time::Instant, }; use subtle::ConstantTimeEq as _; @@ -541,7 +541,10 @@ impl ConnectionCredentialStore for InMemoryCredentialStore { /// only internal connection IDs, generations, commitment-bound secret bytes, /// and no provider/account/profile metadata. Deployments that require an HSM, /// OS keychain, or external secret manager can implement the same mechanism -/// contract without changing callers. +/// contract without changing callers. Every operation reloads bounded state +/// under a stable cross-process file lock. File-lock contention fails immediately with +/// `Unavailable`; stale handles cannot overwrite a successor or lease a +/// generation already removed by a completed custody mutation. pub struct PersistentCredentialStore { path: PathBuf, entries: Mutex>, @@ -587,10 +590,7 @@ impl PersistentCredentialStore { let parent = path.parent().ok_or(CredentialStoreError::InvalidCapacity)?; validate_parent(parent)?; let entries = if path.exists() { - validate_secret_file(&path, maximum_bytes)?; - let bytes = - Zeroizing::new(fs::read(&path).map_err(|_| CredentialStoreError::Unavailable)?); - decode_persistent_entries(&bytes, maximum_entries, maximum_bytes)? + read_persistent_entries(&path, maximum_entries, maximum_bytes)? } else { BTreeMap::new() }; @@ -612,6 +612,8 @@ impl PersistentCredentialStore { .entries .lock() .map_err(|_| CredentialStoreError::Unavailable)?; + let _writer = self.writer_lock()?; + self.refresh(&mut entries)?; let mut next = entries.clone(); let result = mutation(&mut next)?; persist_entries(&self.path, &next, self.maximum_bytes)?; @@ -619,6 +621,82 @@ impl PersistentCredentialStore { Ok(result) } + /// Cross-process mutations use one stable sidecar, not the database inode + /// that atomic rename replaces. Contention fails immediately and cannot + /// acknowledge custody. A reader's snapshot is ordered with these writers. + fn writer_lock(&self) -> Result { + let parent = self + .path + .parent() + .ok_or(CredentialStoreError::UnsafeStorage)?; + validate_parent(parent)?; + let mut name = self.path.as_os_str().to_os_string(); + name.push(".lock"); + let path = PathBuf::from(name); + let mut options = OpenOptions::new(); + options.read(true).write(true).create_new(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt as _; + options.mode(0o600); + } + let lock = match options.open(&path) { + Ok(lock) => lock, + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => { + validate_secret_file(&path, 0)?; + OpenOptions::new() + .read(true) + .write(true) + .open(&path) + .map_err(|_| CredentialStoreError::Unavailable)? + } + Err(_) => return Err(CredentialStoreError::Unavailable), + }; + lock.try_lock() + .map_err(|_| CredentialStoreError::Unavailable)?; + validate_secret_file(&path, 0)?; + #[cfg(unix)] + { + use std::os::unix::fs::MetadataExt as _; + let opened = lock + .metadata() + .map_err(|_| CredentialStoreError::Unavailable)?; + let named = + fs::symlink_metadata(&path).map_err(|_| CredentialStoreError::Unavailable)?; + if opened.dev() != named.dev() || opened.ino() != named.ino() || opened.nlink() != 1 { + return Err(CredentialStoreError::UnsafeStorage); + } + } + Ok(lock) + } + + fn refresh( + &self, + entries: &mut BTreeMap<(String, u64), StoredSecret>, + ) -> Result<(), CredentialStoreError> { + match fs::symlink_metadata(&self.path) { + Err(error) if error.kind() == std::io::ErrorKind::NotFound && entries.is_empty() => { + return Ok(()); + } + Err(_) => return Err(CredentialStoreError::Unavailable), + Ok(_) => {} + } + *entries = read_persistent_entries(&self.path, self.maximum_entries, self.maximum_bytes)?; + Ok(()) + } + + fn current_entries( + &self, + ) -> Result>, CredentialStoreError> { + let mut entries = self + .entries + .lock() + .map_err(|_| CredentialStoreError::Unavailable)?; + let _writer = self.writer_lock()?; + self.refresh(&mut entries)?; + Ok(entries) + } + fn total_bytes(entries: &BTreeMap<(String, u64), StoredSecret>) -> usize { entries.values().map(|entry| entry.bytes.len()).sum() } @@ -641,10 +719,7 @@ impl PersistentCredentialStore { connection_id: &ConnectionId, generation: NonZeroU64, ) -> Result { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; retained_entry(&entries, connection_id, generation) .map(|(_, entry)| entry.commitment) .ok_or(CredentialStoreError::Unavailable) @@ -661,10 +736,7 @@ impl PersistentCredentialStore { &self, connection_id: &ConnectionId, ) -> Result, CredentialStoreError> { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; Ok(connection_generations(&entries, connection_id) .filter_map(NonZeroU64::new) .collect()) @@ -689,10 +761,7 @@ impl PersistentCredentialStore { record: &ConnectionRecord, deadline: Instant, ) -> Result { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; let stored = record_entry(&entries, record)?; Ok(StoredSecretLease { bytes: stored.bytes.clone(), @@ -710,10 +779,7 @@ impl PersistentCredentialStore { &self, record: &ConnectionRecord, ) -> Result<(), CredentialStoreError> { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; record_entry(&entries, record).map(|_| ()) } @@ -976,10 +1042,7 @@ impl ConnectionCredentialStore for PersistentCredentialStore { binding: &CredentialBinding, deadline: Instant, ) -> Result { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; let stored = binding_entry(&entries, binding)?; Ok(StoredSecretLease { bytes: stored.bytes.clone(), @@ -1047,10 +1110,7 @@ impl ConnectionCredentialStore for PersistentCredentialStore { } async fn holds(&self, binding: &CredentialBinding) -> Result<(), CredentialStoreError> { - let entries = self - .entries - .lock() - .map_err(|_| CredentialStoreError::Unavailable)?; + let entries = self.current_entries()?; binding_entry(&entries, binding).map(|_| ()) } @@ -1124,6 +1184,37 @@ fn validate_secret_file(path: &Path, maximum_bytes: usize) -> Result<(), Credent Ok(()) } +fn read_persistent_entries( + path: &Path, + maximum_entries: usize, + maximum_bytes: usize, +) -> Result, CredentialStoreError> { + validate_secret_file(path, maximum_bytes)?; + let mut file = File::open(path).map_err(|_| CredentialStoreError::Unavailable)?; + let length = usize::try_from( + file.metadata() + .map_err(|_| CredentialStoreError::Unavailable)? + .len(), + ) + .map_err(|_| CredentialStoreError::Capacity)?; + if length > maximum_bytes { + return Err(CredentialStoreError::Capacity); + } + // Allocate once: growing a secret-bearing Vec can strand an unwiped copy. + let mut bytes = Zeroizing::new(vec![0; length]); + file.read_exact(&mut bytes) + .map_err(|_| CredentialStoreError::Unavailable)?; + let mut extra = Zeroizing::new([0_u8; 1]); + if file + .read(&mut *extra) + .map_err(|_| CredentialStoreError::Unavailable)? + != 0 + { + return Err(CredentialStoreError::UnsafeStorage); + } + decode_persistent_entries(&bytes, maximum_entries, maximum_bytes) +} + fn persist_entries( path: &Path, entries: &BTreeMap<(String, u64), StoredSecret>, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index d7edb6150..93a8ae570 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"4e288905ff4d1c938d2750194abfc24dd0ee046880c9e4b218127eaf347ad567"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"6558cda21bdf40cf779f0d6f4195a503ed082b2823128b451a0b3dc7d0ead7b5"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5fafabc2a65b6c1ec909d39ab6cc9df668b2fa4db16f279ddbd278ada4cd0391"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"2632418325436b5c2f57a57181d162c390bb7fc3311c08e69e71016b1d9c311a"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"dd793454291d5858d0787ca09065595af235a5eae14dda3e2de6fa7c07482cb7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"0a95c9612a06e45e5293e380f9d4627cbe2eb55fdedc769b9b33bd3d40de2db5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"be62eaf2e76fdaab414d65a12ad92252eeaa90e73b014915e55883a0c2fff7d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"d801fc44b7d2450c8667c15cd3730860621062295839aeda99d320dbd31af35d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"9eeea954a62cb66e3abfad3a2c3b996a72c6b44175aeb5a3710ddea4c2465cf0"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"928e7e7283b2bd90099f6ab93c48a4d65915853c9a1b32176cc58b3738d8ee49"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"7405569876e7e95f8a7f703cbdd46ccae0ae6d9159b54fa0b7f35034556f9db4"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4833c83ed7d170777dbedb84716e98cd0319dae087ce53cc428a3ecd6e2d249c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 339c86a1f..dccfcfb90 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -188,8 +188,11 @@ mod unix { #[arg(long)] state_dir: PathBuf, /// Compile independent read authority for this retained source. - #[arg(long)] + #[arg(long, conflicts_with = "candidate")] recovery_of: Option, + /// Private staged candidate proposal for credential-check review. + #[arg(long, conflicts_with = "recovery_of")] + candidate: Option, #[arg(long)] proof: PathBuf, #[arg(long)] @@ -202,6 +205,56 @@ mod unix { #[arg(long)] request_out: PathBuf, }, + /// Operator-only: stage a rotation secret from stdin and save its exact + /// private proposal. No provider read, lease or publication occurs. + CandidateStageRotation { + #[arg(long)] + state_dir: PathBuf, + #[arg(long, required = true)] + credential_stdin: bool, + #[arg(long)] + proposal_out: PathBuf, + }, + /// Author the native call for exact staged candidate checks. No I/O + /// authority or completed-check claim is created. + EffectCandidateCall { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + candidate: PathBuf, + #[arg(long)] + operation: String, + #[arg(long)] + call_out: PathBuf, + }, + /// Execute independently authorized staged credential checks using the + /// runtime custody identity; returns redacted acquisition facts only. + CandidateAcquire { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + candidate: PathBuf, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + }, + /// Operator-only: publish an exact candidate from fresh retained checks. + /// Performs no provider I/O and creates no new read allocation. + CandidatePublish { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + candidate: PathBuf, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + }, /// Author the exact private call for an independently authorized /// recovery read. No proof, approval, reservation or entry is created. EffectRecoveryCall { @@ -596,7 +649,8 @@ mod unix { #[arg(long)] state_dir: PathBuf, }, - /// Rotate the credential via the private operator socket and stdin. + /// Offline rotation for recipes without credential reads. Read-bearing + /// recipes use candidate-stage-rotation, candidate-acquire and candidate-publish. Rotate { #[arg(long)] state_dir: PathBuf, @@ -611,7 +665,7 @@ mod unix { #[arg(long, default_value_t = false)] operator_process: bool, }, - /// First phase of a two-phase rotation: store the new credential + /// Offline recipes only. First phase of a two-phase rotation: store the new credential /// from stdin without publishing it, and print its commitment. RotatePrepare { #[arg(long)] @@ -627,7 +681,7 @@ mod unix { #[arg(long, default_value_t = false)] operator_process: bool, }, - /// Second phase: publish the prepared credential the commitment + /// Offline recipes only. Second phase: publish the prepared credential the commitment /// names to every process sharing the store. RotateCommit { #[arg(long)] @@ -3062,10 +3116,25 @@ mod unix { .map_err(|_| "gateway.effect.approval") } + fn read_candidate( + state_dir: &Path, + path: &Path, + ) -> Result { + let metadata = fs::symlink_metadata(path).map_err(|_| "gateway.state.invalid-path")?; + if !metadata.file_type().is_file() || metadata.permissions().mode() & 0o077 != 0 { + return Err("gateway.state.invalid-path".into()); + } + let recipe = installed_recipe(state_dir)?; + let bytes = Zeroizing::new(read_bounded(path, auths_gateway::effect::MAX_EFFECT_BYTES)?); + auths_gateway::effect::CandidateCredentialTarget::from_private_bytes(&recipe, &bytes) + .map_err(|_| "gateway.effect.review-refused".into()) + } + #[allow(clippy::too_many_arguments)] async fn effect_review( state_dir: PathBuf, recovery_of: Option, + candidate: Option, proof: PathBuf, action: PathBuf, not_before: u64, @@ -3076,18 +3145,28 @@ mod unix { if !request_out.is_absolute() { return Err("gateway.state.invalid-path".into()); } + let candidate = candidate + .as_ref() + .map(|path| read_candidate(&state_dir, path)) + .transpose()?; let engine = tokio::task::spawn_blocking(move || load_engine(&state_dir)) .await .map_err(|_| "gateway.effect.unavailable")??; let proof = read_bounded(&proof, 4 * 1024 * 1024)?; let action = read_bounded(&action, 64 * 1024)?; - let effect = match recovery_of { - Some(source) => { + let effect = match (recovery_of, candidate) { + (Some(source), None) => { engine .compile_recovery_effect(&source, &proof, &action) .await } - None => engine.compile_effect(&proof, &action).await, + (None, Some(target)) => { + engine + .compile_candidate_effect(&target, &proof, &action) + .await + } + (None, None) => engine.compile_effect(&proof, &action).await, + (Some(_), Some(_)) => return Err("gateway.effect.review-refused".into()), } .map_err(|_| "gateway.effect.review-refused")?; let request = effect @@ -3884,9 +3963,113 @@ mod unix { .map_err(|_| "gateway.configuration.unavailable")??; Ok(()) } + Command::CandidateStageRotation { + state_dir, + credential_stdin, + proposal_out, + } => { + if !credential_stdin || std::io::stdin().is_terminal() { + return Err("gateway.admin.credential-must-be-piped-to-stdin".into()); + } + if !proposal_out.is_absolute() || proposal_out.exists() { + return Err("gateway.state.file-exists-or-unavailable".into()); + } + let candidate = read_install_credential()?; + let engine = operator_engine(&state_dir).await?; + let proposal = engine.stage_candidate_rotation(candidate).await?; + private_file( + &proposal_out, + &proposal + .to_private_bytes() + .map_err(|_| "gateway.effect.review-refused")?, + )?; + println!("credential candidate staged; private proposal saved"); + Ok(()) + } + Command::EffectCandidateCall { + state_dir, + candidate, + operation, + call_out, + } => { + if !call_out.is_absolute() { + return Err("gateway.state.invalid-path".into()); + } + let target = read_candidate(&state_dir, &candidate)?; + let recipe = installed_recipe(&state_dir)?; + let operation = auths_gateway::LogicalOperationId::parse(&operation) + .map_err(|_| "gateway.effect.review-refused")?; + let call = target + .authorization_call(&recipe, &operation) + .map_err(|_| "gateway.effect.review-refused")?; + let bytes = Zeroizing::new( + serde_json_canonicalizer::to_vec(&call).map_err(|_| "gateway.output")?, + ); + private_file(&call_out, &bytes)?; + println!( + "private candidate call saved; native proof and exact approval still required" + ); + Ok(()) + } + Command::CandidateAcquire { + state_dir, + candidate, + proof, + action, + approval, + } => { + let target = read_candidate(&state_dir, &candidate)?; + let proof = read_bounded(&proof, 4 * 1024 * 1024)?; + let action = read_bounded(&action, 64 * 1024)?; + let approval = read_effect_approval(&approval)?; + let engine = tokio::task::spawn_blocking(move || load_engine(&state_dir)) + .await + .map_err(|_| "gateway.effect.unavailable")??; + match engine + .acquire_candidate_credential(&target, &proof, &action, approval) + .await + { + Ok(snapshot) => { + println!( + "{}", + serde_json::to_string(&snapshot).map_err(|_| "gateway.output")? + ); + Ok(()) + } + Err(result) => { + println!( + "{}", + serde_json::to_string(&result).map_err(|_| "gateway.output")? + ); + Err("gateway.effect.review-refused".into()) + } + } + } + Command::CandidatePublish { + state_dir, + candidate, + proof, + action, + approval, + } => { + let target = read_candidate(&state_dir, &candidate)?; + let proof = read_bounded(&proof, 4 * 1024 * 1024)?; + let action = read_bounded(&action, 64 * 1024)?; + let approval = read_effect_approval(&approval)?; + let engine = operator_engine(&state_dir).await?; + let outcome = engine + .publish_candidate_credential(&target, &proof, &action, approval) + .await?; + println!( + "{}", + serde_json::to_string(&outcome).map_err(|_| "gateway.output")? + ); + Ok(()) + } Command::EffectReview { state_dir, recovery_of, + candidate, proof, action, not_before, @@ -3896,6 +4079,7 @@ mod unix { effect_review( state_dir, recovery_of, + candidate, proof, action, not_before, diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index 543326551..7313e27e0 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -6,6 +6,83 @@ use crate::effect::{BoundEffect, CandidateCredentialTarget, compile_candidate_cr use crate::submit::AcquisitionIo; impl GatewayEngine { + /// Stages an operator-supplied rotation secret without leasing it or + /// contacting the provider. The exact proposal can be persisted for native + /// read authorization and approval. It never publishes the connection. + /// Existing successor custody is never revoked or overwritten; a different + /// secret at that generation fails. Cleanup notes precede the custody write. + /// Only the trusted operator service may call this method. + /// + /// # Errors + /// Refuses revoked/changed connections, missing current custody, invalid + /// credential syntax/prefix, recipes without candidate reads, exhausted + /// generations, conflicting staged custody or unavailable durable state. + /// A custody failure can be ambiguous: retained cleanup notes remain and + /// no automatic deletion or publication follows an error. + pub async fn stage_candidate_rotation( + &self, + mut candidate: zeroize::Zeroizing>, + ) -> Result { + self.check_effect_configuration().await?; + let current = self.load_for_admin().await?; + let record = current.record(); + if record.state() == ConnectionState::Revoked { + return Err("gateway.admin.connection-not-active"); + } + if self + .recipe + .guard_checks() + .as_ref() + .is_some_and(|guard| !guard.admits_secret(&candidate)) + { + return Err("gateway.admin.credential-guard"); + } + let now = self + .qualification + .effect_time() + .ok_or("gateway.admin.clock-unavailable")?; + let proposed = record + .rotated( + record.descriptor().to_vec(), + *record.account_commitment(), + [0; 32], + now, + ) + .map_err(|_| "gateway.admin.transition-unavailable")?; + // Validate the complete relationship/check plan before touching custody. + CandidateCredentialTarget::new(&self.recipe, &proposed, Some(record)) + .map_err(|_| "gateway.admin.transition-unavailable")?; + self.holds(record) + .await + .map_err(|_| "gateway.admin.credential-unavailable")?; + let secret = SecretBytes::new(std::mem::take(&mut *candidate)) + .map_err(|_| "gateway.admin.invalid-credential")?; + self.note_credential(record, proposed.credential_generation()) + .await?; + let reference = self + .credentials + .replace( + record.connection_id(), + record.generation(), + proposed.credential_generation(), + secret, + ) + .await + .map_err(|_| "gateway.admin.credential-unavailable")?; + let proposed = record + .rotated( + record.descriptor().to_vec(), + *record.account_commitment(), + *reference.as_bytes(), + now, + ) + .map_err(|_| "gateway.admin.transition-unavailable")?; + let target = CandidateCredentialTarget::new(&self.recipe, &proposed, Some(record)) + .map_err(|_| "gateway.admin.transition-unavailable")?; + self.check_candidate_predecessor(&target).await?; + Ok(target) + } + /// Compiles independently authorized checks for a staged credential. The /// exact predecessor/absence must currently match; no custody or provider /// I/O occurs. The final entry transaction repeats this check under its fence. diff --git a/product/runtime/auths-gateway/src/connection.rs b/product/runtime/auths-gateway/src/connection.rs index e35aa3391..e911085f4 100644 --- a/product/runtime/auths-gateway/src/connection.rs +++ b/product/runtime/auths-gateway/src/connection.rs @@ -339,8 +339,7 @@ pub async fn install_connection( } /// Joins a further process to an installed connection: loads the shared -/// record, runs every credential check the recipe declares against the -/// record's account commitment, and stores `candidate` at the record's +/// record and stores `candidate` at the record's /// credential generation only when its reference commitment there equals /// the record's, compared in constant time. Because the commitment is bound /// to the credential generation rather than the current generation, a join @@ -349,8 +348,8 @@ pub async fn install_connection( /// /// # Errors /// Returns `gateway.install.join-record-missing` without a record, -/// `gateway.install.join-commitment-mismatch` for another secret, the -/// onboarding codes of a refused candidate, and store codes otherwise. +/// `gateway.install.join-commitment-mismatch` for another secret, +/// and store codes otherwise. No provider read is performed. pub async fn join_connection( shared: &SharedConnection, credentials: &dyn ConnectionCredentialStore, @@ -368,14 +367,9 @@ pub async fn join_connection( } crate::GatewayConnectionDescriptor::from_record(record, recipe) .map_err(|_| "gateway.install.join-recipe-mismatch")?; - crate::onboarding::check_candidate_credential( - recipe, - recipe.review().credential(), - candidate, - crate::onboarding::OnboardingAccount::Commitment(*record.account_commitment()), - ) - .await - .map_err(crate::onboarding::OnboardingFailure::install_code)?; + // Joining confirms exactly the already-published secret. It does not + // acquire new provider evidence or authorize a changed credential. + let secret = SecretBytes::new(candidate.to_vec()).map_err(|_| "gateway.install.invalid-credential")?; match credentials diff --git a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs new file mode 100644 index 000000000..d79f89242 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs @@ -0,0 +1,266 @@ +//! Actual durable custody and engine staging; no provider execution claim. +use super::*; +use auths_connections::{ConnectionCredentialStore, PersistentCredentialStore, SecretBytes}; +use std::{num::NonZeroU64, sync::Arc}; + +pub(super) async fn histories( + recipe: &CompiledRecipe, + trust: &auths_model::TrustedContext, + policy: &EffectPolicy, +) -> Value { + let mut cases = Vec::new(); + for case in [ + "active", + "disabled", + "revoked", + "missing-journal", + "bad-prefix", + ] { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private directory"); + } + let credentials_path = root.join("credentials.cbor"); + let credentials = + Arc::new(PersistentCredentialStore::open(&credentials_path).expect("custody")); + let store: Arc = + Arc::new(crate::FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); + let attempts = + crate::GatewayAttempts::new(Arc::clone(&store), policy.clone()).expect("attempts"); + let template = connection_account( + recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + let first = credentials + .install( + template.connection_id(), + NonZeroU64::MIN, + SecretBytes::new(b"rk_test_initial".to_vec()).expect("secret"), + ) + .await + .expect("custody install"); + let record = ConnectionRecord::new( + template.provider_kind().clone(), + template.alias().clone(), + template.connection_id().clone(), + SemanticId::parse("auths.gateway-operation/1").expect("contract"), + SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), + template.descriptor().to_vec(), + *template.account_commitment(), + *first.as_bytes(), + NonZeroU64::MIN, + ConnectionState::Active, + template.allowed_workloads().to_vec(), + template.allowed_profiles().to_vec(), + NOW - 100, + NOW - 100, + None, + ) + .expect("record"); + let record = match case { + "disabled" => record + .transition_state(ConnectionState::Disabled, NOW - 10) + .expect("disable"), + "revoked" => record + .transition_state(ConnectionState::Revoked, NOW - 10) + .expect("revoke"), + _ => record, + }; + let shared = crate::SharedConnection::new( + Arc::clone(&store), + record.provider_kind().clone(), + record.alias().clone(), + ); + shared.insert(&record).await.expect("insert"); + let journal = crate::CredentialJournal::new(root.clone()); + if case != "missing-journal" { + journal.initialize(record.connection_id()).expect("journal"); + journal + .register(record.connection_id(), record.credential_generation()) + .expect("first note"); + } + let floor = crate::GenerationFloor::new(root.clone()); + floor.initialize(&record).expect("floor"); + let engine = crate::GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &auths_codec::encode_verifier_context(trust).expect("trust"), + policy.clone(), + record.provider_kind().clone(), + record.alias().clone(), + "gateway".to_owned(), + record.allowed_profiles()[0].clone(), + credentials.clone(), + attempts, + ) + .expect("engine") + .with_credential_journal(journal.clone()) + .with_generation_floor(floor) + .with_qualification(Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(NOW))), + auths_recipe_qualification::VerifierState::default(), + ))); + engine + .initialize_effect_configuration() + .expect("configuration"); + let stale = + PersistentCredentialStore::open(&credentials_path).expect("second pre-staging handle"); + let before = engine.execution_witness(); + assert_eq!( + engine + .rotate_connection(zeroize::Zeroizing::new(b"rk_test_direct".to_vec())) + .await + .unwrap_err(), + "gateway.admin.candidate-approval-required" + ); + assert_eq!( + engine + .prepare_rotation(zeroize::Zeroizing::new(b"rk_test_direct".to_vec())) + .await + .unwrap_err(), + "gateway.admin.candidate-approval-required" + ); + assert_eq!( + engine.commit_rotation([7; 32]).await.unwrap_err(), + "gateway.admin.candidate-approval-required" + ); + + let secret = if case == "bad-prefix" { + b"sk_live_invalid".as_slice() + } else { + b"rk_test_stage".as_slice() + }; + let result = engine + .stage_candidate_rotation(zeroize::Zeroizing::new(secret.to_vec())) + .await; + if matches!(case, "active" | "disabled") { + let target = result.expect("staged"); + assert_eq!(target.record().state(), record.state()); + assert_eq!( + target.record().generation().get(), + record.generation().get() + 1 + ); + assert_eq!( + target.record().credential_generation(), + target.record().generation() + ); + assert_eq!(target.previous(), Some(&record)); + assert!( + credentials + .holds(&record.credential_binding()) + .await + .is_ok() + ); + assert!( + credentials + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + assert!( + stale + .holds(&target.record().credential_binding()) + .await + .is_ok(), + "a preexisting reader refreshes custody" + ); + assert!( + stale + .replace( + record.connection_id(), + record.generation(), + target.record().credential_generation(), + SecretBytes::new(b"rk_test_stale".to_vec()).expect("secret") + ) + .await + .is_err(), + "a stale writer cannot overwrite the committed candidate" + ); + let bytes = target.to_private_bytes().expect("proposal"); + let repeated = engine + .stage_candidate_rotation(zeroize::Zeroizing::new(secret.to_vec())) + .await + .expect("idempotent custody stage"); + assert_eq!(repeated.to_private_bytes().expect("repeated"), bytes); + assert!( + engine + .stage_candidate_rotation(zeroize::Zeroizing::new(b"rk_test_other".to_vec())) + .await + .is_err(), + "never overwrite a staged candidate" + ); + let reopened = PersistentCredentialStore::open(&credentials_path).expect("reopen"); + assert!(reopened.holds(&record.credential_binding()).await.is_ok()); + assert!( + reopened + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + let generations = reopened + .stored_generations(record.connection_id()) + .expect("generations"); + assert_eq!( + generations, + vec![ + record.credential_generation(), + target.record().credential_generation() + ] + ); + assert_eq!( + journal.generations(record.connection_id()).expect("notes"), + generations + ); + reopened + .revoke( + record.connection_id(), + target.record().credential_generation(), + ) + .await + .expect("delete staged generation"); + assert!( + stale + .holds(&target.record().credential_binding()) + .await + .is_err(), + "completed deletion is visible to a stale reader" + ); + assert!( + stale.holds(&record.credential_binding()).await.is_ok(), + "current credential remains" + ); + cases.push(json!({"case": case, "staged_generation": target.record().credential_generation().get(), "same_secret_idempotent": true, "different_secret_refused": true, "reopen_retains_current_and_candidate": true, "cleanup_notes_retained": true, "preexisting_reader_refreshes_custody": true, "stale_writer_cannot_overwrite": true, "completed_delete_visible_to_stale_reader": true})); + } else { + assert!(result.is_err(), "{case}"); + assert_eq!( + credentials + .stored_generations(record.connection_id()) + .expect("generations"), + vec![record.credential_generation()] + ); + cases.push(json!({"case": case, "refused_without_custody_change": true})); + } + assert_eq!( + shared + .load() + .await + .expect("load") + .expect("current") + .record(), + &record + ); + assert_eq!( + engine.execution_witness(), + before, + "no lease or provider entry" + ); + } + json!({"schema": "auths.candidate-staging-fixture/1", "scope": "actual engine, persistent file custody, generation floor and cleanup journal; fixed deployment clock; no provider execution, process crash or PostgreSQL claim", "cases": cases}) +} diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index 5c2680b6d..abe4077ae 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -1,5 +1,7 @@ //! Native candidate compilation, acquisition and fenced publication corpus. use super::*; +#[path = "effect_candidate_staging_tests.rs"] +mod staging; use crate::effect::{ CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, }; @@ -23,6 +25,7 @@ async fn native_candidate_compilation_fixture_is_current() { let mut cases = Vec::new(); let mut journal_cases = Vec::new(); let mut capacity_cases = Vec::new(); + let mut staging_cases = Value::Null; let capacity_directory = tempfile::tempdir().expect("capacity directory"); let capacity_store = std::sync::Arc::new( crate::FileGatewayAttemptStore::open( @@ -173,6 +176,9 @@ async fn native_candidate_compilation_fixture_is_current() { ) .expect("grant"); let submission = submission_for_call(&root, &reader, &grant, &call, &[]); + if case == "rotation" { + staging_cases = staging::histories(&recipe, &trust, &policy).await; + } let installed = policy.installation( &recipe, &trust, @@ -559,6 +565,13 @@ async fn native_candidate_compilation_fixture_is_current() { std::fs::write(&path, &fixture).expect("write fixture"); } assert_eq!(std::fs::read(path).expect("fixture"), fixture); + let fixture = serde_json::to_vec_pretty(&staging_cases).expect("staging fixture"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/candidate-staging.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("staging write"); + } + assert_eq!(std::fs::read(path).expect("staging fixture"), fixture); } #[allow( diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 1f9d95b91..863191b40 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -808,41 +808,32 @@ impl GatewayEngine { Ok(self.drained("gateway.admin.enabled").await) } - /// Rotates the operator-held secret. - /// - /// The candidate must first pass every declared credential check: the - /// prefix, the probe, the account read against the record's commitment, - /// and the denied reads. A process that holds the record's current secret - /// commits a rotation: it stores the candidate at the next generation and - /// publishes the rotated record, which makes that generation the - /// credential generation. A process that does not hold it, because the - /// rotation was committed through another process, takes the candidate - /// into its own store at the credential generation only when its - /// reference commitment there equals the record's. A later disable or - /// enable leaves both valid. + /// Rotates an operator-held secret only for a recipe with no provider + /// credential reads. Read-bearing recipes require `stage_candidate_rotation`, + /// separately approved acquisition, and `publish_candidate_credential`. + /// A peer may take an already-published exact secret into local custody. /// /// # Errors - /// A refused candidate, a commitment that does not match, or a failed - /// durable transition never reports the rotation complete. + /// Refuses read-bearing recipes before custody or provider I/O, invalid + /// secret prefixes, substitution and unavailable durable state. pub async fn rotate_connection( &self, candidate: zeroize::Zeroizing>, ) -> Result { + self.require_offline_rotation()?; let current = self.load_for_admin().await?; let record = current.record(); if record.state() == ConnectionState::Revoked { return Err("gateway.admin.connection-not-active"); } - // The provider reads run before anything is stored or committed, - // and no submission waits on them. - crate::onboarding::check_candidate_credential( - &self.recipe, - self.recipe.review().credential(), - &candidate, - crate::onboarding::OnboardingAccount::Commitment(*record.account_commitment()), - ) - .await - .map_err(crate::onboarding::OnboardingFailure::admin_code)?; + if self + .recipe + .guard_checks() + .as_ref() + .is_some_and(|guard| !guard.admits_secret(&candidate)) + { + return Err("gateway.admin.credential-guard"); + } let mut candidate = candidate; let secret = SecretBytes::new(std::mem::take(&mut *candidate)) .map_err(|_| "gateway.admin.invalid-credential")?; @@ -863,6 +854,18 @@ impl GatewayEngine { committed } + /// Offline operator rotation cannot bypass any recipe-declared read. + fn require_offline_rotation(&self) -> Result<(), &'static str> { + let reads = self + .recipe + .credential_reads() + .map_err(|_| "gateway.admin.transition-unavailable")?; + if reads.probe().is_some() || reads.account().is_some() || !reads.denied().is_empty() { + return Err("gateway.admin.candidate-approval-required"); + } + Ok(()) + } + /// Stores `secret` at the generation after `record`'s without changing /// the shared record, and returns its reference commitment. Nothing /// leases the stored secret until a commit publishes it. @@ -909,10 +912,10 @@ impl GatewayEngine { } } - /// The first phase of a two-phase rotation: checks the candidate against - /// the recipe's declared credential checks, stores it at the next - /// generation, and returns its reference commitment. The shared record - /// is unchanged, so every process keeps serving the current credential. + /// The first phase of an offline two-phase rotation: checks the secret + /// prefix, stores it at the next generation and returns its reference + /// commitment. Recipes with provider reads require the candidate workflow. + /// The shared record is unchanged, so every process keeps serving the current credential. /// It works on a disabled connection, which is how a possibly /// compromised credential is replaced. /// @@ -923,19 +926,20 @@ impl GatewayEngine { &self, candidate: zeroize::Zeroizing>, ) -> Result<[u8; 32], &'static str> { + self.require_offline_rotation()?; let current = self.load_for_admin().await?; let record = current.record(); if record.state() == ConnectionState::Revoked { return Err("gateway.admin.connection-not-active"); } - crate::onboarding::check_candidate_credential( - &self.recipe, - self.recipe.review().credential(), - &candidate, - crate::onboarding::OnboardingAccount::Commitment(*record.account_commitment()), - ) - .await - .map_err(crate::onboarding::OnboardingFailure::admin_code)?; + if self + .recipe + .guard_checks() + .as_ref() + .is_some_and(|guard| !guard.admits_secret(&candidate)) + { + return Err("gateway.admin.credential-guard"); + } let mut candidate = candidate; let secret = SecretBytes::new(std::mem::take(&mut *candidate)) .map_err(|_| "gateway.admin.invalid-credential")?; @@ -945,7 +949,8 @@ impl GatewayEngine { self.store_successor(record, secret).await } - /// The second phase: replaces the credential generation and reference + /// The second phase for recipes without provider credential reads: + /// replaces the credential generation and reference /// commitment in the shared record with one compare-and-swap, only when /// the store holds, at the next generation, exactly the secret /// `commitment` names. The superseded generation is kept for the @@ -959,6 +964,7 @@ impl GatewayEngine { &self, commitment: [u8; 32], ) -> Result { + self.require_offline_rotation()?; let current = self.load_for_admin().await?; if current.record().state() == ConnectionState::Revoked { return Err("gateway.admin.connection-not-active"); diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 65a611fbe..45725b212 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -81,6 +81,7 @@ const ROWS: &[&str] = &[ "gateway.trust.key-aliased install install-and-serve new 5 -", "gateway.trust.observer-key-in-authority-chain engine before-claim new 5 -", "gateway.observer.credential-guard observer observe new 3 -", + "gateway.admin.candidate-approval-required admin admin new 74 -", "gateway.admin.credential-account admin admin new 3 -", "gateway.admin.credential-capability admin admin new 3 -", "gateway.admin.credential-guard admin admin new 3 -", diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 551d44f3b..3da0be38a 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0d479f49488df1cf1724933505c120f2bc1a367d0243f722f5d7a42e65a0ef84"; + "d59a602cc911c37118512d0e603050e4ffbc48d14e42c4aa9f6b114052902b2b"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/candidate_cli.rs b/product/runtime/auths-gateway/tests/candidate_cli.rs new file mode 100644 index 000000000..4c6908cd1 --- /dev/null +++ b/product/runtime/auths-gateway/tests/candidate_cli.rs @@ -0,0 +1,328 @@ +//! Production candidate CLI over private synthetic installation files and real +//! local custody. No approved provider acquisition or publication is claimed. +#![cfg(unix)] + +use auths_connections::{ + ConnectionAlias, ConnectionCredentialStore, ConnectionId, ConnectionProfile, ConnectionRecord, + ConnectionState, PersistentCredentialStore, ProviderKind, SecretBytes, SemanticId, +}; +use auths_gateway::{ + CompiledRecipe, FileGatewayAttemptStore, GatewayAttempts, GatewayEngine, QualificationGate, + SharedConnection, +}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use serde_json::{Value, json}; +use sha2::{Digest as _, Sha256}; +use std::{ + io::Write as _, + num::NonZeroU64, + os::unix::fs::PermissionsExt as _, + path::Path, + process::{Command, Stdio}, + sync::Arc, +}; + +fn private(path: &Path, bytes: &[u8]) { + std::fs::write(path, bytes).expect("private write"); + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("private mode"); +} + +fn spawn_stage(root: &Path, out: &Path) -> std::process::Child { + Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("candidate-stage-rotation") + .arg("--state-dir") + .arg(root) + .arg("--credential-stdin") + .arg("--proposal-out") + .arg(out) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("stage CLI") +} + +fn stage(root: &Path, out: &Path, secret: &[u8]) -> std::process::Output { + let mut child = spawn_stage(root, out); + child + .stdin + .take() + .expect("stdin") + .write_all(secret) + .expect("secret input"); + child.wait_with_output().expect("stage output") +} + +#[tokio::test] +async fn native_candidate_cli_fixture_is_current() { + let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let recipes: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("hostile-recipes-v2.json")).expect("recipes"), + ) + .expect("JSON"); + let source = serde_json::to_vec(&recipes["bases"]["stripe"]["recipe"]).expect("recipe"); + let lock = serde_json::to_vec(&recipes["bases"]["stripe"]["lock"]).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("compile"); + let input: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("approval-quorum.json")).expect("trust fixture"), + ) + .expect("JSON"); + let trust = + Base64UrlUnpadded::decode_vec(input["trusted_context_b64"].as_str().expect("context")) + .expect("decode"); + let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) + .verifying_key() + .to_bytes(); + let policy = + auths_gateway::effect::EffectPolicy::new("candidate-cli-test".to_owned(), 1, public) + .expect("policy"); + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let store = Arc::new(FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); + let attempts = GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"); + let provider = ProviderKind::parse("stripe").expect("provider"); + let alias = ConnectionAlias::parse("synthetic").expect("alias"); + let id = ConnectionId::parse("conn_AAAAAAAAAAAAAAAAAAAAAA").expect("id"); + let profile = ConnectionProfile::new(SemanticId::parse("auths.mcp").expect("profile"), 2) + .expect("profile"); + let credentials = + Arc::new(PersistentCredentialStore::open(root.join("credentials.cbor")).expect("custody")); + let reference = credentials + .install( + &id, + NonZeroU64::MIN, + SecretBytes::new(b"rk_test_initial".to_vec()).expect("secret"), + ) + .await + .expect("initial custody"); + let record = ConnectionRecord::new( + provider.clone(), + alias.clone(), + id.clone(), + SemanticId::parse("auths.gateway-operation/1").expect("contract"), + SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), + auths_gateway::GatewayConnectionDescriptor::approve(&recipe, "Authorization") + .expect("descriptor") + .to_bytes() + .expect("bytes"), + [4; 32], + *reference.as_bytes(), + NonZeroU64::MIN, + ConnectionState::Active, + vec!["gateway".to_owned()], + vec![profile.clone()], + 1_790_000_000, + 1_790_000_000, + None, + ) + .expect("record"); + let shared = SharedConnection::new(store, provider.clone(), alias.clone()); + shared.insert(&record).await.expect("initial record"); + auths_gateway::GenerationFloor::new(root.clone()) + .initialize(&record) + .expect("floor"); + let journal = auths_gateway::CredentialJournal::new(root.clone()); + journal.initialize(&id).expect("journal"); + journal.register(&id, NonZeroU64::MIN).expect("note"); + let engine = GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &trust, + policy.clone(), + provider, + alias, + "gateway".to_owned(), + profile, + credentials, + attempts, + ) + .expect("engine") + .with_qualification(Arc::new(QualificationGate::new( + auths_gateway::QualificationPolicy::Optional, + auths_gateway::PINNED_QUALIFICATION_ROOT.map(|bytes| { + auths_recipe_qualification::QualificationTrustRoot::from_canonical_json(bytes) + .expect("pinned root") + }), + None, + Box::new(auths_gateway::DevelopmentClock), + auths_recipe_qualification::VerifierState::default(), + ))); + engine + .qualification() + .load(&auths_gateway::QualificationBundle { + signer_certificate: Vec::new(), + revocation_list: Vec::new(), + release_index: Vec::new(), + records: Vec::new(), + attestations: Vec::new(), + }); + engine + .initialize_effect_configuration() + .expect("configuration"); + for (name, bytes) in [ + ("recipe.json", &source), + ("profile.lock.json", &lock), + ("trusted.context.cbor", &trust), + ] { + private(&root.join(name), bytes); + } + private(&root.join("installation.json"), &serde_json_canonicalizer::to_vec(&json!({ + "schema": "auths.gateway-installation/6", "recipe_digest": recipe.digest_hex(), + "profile_lock_sha256": hex::encode(Sha256::digest(&lock)), "trusted_context_sha256": hex::encode(Sha256::digest(&trust)), + "effect_policy": policy, "provider": "stripe", "alias": "synthetic", "deployment": "development", + "operator_attestation_sha256": null, "attempt_store": root.join("attempts"), + "credential_store": {"kind": "local-file-v1"}, "qualification": {"policy": "optional"} + })).expect("manifest")); + let first_path = root.join("candidate-a.json"); + let second_path = root.join("candidate-b.json"); + let mut first = spawn_stage(&root, &first_path); + let mut second = spawn_stage(&root, &second_path); + first + .stdin + .take() + .expect("first stdin") + .write_all(b"rk_test_first\n") + .expect("first secret"); + second + .stdin + .take() + .expect("second stdin") + .write_all(b"rk_test_second\n") + .expect("second secret"); + let first = first.wait_with_output().expect("first process"); + let second = second.wait_with_output().expect("second process"); + assert_ne!( + first.status.success(), + second.status.success(), + "one successful staging process: first={}, second={}", + String::from_utf8_lossy(&first.stderr), + String::from_utf8_lossy(&second.stderr) + ); + let proposal = if first.status.success() { + first_path + } else { + second_path + }; + let proposal_bytes = std::fs::read(&proposal).expect("proposal"); + assert_eq!( + std::fs::metadata(&proposal) + .expect("metadata") + .permissions() + .mode() + & 0o777, + 0o600 + ); + let target = auths_gateway::effect::CandidateCredentialTarget::from_private_bytes( + &recipe, + &proposal_bytes, + ) + .expect("target"); + assert_eq!( + shared + .load() + .await + .expect("load") + .expect("current") + .record(), + &record + ); + let repeat = stage(&root, &proposal, b"rk_test_other\n"); + assert!(!repeat.status.success()); + assert_eq!( + std::fs::read(&proposal).expect("same proposal"), + proposal_bytes + ); + let conflict = stage(&root, &root.join("conflict.json"), b"rk_test_other\n"); + assert!(!conflict.status.success()); + assert!(!root.join("conflict.json").exists()); + let reopened = PersistentCredentialStore::open(root.join("credentials.cbor")).expect("reopen"); + assert_eq!( + reopened.stored_generations(&id).expect("generations"), + vec![NonZeroU64::MIN, NonZeroU64::new(2).expect("two")] + ); + let proposed: Value = serde_json::from_slice(&proposal_bytes).expect("proposal JSON"); + let staged = ConnectionRecord::from_canonical_cbor( + &hex::decode(proposed["candidate"].as_str().expect("hex")).expect("bytes"), + ) + .expect("candidate record"); + assert!(reopened.holds(&staged.credential_binding()).await.is_ok()); + let lock = std::fs::OpenOptions::new() + .read(true) + .write(true) + .open(root.join("credentials.cbor.lock")) + .expect("custody lock"); + lock.try_lock().expect("hold custody fence"); + let blocked = stage(&root, &root.join("blocked.json"), b"rk_test_blocked\n"); + assert!(!blocked.status.success()); + assert!(!root.join("blocked.json").exists()); + drop(lock); + let call_out = root.join("call.json"); + let call = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("effect-candidate-call") + .arg("--state-dir") + .arg(&root) + .arg("--candidate") + .arg(&proposal) + .arg("--operation") + .arg("candidate-cli-1") + .arg("--call-out") + .arg(&call_out) + .output() + .expect("call CLI"); + assert!( + call.status.success(), + "{}", + String::from_utf8_lossy(&call.stderr) + ); + let expected = target + .authorization_call( + &recipe, + &auths_gateway::LogicalOperationId::parse("candidate-cli-1").expect("operation"), + ) + .expect("call"); + assert_eq!( + std::fs::read(&call_out).expect("call bytes"), + serde_json_canonicalizer::to_vec(&expected).expect("native call") + ); + assert_eq!( + std::fs::metadata(&call_out) + .expect("call mode") + .permissions() + .mode() + & 0o777, + 0o600 + ); + let mut wide = std::fs::metadata(&proposal) + .expect("proposal mode") + .permissions(); + wide.set_mode(0o644); + std::fs::set_permissions(&proposal, wide).expect("wide mode"); + let refused = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("effect-candidate-call") + .arg("--state-dir") + .arg(&root) + .arg("--candidate") + .arg(&proposal) + .arg("--operation") + .arg("candidate-cli-2") + .arg("--call-out") + .arg(root.join("refused.json")) + .output() + .expect("refusal CLI"); + assert!(!refused.status.success()); + assert!(!root.join("refused.json").exists()); + let fixture = serde_json::to_vec_pretty(&json!({ + "schema": "auths.candidate-cli-fixture/1", "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", + "competing_processes_one_staging_winner": true, "held_custody_fence_refuses_without_proposal": true, + "staged_generation": 2, "current_record_unchanged": true, "proposal_and_call_mode": "0600", + "existing_proposal_refused_without_overwrite": true, "different_secret_same_generation_refused": true, + "reopened_custody_holds_exact_candidate": true, "authored_call_matches_native": true, + "permissive_proposal_refused": true + })).expect("fixture"); + let path = fixtures.join("candidate-cli.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("fixture write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} From 67506ada2dc9b3802da424c5812c4928bd5194cb Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 11:24:59 +0000 Subject: [PATCH 042/136] chore(formal): regenerate qualification artifacts Source-SHA: 1c23ca31e2a0d95d5502d15a7fc7edc15decad38 Workflow-Run: 40679363261 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index bcad68211..cad6af779 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "4bc466118a74f05c0631f7c988e6a38d661b520840957de3895b1f646d6fca44", + "digest": "49eaf38e97eb68ff43d3668591e55aea64dd2ae8d18261758bc366b07a5815bd", "files": [ { "path": ".cargo/config.toml", @@ -157,7 +157,7 @@ }, { "path": "product/runtime/auths-connections/src/credential.rs", - "sha256": "82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51" + "sha256": "83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb" }, { "path": "product/runtime/auths-connections/src/kernel.rs", From ed557dab874beed2820624ad9600df04e81a1d6e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 11:43:58 +0000 Subject: [PATCH 043/136] feat(gateway)!: stage first installs for approved credential checks --- bindings/fixtures/gateway/candidate-cli.json | 9 + .../fixtures/gateway/candidate-staging.json | 38 ++ bindings/fixtures/gateway/codes.json | 8 + compliance.toml | 4 + ...017-bound-effect-and-recovery-ownership.md | 34 ++ docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md | 36 +- docs/plans/0074-implementation-status.md | 47 ++- .../0009-bound-effect-and-recovery.md | 19 + ...ound-effects-and-recovery-state-machine.md | 12 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 284 +++++++++------ .../auths-gateway/src/candidate_runtime.rs | 104 ++++++ .../runtime/auths-gateway/src/connection.rs | 58 ++- .../src/effect_candidate_staging_tests.rs | 202 ++++++++++- product/runtime/auths-gateway/src/engine.rs | 5 +- .../auths-gateway/src/generation_floor.rs | 4 +- product/runtime/auths-gateway/src/lib.rs | 3 - .../runtime/auths-gateway/src/onboarding.rs | 334 ++++++++---------- .../src/pending_vectors/codes.rs | 1 + product/runtime/auths-gateway/src/recipe.rs | 17 + .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/candidate_cli.rs | 147 +++++++- 22 files changed, 1074 insertions(+), 296 deletions(-) diff --git a/bindings/fixtures/gateway/candidate-cli.json b/bindings/fixtures/gateway/candidate-cli.json index e2e9a8f68..5f9c55300 100644 --- a/bindings/fixtures/gateway/candidate-cli.json +++ b/bindings/fixtures/gateway/candidate-cli.json @@ -1,4 +1,13 @@ { + "first_installation": { + "production_install_stages_without_publication": true, + "private_draft_and_proposal": true, + "exact_floor_and_cleanup_note": true, + "independent_resume_process_reuses_exact_proposal": true, + "different_secret_refused": true, + "existing_output_preserved": true, + "no_approved_provider_execution_claim": true + }, "schema": "auths.candidate-cli-fixture/1", "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", "competing_processes_one_staging_winner": true, diff --git a/bindings/fixtures/gateway/candidate-staging.json b/bindings/fixtures/gateway/candidate-staging.json index 65b032228..59648d3c3 100644 --- a/bindings/fixtures/gateway/candidate-staging.json +++ b/bindings/fixtures/gateway/candidate-staging.json @@ -1,4 +1,42 @@ { + "installation": { + "direct_install_requires_approval_before_custody": true, + "cases": [ + { + "case": "staged", + "reopened_same_draft_and_secret_exact": true, + "different_secret_refused": true, + "runtime_missing_floor_refused_without_repair": true, + "explicit_restaging_exact": true, + "connection_remains_absent": true, + "cleanup_note_retained": true + }, + { + "case": "bad-prefix", + "refused": true, + "stored_generations": 0, + "no_provider_entry": true + }, + { + "case": "existing-connection", + "refused": true, + "stored_generations": 0, + "no_provider_entry": true + }, + { + "case": "substituted-floor", + "refused": true, + "stored_generations": 1, + "no_provider_entry": true + }, + { + "case": "corrupt-journal", + "refused": true, + "stored_generations": 0, + "no_provider_entry": true + } + ] + }, "schema": "auths.candidate-staging-fixture/1", "scope": "actual engine, persistent file custody, generation floor and cleanup journal; fixed deployment clock; no provider execution, process crash or PostgreSQL claim", "cases": [ diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 0e0c28591..95742f1cf 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -373,6 +373,14 @@ "id": "idempotency-window-exceeds-retention" } }, + { + "code": "gateway.install.candidate-approval-required", + "owner": "install", + "stage": "install", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.install.connection-exists", "owner": "install", diff --git a/compliance.toml b/compliance.toml index a5fe3290a..6a43a9d65 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1615,6 +1615,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-installation = [ + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", + "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", +] candidate-staging = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 7fae85310..5ca7a8bfa 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -738,3 +738,37 @@ process cache. This is a store mechanism, with no change to credential identity, read authorization or publication policy. Staged/CLI fixtures cover real file custody, independent competing processes, held-lock refusal and stale handles; they do not establish AWS, PostgreSQL or full process-crash qualification. + + +### First-install staging and floor binding + +A read-bearing first install now stores a private canonical connection draft +before its manifest or custody mutation. The draft fixes the connection identity, +account, descriptor and timestamps, and carries no read or publication authority. +The existing candidate runtime derives the credential reference with the native +custody commitment, initializes/registers cleanup notes, stores only an absent +exact generation and binds the host floor to that unpublished generation-one +record. The shared connection remains absent until fenced candidate publication. +An exact custody `holds` result supports explicit retry from the same retained +draft after an ambiguous write acknowledgement; another secret cannot replace it. + +`install` saves `candidate-installation.json`; `candidate-stage-installation` +resumes from `candidate-installation.cbor` into a new private output file. Only +this explicit operator action may initialize the installation's configuration, +cleanup journal or floor. Candidate compilation, acquisition and publication +check an existing floor, and ordinary entry still requires a live connection. +There is no cross-store atomicity claim: a floor or output failure may leave +custody with a retained cleanup obligation and no published connection. + +Production raw onboarding exports are removed. The previous checker remains a +test-only reference; the pure probe predicate remains shared by managed entry. +The offline install helper refuses recipes with reads before custody, while +join records cleanup notes before confirming an exact already-published secret. +The loopback option moves from unapproved install to approved candidate acquisition +and is limited to development installations in feature-enabled builds. + +Native staging artifacts exercise absent connection, exact restart, conflicting +secret, bad prefix, corrupt cleanup notes, substituted floor and runtime refusal +to repair a missing floor. The production CLI artifact exercises actual install +and a separate resume process. Full approved provider journeys, process faults +and PostgreSQL evidence remain separate unfinished requirements. diff --git a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md index 83a0e2cbc..da013fe3a 100644 --- a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md +++ b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md @@ -42,6 +42,38 @@ Active or disabled connections keep the normal floor requirement. If no connection committed, retain the journal as an orphan cleanup obligation; never infer deletion from a failed install command. +## First installation with credential checks + +For a recipe declaring credential reads, `install` retains private installation +inputs and writes `candidate-installation.cbor` and `candidate-installation.json` +under the state directory. It stages the secret, cleanup note and exact host +floor, but does not publish a connection or contact the provider. Continue with +steps 2–5 of the candidate workflow below, using that proposal. Serving ordinary +operations requires successful publication. + +If installation stops after retaining the draft, resume explicitly under +operator identity with the same secret: + +```sh +credential-source | auths-gateway candidate-stage-installation \ + --state-dir /private/installation --credential-stdin \ + --proposal-out /private/resumed-candidate.json +``` + +The output must be a new absolute owner-private file. Preserve an existing +proposal; do not overwrite it to conceal a failed or ambiguous attempt. Restaging +reuses the draft's exact connection identity and timestamps, confirms an existing +matching secret or stores an absent one, and refuses conflicting custody/floors. +A missing runtime floor is a refusal, never implicit repair. This explicit +operator action may initialize the unpublished installation floor; it cannot +stage after a connection has been published. A failed stage can retain custody +and cleanup notes without a connection; retain that orphan cleanup obligation. + +Development provider doubles are selected only on `candidate-acquire +--loopback-provider PORT` in a feature-enabled development build. `install` +no longer accepts a provider transport option. Recipes without credential reads +keep the offline installation flow. + ## Provider-secret rotation For the web-identity reference, the operator configuration must explicitly @@ -84,8 +116,8 @@ rotation API refuses `rotate`, `rotate-prepare` and commitment-only `rotate-commit` with `gateway.admin.candidate-approval-required`. Those commands remain the offline operator flow for recipes declaring no credential reads. Joining an already-published connection confirms the exact committed secret -without acquiring new provider evidence. First-install candidate staging and -full installed provider/custody qualification remain unfinished AP074 work. +without acquiring new provider evidence. Full installed provider/custody +qualification remains unfinished AP074 work. Check status on both hosts; each must see the same shared generation and hold the exact committed credential generation. The old generation remains for at diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 214a92e8a..df476d192 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -949,6 +949,51 @@ closure regeneration passed after that correction (one artifact-generation test) complete fault/formal/performance/hosted evidence remain required. No A01–A22 acceptance criterion closes. No broad local gate or hosted CI was run. +## First-install staging and onboarding cutover checkpoint + +- Read-bearing `install` now persists the existing canonical connection format + as a private draft, stages exact generation-one custody and saves a private + proposal. The shared connection stays absent until approved acquisition and + fenced publication. Draft identity/account/descriptor/timestamps survive + process restart. `candidate-stage-installation` explicitly resumes from it. +- The stage initializes durable cleanup notes before custody and pins the host + floor to the exact unpublished candidate. An existing matching secret supports + retry after ambiguous custody acknowledgement; conflicting secrets or floors + refuse. Candidate compilation/acquisition/publication require the existing + floor. Runtime cannot repair it; explicit operator restaging may initialize + an unpublished floor. Independent custody/floor/output failures retain cleanup + obligations and do not imply that custody was never written. +- Removed production raw onboarding exports and the install checker. The old + closed evaluator remains test-only; the pure probe predicate remains shipping. + The offline install helper now requires the recipe and refuses declared reads + before custody. Join requires cleanup notes before confirmation. Development + loopback selection moves from install to approved candidate acquisition. +- Native candidate artifact construction passed on `1c23ca31` plus this source, + retaining all 80 journal/publication histories and adding five first-install + staging histories: exact reopen/restage, bad prefix, existing connection, + substituted floor and corrupt cleanup journal. The actual CLI generator passed + with `testkit-harness,loopback-provider`, covering installation, an independent + resume process, identical proposal bytes, private files and conflicts. +- Initial generator failures were missing test-oracle imports, an incorrect + result-field assertion, comparing process-specific witness scopes across two + engines, and a test variable shadowing the recipe lock. Corrections retain + each process's own zero-I/O witness and the intended refusal assertions. +- Required generators: `observed_tests::effect_native_tests::candidate_tests::native_candidate_compilation_fixture_is_current` + (library), `native_candidate_cli_fixture_is_current` (candidate_cli integration + target), code inventories and final semantic closure. These construct scoped + artifacts; they are not broad local gates, installed approved provider + qualification or hosted evidence. No hosted CI has been observed. +- Final candidate/code/custody generation passed (four exact tests); the + production CLI artifact passed (one exact test), and final semantic closure + passed (one exact test). Fetch found upstream bot commit `67506ada`, updating + only the prior custody source's formal closure. It was inspected and retained + by fast-forward without observing hosted workflow results. +- Remaining: maintained deployment/example scripts and complete approved + installation/rotation journeys; safe recovery credential replacement; general + acquisition/disclosure/ACK; Python-owner removal; authenticated UI/bindings; + full process/adapter/differential/formal/performance/hosted evidence. No A01–A22 + acceptance criterion closes at this checkpoint. + ## Phase gates | Phase | State | Outstanding gate | @@ -956,7 +1001,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | First-install staging, maintained deployment and full approved rotation journeys (candidate CLI wired), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Maintained deployment and full approved installation/rotation journeys (staging and candidate CLI wired), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index c4fd5ff7e..02cfee9de 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -464,3 +464,22 @@ new lifecycle owner. The production CLI corpus drives two competing staging processes and a held-lock refusal. Native staging evidence checks stale handle refresh and conflicting successor refusal. Broader fault and adapter evidence remains required before AP074 acceptance closes. + + +### First-install source cutover + +Installation now uses the same sealed candidate and native acquisition owner as +rotation. Its concrete difference is the expected absence of a live connection +and an explicit generation-one host floor. The private draft is the existing +canonical connection record, not another lifecycle format. The cleanup journal, +custody reference commitment and floor retain their existing owners. Only the +operator staging action initializes missing installation state; managed candidate +execution checks it and cannot repair it. + +The raw onboarding I/O wrapper is removed from production exports and CLI calls; +its pre-cutover evaluator is retained under `cfg(test)` as the closed reference. +The production `install` command stages read-bearing recipes without publication. +Native file evidence and independent CLI restart evidence cover exact restaging, +conflicting secret refusal, explicit absence, cleanup ordering and floor checks. +No provider predicate is inferred from successful staging, and these artifacts +do not close the installed approved provider, fault or PostgreSQL obligations. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 7d0259650..c33b55572 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -272,6 +272,18 @@ and grants no native authority, custody lease, transport or publication. It is private operator data suitable for preserving an exact target across approval and restart; the journal and fresh fences remain authoritative. +First installation retains a private canonical connection draft before custody, +with fixed connection ID, account, descriptor and timestamps. For a read-bearing +recipe, `install` stages the secret and private proposal but leaves the shared +connection absent. Cleanup notes precede custody. The explicit operator staging +action binds the host generation floor to the exact unpublished generation-one +candidate; this does not authorize ordinary entry. Candidate compilation, +acquisition and publication check that floor without initializing it. Runtime +startup cannot repair a missing floor. Explicit installation staging can resume +from the retained draft and same secret after an ambiguous custody result; it +must not replace a conflicting staged secret or a substituted floor. Joining an +existing connection records cleanup obligations before custody confirmation. + Rotation staging stores a successor only after validating the live predecessor, recipe, secret prefix, custody and generation and recording its durable cleanup obligation. It performs no provider read or lease, never deletes an existing diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 93a8ae570..e36629586 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"be62eaf2e76fdaab414d65a12ad92252eeaa90e73b014915e55883a0c2fff7d1"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"d801fc44b7d2450c8667c15cd3730860621062295839aeda99d320dbd31af35d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"9eeea954a62cb66e3abfad3a2c3b996a72c6b44175aeb5a3710ddea4c2465cf0"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"928e7e7283b2bd90099f6ab93c48a4d65915853c9a1b32176cc58b3738d8ee49"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"7405569876e7e95f8a7f703cbdd46ccae0ae6d9159b54fa0b7f35034556f9db4"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"fe1510ec96ce0f67e9a78edbfa94b33eb7df64c0ac4d0a67901124dcd0164777"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33ba1a8cd27aff7c70b5a309dff9508fa3930fa5779cfc28093eec9833555de7"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"90a69b565e00732457493027dfe5527c2883773416a691327a0a5d3343ade5c7"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4833c83ed7d170777dbedb84716e98cd0319dae087ce53cc428a3ecd6e2d249c"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"3a2ccbf60ff54f718af54308c81c5fd2b294c5cf8d4bc9f9288e384b28c4fb68"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index dccfcfb90..b59b4fc74 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -29,9 +29,8 @@ mod unix { use auths_gateway::{ CompiledRecipe, FileGatewayAttemptStore, GatewayAttempts, GatewayConnectionDescriptor, GatewayEngine, GatewayObserveRequest, GatewayObserveResult, GatewayObserver, - GatewayObserverError, GatewaySubmitResult, ObserverCustody, OnboardingAccount, - OnboardingFailure, OperatorNamespace, PostgresGatewayAttemptStore, - PrincipalSeparationError, check_candidate_credential, check_principal_separation, + GatewayObserverError, GatewaySubmitResult, ObserverCustody, OperatorNamespace, + PostgresGatewayAttemptStore, PrincipalSeparationError, check_principal_separation, check_private_directory, check_private_directory_owned_by, gateway_verifier_configuration, }; use auths_gateway::{ @@ -87,6 +86,8 @@ mod unix { const QUALIFICATION_ROOT_FILE: &str = "qualification-trust-root.json"; const OBSERVER_SEED: &str = "observer.seed"; const OPERATOR_ATTESTATION_FILE: &str = "operator-attestation.json"; + const INSTALL_DRAFT_FILE: &str = "candidate-installation.cbor"; + const INSTALL_PROPOSAL_FILE: &str = "candidate-installation.json"; use auths_gateway::admin::{ ADMIN_REQUEST_SCHEMA, ADMIN_RESPONSE_SCHEMA, AdminRequestCommand, parse_admin_request, }; @@ -205,6 +206,16 @@ mod unix { #[arg(long)] request_out: PathBuf, }, + /// Resume an unpublished first install from its retained private draft. + /// Reuses the exact connection ID and timestamps; performs no provider I/O. + CandidateStageInstallation { + #[arg(long)] + state_dir: PathBuf, + #[arg(long, required = true)] + credential_stdin: bool, + #[arg(long)] + proposal_out: PathBuf, + }, /// Operator-only: stage a rotation secret from stdin and save its exact /// private proposal. No provider read, lease or publication occurs. CandidateStageRotation { @@ -240,6 +251,10 @@ mod unix { action: PathBuf, #[arg(long)] approval: PathBuf, + /// Development build only: independently approved reads reach the local double. + #[cfg(feature = "loopback-provider")] + #[arg(long)] + loopback_provider: Option, }, /// Operator-only: publish an exact candidate from fresh retained checks. /// Performs no provider I/O and creates no new read allocation. @@ -274,8 +289,8 @@ mod unix { signature_hex: String, }, /// Operator-only install; credential bytes enter through stdin. The - /// first host inserts the shared connection record; each further host - /// joins it with `--join` and the same secret. + /// first host stages recipes with reads for independent approval and + /// publication; each further host joins published state with `--join`. Install { #[arg(long)] state_dir: PathBuf, @@ -343,12 +358,6 @@ mod unix { attempt_store: Option, #[command(flatten)] qualification: QualificationOptions, - /// Development builds only: send the onboarding credential reads - /// of a first install to a plain-HTTP provider double on - /// 127.0.0.1:. - #[cfg(feature = "loopback-provider")] - #[arg(long, conflicts_with = "join")] - loopback_provider: Option, }, /// Serve a restricted application socket and private admin socket. /// A Unix socket path holds at most 103 bytes on macOS and 107 on @@ -1309,37 +1318,6 @@ mod unix { Ok(bytes) } - /// Runs every credential check the recipe declares on the candidate - /// secret before anything is stored: the prefix, the probe, the account - /// read against the operator's label, and the denied reads. - async fn checked_install_credential( - recipe: &CompiledRecipe, - mut candidate: Zeroizing>, - account_label: &str, - loopback_provider: Option, - ) -> Result { - let account = OnboardingAccount::Label(account_label); - let review = recipe.review(); - let requirement = review.credential(); - let checked = match loopback_provider { - #[cfg(feature = "loopback-provider")] - Some(port) => { - auths_gateway::check_candidate_credential_loopback( - recipe, - requirement, - &candidate, - account, - port, - ) - .await - } - _ => check_candidate_credential(recipe, requirement, &candidate, account).await, - }; - checked.map_err(OnboardingFailure::install_code)?; - SecretBytes::new(std::mem::take(&mut *candidate)) - .map_err(|_| "gateway.install.invalid-credential") - } - /// Verifies an operator attestation against the installation it must /// name, and requires the authenticated operator to pass separation by /// key from every root and observer of the trust. @@ -1399,7 +1377,6 @@ mod unix { attempt_store: Option, credential_store: CredentialStoreSettings, qualification: QualificationOptions, - loopback_provider: Option, ) -> Result<(), Failure> { // The store choice is checked before anything is read or written. auths_gateway::credential_store_policy( @@ -1463,7 +1440,10 @@ mod unix { } (None, Deployment::Development) => None, }; - let candidate = read_install_credential()?; + let mut candidate = read_install_credential()?; + if !recipe.credential_prefix_matches(&candidate) { + return Err("gateway.install.credential-guard".into()); + } private_root(&state_dir)?; if state_dir.join("installation.json").exists() { return Err("gateway.install.already-installed".into()); @@ -1486,9 +1466,58 @@ mod unix { "gateway.install.credential-store-unavailable", CredentialAccess::Operator, )?; - // Retain authenticated cleanup inputs before any custody write. A - // pending install has no generation floor and cannot admit a lease. - // Explicit store-only revocation can still make its journal collectible. + // Retain the exact private initial draft before manifest/custody. An + // explicit staging retry reuses its connection ID and timestamps. + let draft = if join { + None + } else { + let label = account_label.ok_or("gateway.install.invalid-account-label")?; + if label.is_empty() || label.len() > 256 { + return Err("gateway.install.invalid-account-label".into()); + } + let id = + ConnectionId::generate().map_err(|_| "gateway.install.randomness-unavailable")?; + let profile = ConnectionProfile::new( + SemanticId::parse("auths.mcp").map_err(|_| "gateway.install.profile")?, + 2, + ) + .map_err(|_| "gateway.install.profile")?; + let mut account_hash = Sha256::new(); + account_hash.update(b"auths.gateway-account/1\0"); + account_hash.update(label.as_bytes()); + let timestamp = now()?; + Some( + ConnectionRecord::new( + provider.clone(), + alias.clone(), + id, + SemanticId::parse("auths.gateway-operation/1") + .map_err(|_| "gateway.install.contract")?, + SemanticId::parse("auths.gateway-connection-descriptor/1") + .map_err(|_| "gateway.install.descriptor-schema")?, + descriptor, + account_hash.finalize().into(), + [0; 32], + NonZeroU64::MIN, + ConnectionState::Active, + vec!["gateway".to_owned()], + vec![profile], + timestamp, + timestamp, + None, + ) + .map_err(|_| "gateway.install.connection-invalid")?, + ) + }; + if let Some(draft) = &draft { + private_file( + &state_dir.join(INSTALL_DRAFT_FILE), + &draft + .to_canonical_cbor() + .map_err(|_| "gateway.install.connection-invalid")?, + )?; + } + // Retain authenticated cleanup inputs before any custody write. private_file(&state_dir.join("recipe.json"), &source)?; private_file(&state_dir.join("profile.lock.json"), &lock)?; private_file(&state_dir.join("trusted.context.cbor"), &trust)?; @@ -1501,64 +1530,59 @@ mod unix { let manifest_bytes = serde_json_canonicalizer::to_vec(&manifest) .map_err(|_| "gateway.install.manifest-invalid")?; private_file(&state_dir.join("installation.json"), &manifest_bytes)?; - let shared = SharedConnection::new(attempts.store(), provider.clone(), alias.clone()); + let shared = SharedConnection::new(attempts.store(), provider, alias); + let journal = auths_gateway::CredentialJournal::new(state_dir.clone()); if join { - join_connection(&shared, &*credentials, &recipe, &candidate).await?; + join_connection(&shared, &journal, &*credentials, &recipe, &candidate).await?; } else { - let account_label = account_label.ok_or("gateway.install.invalid-account-label")?; - if account_label.is_empty() || account_label.len() > 256 { - return Err("gateway.install.invalid-account-label".into()); + let draft = draft.ok_or("gateway.install.connection-invalid")?; + if !recipe + .credential_reads() + .map_err(|_| "gateway.install.invalid-descriptor")? + .is_empty() + { + let proposal = state_dir.join(INSTALL_PROPOSAL_FILE); + stage_installation(&state_dir, candidate, &proposal).await?; + println!( + "installation candidate staged; approve checks and publish before serving" + ); + return Ok(()); } - let secret = - checked_install_credential(&recipe, candidate, &account_label, loopback_provider) - .await?; - let connection_id = - ConnectionId::generate().map_err(|_| "gateway.install.randomness-unavailable")?; - let profile = ConnectionProfile::new( - SemanticId::parse("auths.mcp").map_err(|_| "gateway.install.profile")?, - 2, - ) - .map_err(|_| "gateway.install.profile")?; - let mut account_hash = Sha256::new(); - account_hash.update(b"auths.gateway-account/1\0"); - account_hash.update(account_label.as_bytes()); - let account_commitment: [u8; 32] = account_hash.finalize().into(); - let timestamp = now()?; - let journal = auths_gateway::CredentialJournal::new(state_dir.clone()); - let id = connection_id.clone(); + let notes = journal.clone(); + let id = draft.connection_id().clone(); tokio::task::spawn_blocking(move || { - journal.initialize(&id)?; - journal.register(&id, NonZeroU64::MIN) + notes.initialize(&id)?; + notes.register(&id, NonZeroU64::MIN) }) .await .map_err(|_| "gateway.admin.credential-journal-unavailable")??; - let record_id = connection_id.clone(); + let secret = SecretBytes::new(std::mem::take(&mut *candidate)) + .map_err(|_| "gateway.install.invalid-credential")?; install_connection( + &recipe, &shared, &*credentials, - move |reference| { + |reference| { ConnectionRecord::new( - provider, - alias, - record_id, - SemanticId::parse("auths.gateway-operation/1") - .map_err(|_| "gateway.install.contract")?, - SemanticId::parse("auths.gateway-connection-descriptor/1") - .map_err(|_| "gateway.install.descriptor-schema")?, - descriptor, - account_commitment, + draft.provider_kind().clone(), + draft.alias().clone(), + draft.connection_id().clone(), + draft.contract().clone(), + draft.descriptor_schema().clone(), + draft.descriptor().to_vec(), + *draft.account_commitment(), reference, - NonZeroU64::MIN, - ConnectionState::Active, - vec!["gateway".to_owned()], - vec![profile], - timestamp, - timestamp, + draft.generation(), + draft.state(), + draft.allowed_workloads().to_vec(), + draft.allowed_profiles().to_vec(), + draft.created_at_unix_seconds(), + draft.updated_at_unix_seconds(), None, ) .map_err(|_| "gateway.install.connection-invalid") }, - &connection_id, + draft.connection_id(), secret, ) .await?; @@ -1568,16 +1592,6 @@ mod unix { .await .map_err(|_| "gateway.install.connection-store-unavailable")? .ok_or("gateway.install.connection-store-unavailable")?; - if join { - let journal = auths_gateway::CredentialJournal::new(state_dir.clone()); - let record = installed.record().clone(); - tokio::task::spawn_blocking(move || { - journal.initialize(record.connection_id())?; - journal.register(record.connection_id(), record.credential_generation()) - }) - .await - .map_err(|_| "gateway.admin.credential-journal-unavailable")??; - } let floor = auths_gateway::GenerationFloor::new(state_dir.clone()); let record = installed.record().clone(); tokio::task::spawn_blocking(move || floor.initialize(&record)) @@ -3116,6 +3130,48 @@ mod unix { .map_err(|_| "gateway.effect.approval") } + async fn stage_installation( + state_dir: &Path, + candidate: Zeroizing>, + proposal_out: &Path, + ) -> Result<(), Failure> { + if !proposal_out.is_absolute() || proposal_out.exists() { + return Err("gateway.state.file-exists-or-unavailable".into()); + } + private_root(state_dir)?; + let path = state_dir.join(INSTALL_DRAFT_FILE); + let metadata = fs::symlink_metadata(&path).map_err(|_| "gateway.state.invalid-path")?; + if !metadata.file_type().is_file() || metadata.permissions().mode() & 0o077 != 0 { + return Err("gateway.state.invalid-path".into()); + } + let bytes = Zeroizing::new(read_bounded( + &path, + auths_gateway::effect::MAX_EFFECT_BYTES, + )?); + let draft = ConnectionRecord::from_canonical_cbor(&bytes) + .map_err(|_| "gateway.install.connection-invalid")?; + let loading = state_dir.to_path_buf(); + let engine = tokio::task::spawn_blocking(move || -> Result { + let engine = load_engine_for(&loading, CredentialAccess::Operator)?; + engine.initialize_effect_configuration()?; + Ok(engine) + }) + .await + .map_err(|_| "gateway.configuration.unavailable")??; + let proposal = engine + .stage_candidate_installation(&draft, candidate) + .await?; + private_file( + proposal_out, + &Zeroizing::new( + proposal + .to_private_bytes() + .map_err(|_| "gateway.effect.review-refused")?, + ), + )?; + Ok(()) + } + fn read_candidate( state_dir: &Path, path: &Path, @@ -3963,6 +4019,18 @@ mod unix { .map_err(|_| "gateway.configuration.unavailable")??; Ok(()) } + Command::CandidateStageInstallation { + state_dir, + credential_stdin, + proposal_out, + } => { + if !credential_stdin || std::io::stdin().is_terminal() { + return Err("gateway.install.credential-must-be-piped-to-stdin".into()); + } + stage_installation(&state_dir, read_install_credential()?, &proposal_out).await?; + println!("installation candidate staged; private proposal saved"); + Ok(()) + } Command::CandidateStageRotation { state_dir, credential_stdin, @@ -4017,14 +4085,27 @@ mod unix { proof, action, approval, + #[cfg(feature = "loopback-provider")] + loopback_provider, } => { let target = read_candidate(&state_dir, &candidate)?; let proof = read_bounded(&proof, 4 * 1024 * 1024)?; let action = read_bounded(&action, 64 * 1024)?; let approval = read_effect_approval(&approval)?; + #[cfg(feature = "loopback-provider")] + if loopback_provider.is_some() + && installation(&state_dir)?.deployment != Deployment::Development + { + return Err("gateway.serve.invalid-installation".into()); + } let engine = tokio::task::spawn_blocking(move || load_engine(&state_dir)) .await .map_err(|_| "gateway.effect.unavailable")??; + #[cfg(feature = "loopback-provider")] + let engine = match loopback_provider { + Some(port) => engine.with_loopback_provider(port), + None => engine, + }; match engine .acquire_candidate_credential(&target, &proof, &action, approval) .await @@ -4169,11 +4250,7 @@ mod unix { aws_region, aws_kms_key, aws_identity, - #[cfg(feature = "loopback-provider")] - loopback_provider, } => { - #[cfg(not(feature = "loopback-provider"))] - let loopback_provider = None; let credential_store = CredentialStoreSettings { kind: credential_store, namespace: credential_namespace, @@ -4199,7 +4276,6 @@ mod unix { attempt_store, credential_store, qualification, - loopback_provider, ) .await } diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index 7313e27e0..606e370ff 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -6,6 +6,98 @@ use crate::effect::{BoundEffect, CandidateCredentialTarget, compile_candidate_cr use crate::submit::AcquisitionIo; impl GatewayEngine { + /// Stages a generation-one candidate from a retained private operator + /// draft, without inserting a connection or contacting the provider. The + /// draft's reference is replaced by the native commitment to `candidate`. + /// Cleanup notes precede custody; exact existing custody supports explicit + /// replay after a lost acknowledgement. A configured host floor is bound + /// to this exact candidate before it may acquire independently approved reads. + /// + /// # Errors + /// Refuses an existing connection, invalid draft/prefix/recipe/location, + /// unavailable cleanup/configuration/custody or a missing/substituted floor + /// that cannot be initialized by this explicit fresh-install action. Errors + /// retain cleanup obligations and never imply custody was not written. + pub async fn stage_candidate_installation( + &self, + draft: &ConnectionRecord, + mut candidate: zeroize::Zeroizing>, + ) -> Result { + self.check_effect_configuration().await?; + let placeholder = CandidateCredentialTarget::new(&self.recipe, draft, None) + .map_err(|_| "gateway.install.connection-invalid")?; + self.check_candidate_location(&placeholder)?; + if !self.recipe.credential_prefix_matches(&candidate) { + return Err("gateway.install.credential-guard"); + } + if self + .connection + .load() + .await + .map_err(|_| "gateway.connection.unavailable")? + .is_some() + { + return Err("gateway.install.connection-exists"); + } + let reference = auths_connections::CredentialReferenceCommitment::of( + draft.connection_id(), + draft.credential_generation(), + &candidate, + ); + let record = ConnectionRecord::new( + draft.provider_kind().clone(), + draft.alias().clone(), + draft.connection_id().clone(), + draft.contract().clone(), + draft.descriptor_schema().clone(), + draft.descriptor().to_vec(), + *draft.account_commitment(), + *reference.as_bytes(), + draft.generation(), + draft.state(), + draft.allowed_workloads().to_vec(), + draft.allowed_profiles().to_vec(), + draft.created_at_unix_seconds(), + draft.updated_at_unix_seconds(), + None, + ) + .map_err(|_| "gateway.install.connection-invalid")?; + let target = CandidateCredentialTarget::new(&self.recipe, &record, None) + .map_err(|_| "gateway.install.connection-invalid")?; + let journal = self + .credential_journal + .clone() + .ok_or("gateway.admin.credential-journal-unavailable")?; + let id = record.connection_id().clone(); + tokio::task::spawn_blocking(move || journal.initialize(&id)) + .await + .map_err(|_| "gateway.admin.credential-journal-unavailable")??; + self.note_credential(&record, record.credential_generation()) + .await?; + if self.holds(&record).await.is_err() { + let secret = SecretBytes::new(std::mem::take(&mut *candidate)) + .map_err(|_| "gateway.install.invalid-credential")?; + let stored = self + .credentials + .install( + record.connection_id(), + record.credential_generation(), + secret, + ) + .await + .map_err(|_| "gateway.install.credential-store-unavailable")?; + if stored != reference { + return Err("gateway.install.credential-store-unavailable"); + } + } + self.connection + .initialize_candidate_floor(&record) + .await + .map_err(|_| "gateway.connection.restore-rollback")?; + self.check_candidate_predecessor(&target).await?; + Ok(target) + } + /// Stages an operator-supplied rotation secret without leasing it or /// contacting the provider. The exact proposal can be persisted for native /// read authorization and approval. It never publishes the connection. @@ -133,6 +225,12 @@ impl GatewayEngine { ) -> Result<(), &'static str> { self.check_effect_configuration().await?; self.check_candidate_location(target)?; + if target.previous().is_none() { + self.connection + .check_candidate_floor(target.record()) + .await + .map_err(|_| "gateway.connection.restore-rollback")?; + } let current = self.connection.load().await.map_err(|error| match error { SharedConnectionError::Rollback => "gateway.connection.restore-rollback", _ => "gateway.connection.unavailable", @@ -183,6 +281,12 @@ impl GatewayEngine { let started = Instant::now(); self.check_effect_configuration().await?; self.check_candidate_location(target)?; + if target.previous().is_none() { + self.connection + .check_candidate_floor(target.record()) + .await + .map_err(|_| "gateway.connection.restore-rollback")?; + } let current = self .connection .load() diff --git a/product/runtime/auths-gateway/src/connection.rs b/product/runtime/auths-gateway/src/connection.rs index e911085f4..b93e46eee 100644 --- a/product/runtime/auths-gateway/src/connection.rs +++ b/product/runtime/auths-gateway/src/connection.rs @@ -158,6 +158,44 @@ impl SharedConnection { self } + /// Bind a fresh host to its exact unpublished generation-one candidate. + /// There is still no live connection; runtime never initializes a floor. + pub(crate) async fn initialize_candidate_floor( + &self, + record: &ConnectionRecord, + ) -> Result<(), SharedConnectionError> { + if record.generation() != NonZeroU64::MIN { + return Err(SharedConnectionError::Corrupt); + } + if let Some(floor) = self.floor.clone() { + let record = record.clone(); + tokio::task::spawn_blocking(move || floor.initialize(&record)) + .await + .map_err(|_| SharedConnectionError::Rollback)? + .map_err(|_| SharedConnectionError::Rollback)?; + } + Ok(()) + } + + /// For first-install candidates only: check the already initialized host + /// floor without creating it or accepting a future rotation prematurely. + pub(crate) async fn check_candidate_floor( + &self, + record: &ConnectionRecord, + ) -> Result<(), SharedConnectionError> { + if record.generation() != NonZeroU64::MIN { + return Err(SharedConnectionError::Corrupt); + } + if let Some(floor) = self.floor.clone() { + let record = record.clone(); + tokio::task::spawn_blocking(move || floor.accept(&record)) + .await + .map_err(|_| SharedConnectionError::Rollback)? + .map_err(|_| SharedConnectionError::Rollback)?; + } + Ok(()) + } + async fn accept_floor( &self, loaded: LoadedConnection, @@ -296,7 +334,7 @@ impl SharedConnection { } } -/// Installs the first record of a connection: stores `secret` in this +/// Installs the first record for a recipe with no credential reads: stores `secret` in this /// process's credential store at generation 1, then inserts the record that /// commits to it. A record already present is never replaced, and the /// secret stored for the refused install is deleted. @@ -308,12 +346,20 @@ impl SharedConnection { /// Returns `gateway.install.connection-exists` when a record is present, /// and a credential-store or connection-store code otherwise. pub async fn install_connection( + recipe: &crate::CompiledRecipe, shared: &SharedConnection, credentials: &dyn ConnectionCredentialStore, draft: impl FnOnce([u8; 32]) -> Result, connection_id: &ConnectionId, secret: SecretBytes, ) -> Result { + if !recipe + .credential_reads() + .map_err(|_| "gateway.install.invalid-descriptor")? + .is_empty() + { + return Err("gateway.install.candidate-approval-required"); + } let first = NonZeroU64::MIN; let reference = credentials .install(connection_id, first, secret) @@ -352,6 +398,7 @@ pub async fn install_connection( /// and store codes otherwise. No provider read is performed. pub async fn join_connection( shared: &SharedConnection, + journal: &crate::CredentialJournal, credentials: &dyn ConnectionCredentialStore, recipe: &crate::CompiledRecipe, candidate: &zeroize::Zeroizing>, @@ -367,6 +414,15 @@ pub async fn join_connection( } crate::GatewayConnectionDescriptor::from_record(record, recipe) .map_err(|_| "gateway.install.join-recipe-mismatch")?; + let notes = journal.clone(); + let id = record.connection_id().clone(); + let generation = record.credential_generation(); + tokio::task::spawn_blocking(move || { + notes.initialize(&id)?; + notes.register(&id, generation) + }) + .await + .map_err(|_| "gateway.admin.credential-journal-unavailable")??; // Joining confirms exactly the already-published secret. It does not // acquire new provider evidence or authorize a changed credential. diff --git a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs index d79f89242..a169aab80 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs @@ -262,5 +262,205 @@ pub(super) async fn histories( "no lease or provider entry" ); } - json!({"schema": "auths.candidate-staging-fixture/1", "scope": "actual engine, persistent file custody, generation floor and cleanup journal; fixed deployment clock; no provider execution, process crash or PostgreSQL claim", "cases": cases}) + let installation = installation_histories(recipe, trust, policy).await; + json!({"installation": installation, "schema": "auths.candidate-staging-fixture/1", "scope": "actual engine, persistent file custody, generation floor and cleanup journal; fixed deployment clock; no provider execution, process crash or PostgreSQL claim", "cases": cases}) +} + +async fn installation_histories( + recipe: &CompiledRecipe, + trust: &auths_model::TrustedContext, + policy: &EffectPolicy, +) -> Value { + let mut cases = Vec::new(); + for case in [ + "staged", + "bad-prefix", + "existing-connection", + "substituted-floor", + "corrupt-journal", + ] { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + } + let credentials = Arc::new( + PersistentCredentialStore::open(root.join("credentials.cbor")).expect("custody"), + ); + let store = + Arc::new(crate::FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); + let template = connection_account( + recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + let draft = ConnectionRecord::new( + template.provider_kind().clone(), + template.alias().clone(), + template.connection_id().clone(), + template.contract().clone(), + template.descriptor_schema().clone(), + template.descriptor().to_vec(), + *template.account_commitment(), + [0; 32], + NonZeroU64::MIN, + ConnectionState::Active, + template.allowed_workloads().to_vec(), + template.allowed_profiles().to_vec(), + NOW, + NOW, + None, + ) + .expect("draft"); + let shared = crate::SharedConnection::new( + store.clone(), + draft.provider_kind().clone(), + draft.alias().clone(), + ); + let floor = crate::GenerationFloor::new(root.clone()); + if case == "existing-connection" { + shared.insert(&draft).await.expect("existing"); + } + if case == "substituted-floor" { + floor.initialize(&draft).expect("substituted floor"); + } + if case == "corrupt-journal" { + std::fs::write(root.join("credential-journal.json"), b"invalid") + .expect("corrupt journal"); + } + let make_engine = || { + crate::GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &auths_codec::encode_verifier_context(trust).expect("trust"), + policy.clone(), + draft.provider_kind().clone(), + draft.alias().clone(), + "gateway".to_owned(), + draft.allowed_profiles()[0].clone(), + Arc::new( + PersistentCredentialStore::open(root.join("credentials.cbor")) + .expect("reopened custody"), + ), + crate::GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"), + ) + .expect("engine") + .with_credential_journal(crate::CredentialJournal::new(root.clone())) + .with_generation_floor(floor.clone()) + .with_qualification(Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(NOW))), + auths_recipe_qualification::VerifierState::default(), + ))) + }; + assert_eq!( + crate::install_connection( + recipe, + &shared, + &*credentials, + |_| panic!("unapproved draft must not run"), + draft.connection_id(), + SecretBytes::new(b"rk_test_unapproved".to_vec()).expect("secret") + ) + .await + .err(), + Some("gateway.install.candidate-approval-required"), + ); + let engine = make_engine(); + engine + .initialize_effect_configuration() + .expect("configuration"); + let before = engine.execution_witness(); + let secret = if case == "bad-prefix" { + b"sk_live_invalid".as_slice() + } else { + b"rk_test_first_install".as_slice() + }; + let result = engine + .stage_candidate_installation(&draft, zeroize::Zeroizing::new(secret.to_vec())) + .await; + if case == "staged" { + let target = result.expect("staged"); + assert!(target.previous().is_none()); + assert_eq!(target.record().generation(), NonZeroU64::MIN); + assert!( + credentials + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + floor.accept(target.record()).expect("floor exact"); + assert!( + floor.accept(&draft).is_err(), + "same generation substitution refused" + ); + let bytes = target.to_private_bytes().expect("proposal"); + assert_eq!(engine.execution_witness(), before); + drop(engine); + let reopened = make_engine(); + let reopened_before = reopened.execution_witness(); + let repeated = reopened + .stage_candidate_installation(&draft, zeroize::Zeroizing::new(secret.to_vec())) + .await + .expect("resume"); + assert_eq!( + repeated.to_private_bytes().expect("resumed proposal"), + bytes + ); + assert!( + reopened + .stage_candidate_installation( + &draft, + zeroize::Zeroizing::new(b"rk_test_other".to_vec()) + ) + .await + .is_err() + ); + std::fs::remove_file(root.join("connection-floor.json")).expect("lost floor"); + let refused = reopened + .compile_candidate_effect(&target, &[], &[]) + .await + .err() + .expect("missing floor refusal"); + assert_eq!( + refused, + crate::GatewaySubmitResult::NotEntered { + code: "gateway.connection.restore-rollback".to_owned() + } + ); + assert!( + !root.join("connection-floor.json").exists(), + "runtime cannot repair floor" + ); + let restored = reopened + .stage_candidate_installation(&draft, zeroize::Zeroizing::new(secret.to_vec())) + .await + .expect("explicit operator restaging"); + assert_eq!(restored.to_private_bytes().expect("restaged"), bytes); + assert_eq!(reopened.execution_witness(), reopened_before); + assert!(shared.load().await.expect("load").is_none()); + assert_eq!( + crate::CredentialJournal::new(root.clone()) + .generations(draft.connection_id()) + .expect("notes"), + vec![NonZeroU64::MIN] + ); + cases.push(json!({"case":case,"reopened_same_draft_and_secret_exact":true,"different_secret_refused":true,"runtime_missing_floor_refused_without_repair":true,"explicit_restaging_exact":true,"connection_remains_absent":true,"cleanup_note_retained":true})); + } else { + assert!(result.is_err(), "{case}"); + assert_eq!(engine.execution_witness(), before); + let generations = credentials + .stored_generations(draft.connection_id()) + .expect("generations"); + assert_eq!(generations.len(), usize::from(case == "substituted-floor")); + if case != "existing-connection" { + assert!(shared.load().await.expect("load").is_none()); + } + cases.push(json!({"case":case,"refused":true,"stored_generations":generations.len(),"no_provider_entry":true})); + } + } + json!({"direct_install_requires_approval_before_custody":true,"cases":cases}) } diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 863191b40..118d93457 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -860,7 +860,7 @@ impl GatewayEngine { .recipe .credential_reads() .map_err(|_| "gateway.admin.transition-unavailable")?; - if reads.probe().is_some() || reads.account().is_some() || !reads.denied().is_empty() { + if !reads.is_empty() { return Err("gateway.admin.candidate-approval-required"); } Ok(()) @@ -2517,6 +2517,7 @@ pub(crate) mod tests { auths_connections::ConnectionId::parse("conn_AAAAAAAAAAAAAAAAAAAAAA").expect("id"); let recipe = airtable_recipe(); crate::install_connection( + &recipe, &first.engine.connection, &*first.engine.credentials, |reference| { @@ -2632,6 +2633,7 @@ pub(crate) mod tests { ) -> Result { crate::join_connection( &self.engine.connection, + &crate::CredentialJournal::new(self._state.path().to_path_buf()), &*self.engine.credentials, &self.engine.recipe, &candidate(secret), @@ -3433,6 +3435,7 @@ pub(crate) mod tests { auths_connections::ConnectionId::parse("conn_BBBBBBBBBBBBBBBBBBBBBA").expect("id"); let recipe = airtable_recipe(); let refused = crate::install_connection( + &recipe, &second.engine.connection, &*second.engine.credentials, |reference| { diff --git a/product/runtime/auths-gateway/src/generation_floor.rs b/product/runtime/auths-gateway/src/generation_floor.rs index 67c0260ec..7c222a0de 100644 --- a/product/runtime/auths-gateway/src/generation_floor.rs +++ b/product/runtime/auths-gateway/src/generation_floor.rs @@ -37,7 +37,9 @@ impl GenerationFloor { Self { directory } } - /// Creates the floor during a fresh installation. An existing floor is + /// Creates the floor during a fresh installation, including its exact + /// unpublished generation-one candidate. This does not create a live + /// connection or authorize a lease. An existing floor is /// checked rather than replaced; runtime startup never initializes one. /// /// # Errors diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 2b2eab232..a8deb58de 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -103,9 +103,6 @@ pub use observer::{ OPERATION_SUBJECT_SCHEME, OUTCOME_SCHEMA, ObserverAnchorTemplate, ObserverCustody, READ_BACK_SCHEMA, operation_subject, }; -#[cfg(feature = "loopback-provider")] -pub use onboarding::check_candidate_credential_loopback; -pub use onboarding::{OnboardingAccount, OnboardingFailure, check_candidate_credential}; pub use operator::{ MAX_ISSUED_AHEAD_SECONDS, MAX_OPERATOR_ATTESTATION_BYTES, MAX_OPERATOR_EVIDENCE, OPERATOR_ATTESTATION_SCHEMA, OperatorAttestation, OperatorAttestationError, OperatorEvidence, diff --git a/product/runtime/auths-gateway/src/onboarding.rs b/product/runtime/auths-gateway/src/onboarding.rs index 03d8d57c5..34332783d 100644 --- a/product/runtime/auths-gateway/src/onboarding.rs +++ b/product/runtime/auths-gateway/src/onboarding.rs @@ -1,203 +1,183 @@ -//! Credential checks at onboarding: `install` and admin `rotate` test a -//! candidate secret before anything is stored. -//! -//! In order: the secret starts with a declared prefix; the probe finds its -//! declared value; the account read names the expected account; and each -//! denied read is refused with a declared status. Every read shares one -//! 20-second deadline and goes over the pinned transport with the version -//! headers and never an account-scope header. The candidate secret is read -//! only to build the credential header and is never logged or returned. +//! Pure candidate probe predicate and a test-only pre-cutover onboarding oracle. -use crate::submit::{account_commitment, account_label, denied_result}; -use crate::transport::{GatewayHttpTransport, ProviderResponse}; -use crate::{CompiledRecipe, CredentialRequirement}; -use auths_gateway_kernel::order::DeniedResult; +use crate::transport::ProviderResponse; use serde_json::Value; -use std::time::Duration; -use subtle::ConstantTimeEq as _; -use tokio::time::Instant; -/// Every onboarding read shares this deadline. -const ONBOARDING_DEADLINE: Duration = Duration::from_secs(20); - -/// The account a candidate secret must name. -#[derive(Clone, Copy, Debug)] -pub enum OnboardingAccount<'a> { - /// A first install: the account read must equal the operator's label. - Label(&'a str), - /// A rotation: the account read must hash to the connection record's - /// commitment. - Commitment([u8; 32]), +/// A complete 2xx JSON response with no version mismatch whose pointer +/// holds exactly the declared value. +pub(crate) fn probe_passes( + response: Option<&ProviderResponse>, + pointer: &str, + equals: &Value, +) -> bool { + response + .and_then(ProviderResponse::usable_body) + .and_then(crate::recipe::parse_provider_response) + .is_some_and(|document| document.pointer(pointer) == Some(equals)) } -/// Why a candidate secret was refused; nothing was stored. -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub enum OnboardingFailure { - /// The secret starts with no declared prefix. - Guard, - /// The probe did not find its declared value. - Probe, - /// The account read did not name the expected account. - Account, - /// A denied read was not refused with a declared status. - Capability, -} +#[cfg(test)] +mod reference { + use super::probe_passes; + use crate::CompiledRecipe; + #[cfg(feature = "loopback-provider")] + use crate::CredentialRequirement; + use crate::submit::{account_commitment, account_label, denied_result}; + use crate::transport::GatewayHttpTransport; + use auths_gateway_kernel::order::DeniedResult; + use std::time::Duration; + use subtle::ConstantTimeEq as _; + use tokio::time::Instant; -impl OnboardingFailure { - /// The stable code at `install`. - #[must_use] - pub const fn install_code(self) -> &'static str { - match self { - Self::Guard => "gateway.install.credential-guard", - Self::Probe => "gateway.install.credential-probe", - Self::Account => "gateway.install.credential-account", - Self::Capability => "gateway.install.credential-capability", - } + /// Every onboarding read shares this deadline. + const ONBOARDING_DEADLINE: Duration = Duration::from_secs(20); + + /// The account a candidate secret must name. + #[derive(Clone, Copy, Debug)] + pub enum OnboardingAccount<'a> { + /// A first install: the account read must equal the operator's label. + Label(&'a str), + /// A rotation: the account read must hash to the connection record's + /// commitment. + Commitment([u8; 32]), } - /// The stable code at admin `rotate`. - #[must_use] - pub const fn admin_code(self) -> &'static str { - match self { - Self::Guard => "gateway.admin.credential-guard", - Self::Probe => "gateway.admin.credential-probe", - Self::Account => "gateway.admin.credential-account", - Self::Capability => "gateway.admin.credential-capability", - } + /// Why a candidate secret was refused; nothing was stored. + #[derive(Clone, Copy, Debug, Eq, PartialEq)] + pub enum OnboardingFailure { + /// The secret starts with no declared prefix. + Guard, + /// The probe did not find its declared value. + Probe, + /// The account read did not name the expected account. + Account, + /// A denied read was not refused with a declared status. + Capability, } -} -/// Runs every declared credential check on `secret` before it is stored. -/// A recipe without a guard passes without any read, so its first install -/// stays offline. -/// -/// # Errors -/// -/// Returns the first failed check. A transport that cannot be prepared, a -/// read that fails, and the shared deadline all fail the check they reach. -pub async fn check_candidate_credential( - recipe: &CompiledRecipe, - requirement: &CredentialRequirement, - secret: &[u8], - account: OnboardingAccount<'_>, -) -> Result<(), OnboardingFailure> { - check_with_transport( - recipe, - || GatewayHttpTransport::prepare(recipe, requirement).ok(), - secret, - account, - ) - .await -} + impl OnboardingFailure { + /// The stable code at `install`. + #[must_use] + pub const fn install_code(self) -> &'static str { + match self { + Self::Guard => "gateway.install.credential-guard", + Self::Probe => "gateway.install.credential-probe", + Self::Account => "gateway.install.credential-account", + Self::Capability => "gateway.install.credential-capability", + } + } -/// [`check_candidate_credential`] against a plain-HTTP provider double on -/// `127.0.0.1:port`, in a `loopback-provider` development build. The checks, -/// their order, and the shared deadline are the same; only the destination -/// of the reads differs. -/// -/// # Errors -/// -/// As [`check_candidate_credential`]. -#[cfg(feature = "loopback-provider")] -pub async fn check_candidate_credential_loopback( - recipe: &CompiledRecipe, - requirement: &CredentialRequirement, - secret: &[u8], - account: OnboardingAccount<'_>, - port: u16, -) -> Result<(), OnboardingFailure> { - check_with_transport( - recipe, - || GatewayHttpTransport::prepare_loopback(recipe, requirement, port).ok(), - secret, - account, - ) - .await -} + /// The stable code at admin `rotate`. + #[must_use] + pub const fn admin_code(self) -> &'static str { + match self { + Self::Guard => "gateway.admin.credential-guard", + Self::Probe => "gateway.admin.credential-probe", + Self::Account => "gateway.admin.credential-account", + Self::Capability => "gateway.admin.credential-capability", + } + } + } -/// [`check_candidate_credential`] over the transport `prepare` returns, which -/// is prepared only when a check needs the network. -async fn check_with_transport( - recipe: &CompiledRecipe, - prepare: impl FnOnce() -> Option, - secret: &[u8], - account: OnboardingAccount<'_>, -) -> Result<(), OnboardingFailure> { - let Some(guard) = recipe.guard_checks() else { - return Ok(()); - }; - if !guard.admits_secret(secret) { - return Err(OnboardingFailure::Guard); + /// The retained reference check against a plain-HTTP provider double on + /// `127.0.0.1:port`, in a `loopback-provider` development build. The checks, + /// their order, and the shared deadline are the same; only the destination + /// of the reads differs. + /// + /// # Errors + /// + /// As The retained reference check. + #[cfg(feature = "loopback-provider")] + pub async fn check_candidate_credential_loopback( + recipe: &CompiledRecipe, + requirement: &CredentialRequirement, + secret: &[u8], + account: OnboardingAccount<'_>, + port: u16, + ) -> Result<(), OnboardingFailure> { + check_with_transport( + recipe, + || GatewayHttpTransport::prepare_loopback(recipe, requirement, port).ok(), + secret, + account, + ) + .await } - let reads = recipe - .credential_reads() - .map_err(|_| OnboardingFailure::Probe)?; - let first_network = if reads.probe().is_some() { - OnboardingFailure::Probe - } else if reads.account().is_some() { - OnboardingFailure::Account - } else if reads.denied().is_empty() { - return Ok(()); - } else { - OnboardingFailure::Capability - }; - let transport = prepare().ok_or(first_network)?; - let deadline = Instant::now() + ONBOARDING_DEADLINE; - let read = |read: &crate::ClosedCredentialRead| { - let transport = &transport; - let read = read.clone(); - async move { - tokio::time::timeout_at(deadline, transport.credential_read(&read, secret)) - .await - .ok() - .flatten() - } - }; - if let (Some(probe), Some((pointer, equals))) = (reads.probe(), &guard.probe) { - let response = read(probe).await; - if !probe_passes(response.as_ref(), pointer, equals) { - return Err(OnboardingFailure::Probe); + + /// The retained reference check over the transport `prepare` returns, which + /// is prepared only when a check needs the network. + pub(super) async fn check_with_transport( + recipe: &CompiledRecipe, + prepare: impl FnOnce() -> Option, + secret: &[u8], + account: OnboardingAccount<'_>, + ) -> Result<(), OnboardingFailure> { + let Some(guard) = recipe.guard_checks() else { + return Ok(()); + }; + if !guard.admits_secret(secret) { + return Err(OnboardingFailure::Guard); } - } - if let (Some(account_read), Some(pointer)) = (reads.account(), &guard.account_pointer) { - let response = read(account_read).await; - let label = account_label(response.as_ref(), pointer).ok_or(OnboardingFailure::Account)?; - let equal = match account { - OnboardingAccount::Label(expected) => label.as_bytes() == expected.as_bytes(), - OnboardingAccount::Commitment(expected) => { - bool::from(account_commitment(&label).ct_eq(&expected)) + let reads = recipe + .credential_reads() + .map_err(|_| OnboardingFailure::Probe)?; + let first_network = if reads.probe().is_some() { + OnboardingFailure::Probe + } else if reads.account().is_some() { + OnboardingFailure::Account + } else if reads.denied().is_empty() { + return Ok(()); + } else { + OnboardingFailure::Capability + }; + let transport = prepare().ok_or(first_network)?; + let deadline = Instant::now() + ONBOARDING_DEADLINE; + let read = |read: &crate::ClosedCredentialRead| { + let transport = &transport; + let read = read.clone(); + async move { + tokio::time::timeout_at(deadline, transport.credential_read(&read, secret)) + .await + .ok() + .flatten() } }; - if !equal { - return Err(OnboardingFailure::Account); + if let (Some(probe), Some((pointer, equals))) = (reads.probe(), &guard.probe) { + let response = read(probe).await; + if !probe_passes(response.as_ref(), pointer, equals) { + return Err(OnboardingFailure::Probe); + } } - } - for (denied, refused) in reads.denied().iter().zip(&guard.denied_refused) { - let response = read(denied).await; - if denied_result(response.as_ref(), refused) != DeniedResult::Refused { - return Err(OnboardingFailure::Capability); + if let (Some(account_read), Some(pointer)) = (reads.account(), &guard.account_pointer) { + let response = read(account_read).await; + let label = + account_label(response.as_ref(), pointer).ok_or(OnboardingFailure::Account)?; + let equal = match account { + OnboardingAccount::Label(expected) => label.as_bytes() == expected.as_bytes(), + OnboardingAccount::Commitment(expected) => { + bool::from(account_commitment(&label).ct_eq(&expected)) + } + }; + if !equal { + return Err(OnboardingFailure::Account); + } } + for (denied, refused) in reads.denied().iter().zip(&guard.denied_refused) { + let response = read(denied).await; + if denied_result(response.as_ref(), refused) != DeniedResult::Refused { + return Err(OnboardingFailure::Capability); + } + } + Ok(()) } - Ok(()) -} - -/// A complete 2xx JSON response with no version mismatch whose pointer -/// holds exactly the declared value. -pub(crate) fn probe_passes( - response: Option<&ProviderResponse>, - pointer: &str, - equals: &Value, -) -> bool { - response - .and_then(ProviderResponse::usable_body) - .and_then(crate::recipe::parse_provider_response) - .is_some_and(|document| document.pointer(pointer) == Some(equals)) } #[cfg(test)] mod tests { - use super::*; - use serde_json::json; + use super::reference::*; + use crate::CompiledRecipe; + use crate::transport::GatewayHttpTransport; + use serde_json::{Value, json}; use std::collections::BTreeMap; use std::net::Ipv4Addr; use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _}; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 45725b212..6ecc90ecd 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -92,6 +92,7 @@ const ROWS: &[&str] = &[ "gateway.admin.recovery-refused admin admin new 74 -", "gateway.admin.recovery-recorded admin admin new 74 -", "gateway.admin.status admin admin new 5 -", + "gateway.install.candidate-approval-required install install new 74 -", "gateway.install.connection-exists install install new 5 -", "gateway.install.credential-account install install new 3 -", "gateway.install.credential-capability install install new 3 -", diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index c8556a172..225ac1162 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -1226,6 +1226,12 @@ pub struct ClosedCredentialReads { } impl ClosedCredentialReads { + /// Whether the recipe declares no provider credential checks. + #[must_use] + pub fn is_empty(&self) -> bool { + self.probe.is_none() && self.account.is_none() && self.denied.is_empty() + } + /// Returns the onboarding probe, if declared. #[must_use] pub const fn probe(&self) -> Option<&ClosedCredentialRead> { @@ -1588,3 +1594,14 @@ fn valid_enum_variant(value: &str) -> bool { .bytes() .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'.' | b':' | b'-')) } + +impl CompiledRecipe { + /// Checks only the recipe's offline credential prefix constraint. Passing + /// does not establish account, capability, provider mode or read authority. + #[must_use] + pub fn credential_prefix_matches(&self, candidate: &[u8]) -> bool { + self.guard_checks() + .as_ref() + .is_none_or(|guard| guard.admits_secret(candidate)) + } +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 3da0be38a..3cbcfcb02 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d59a602cc911c37118512d0e603050e4ffbc48d14e42c4aa9f6b114052902b2b"; + "d0fb724949df577d5f1509a94b6975420667de8d6acb92e91fdb4d94d73dede2"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/candidate_cli.rs b/product/runtime/auths-gateway/tests/candidate_cli.rs index 4c6908cd1..bef8cb069 100644 --- a/product/runtime/auths-gateway/tests/candidate_cli.rs +++ b/product/runtime/auths-gateway/tests/candidate_cli.rs @@ -247,16 +247,16 @@ async fn native_candidate_cli_fixture_is_current() { ) .expect("candidate record"); assert!(reopened.holds(&staged.credential_binding()).await.is_ok()); - let lock = std::fs::OpenOptions::new() + let custody_lock = std::fs::OpenOptions::new() .read(true) .write(true) .open(root.join("credentials.cbor.lock")) .expect("custody lock"); - lock.try_lock().expect("hold custody fence"); + custody_lock.try_lock().expect("hold custody fence"); let blocked = stage(&root, &root.join("blocked.json"), b"rk_test_blocked\n"); assert!(!blocked.status.success()); assert!(!root.join("blocked.json").exists()); - drop(lock); + drop(custody_lock); let call_out = root.join("call.json"); let call = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) .arg("effect-candidate-call") @@ -312,7 +312,9 @@ async fn native_candidate_cli_fixture_is_current() { .expect("refusal CLI"); assert!(!refused.status.success()); assert!(!root.join("refused.json").exists()); + let first_installation = first_installation(&source, &lock, &trust, &policy, &recipe).await; let fixture = serde_json::to_vec_pretty(&json!({ + "first_installation": first_installation, "schema": "auths.candidate-cli-fixture/1", "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", "competing_processes_one_staging_winner": true, "held_custody_fence_refuses_without_proposal": true, "staged_generation": 2, "current_record_unchanged": true, "proposal_and_call_mode": "0600", @@ -326,3 +328,142 @@ async fn native_candidate_cli_fixture_is_current() { } assert_eq!(std::fs::read(path).expect("fixture"), fixture); } + +async fn first_installation( + source: &[u8], + lock: &[u8], + trust: &[u8], + policy: &auths_gateway::effect::EffectPolicy, + recipe: &CompiledRecipe, +) -> Value { + let directory = tempfile::tempdir().expect("installation directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + for (name, bytes) in [ + ("source.json", source), + ("lock.json", lock), + ("trust.cbor", trust), + ( + "policy.json", + policy.to_private_bytes().expect("policy").as_slice(), + ), + ] { + private(&root.join(name), bytes); + } + let state = root.join("state"); + let mut child = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("install") + .arg("--state-dir") + .arg(&state) + .arg("--recipe") + .arg(root.join("source.json")) + .arg("--profile-lock") + .arg(root.join("lock.json")) + .arg("--trusted-context") + .arg(root.join("trust.cbor")) + .arg("--effect-policy") + .arg(root.join("policy.json")) + .arg("--approve-digest") + .arg(recipe.digest_hex()) + .args([ + "--provider", + "stripe", + "--alias", + "synthetic", + "--account-label", + "acct_TESTACCOUNT01", + "--credential-stdin", + ]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("install process"); + child + .stdin + .take() + .expect("stdin") + .write_all(b"rk_test_initial_install\n") + .expect("secret"); + let output = child.wait_with_output().expect("install output"); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + let proposal = state.join("candidate-installation.json"); + let bytes = std::fs::read(&proposal).expect("proposal"); + let json: Value = serde_json::from_slice(&bytes).expect("proposal JSON"); + assert!(json["previous"].is_null()); + let candidate = ConnectionRecord::from_canonical_cbor( + &hex::decode(json["candidate"].as_str().expect("candidate hex")).expect("hex"), + ) + .expect("record"); + let shared = SharedConnection::new( + Arc::new(FileGatewayAttemptStore::open(&state.join("attempts")).expect("store")), + candidate.provider_kind().clone(), + candidate.alias().clone(), + ); + assert!(shared.load().await.expect("load").is_none()); + let custody = PersistentCredentialStore::open(state.join("credentials.cbor")).expect("custody"); + assert!(custody.holds(&candidate.credential_binding()).await.is_ok()); + auths_gateway::GenerationFloor::new(state.clone()) + .accept(&candidate) + .expect("floor"); + assert_eq!( + auths_gateway::CredentialJournal::new(state.clone()) + .generations(candidate.connection_id()) + .expect("notes"), + vec![NonZeroU64::MIN] + ); + let resume = |out: &Path, secret: &[u8]| { + let mut child = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("candidate-stage-installation") + .arg("--state-dir") + .arg(&state) + .arg("--proposal-out") + .arg(out) + .arg("--credential-stdin") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("resume process"); + child + .stdin + .take() + .expect("stdin") + .write_all(secret) + .expect("secret"); + child.wait_with_output().expect("resume output") + }; + let repeated = state.join("resumed.json"); + let result = resume(&repeated, b"rk_test_initial_install\n"); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + assert_eq!(std::fs::read(&repeated).expect("resumed bytes"), bytes); + let conflict = resume(&state.join("conflict.json"), b"rk_test_different\n"); + assert!(!conflict.status.success()); + assert!(!state.join("conflict.json").exists()); + assert!( + !resume(&proposal, b"rk_test_initial_install\n") + .status + .success() + ); + assert_eq!(std::fs::read(&proposal).expect("preserved"), bytes); + for path in [ + &proposal, + &repeated, + &state.join("candidate-installation.cbor"), + ] { + assert_eq!( + std::fs::metadata(path).expect("mode").permissions().mode() & 0o777, + 0o600 + ); + } + assert!(shared.load().await.expect("load").is_none()); + json!({"production_install_stages_without_publication":true,"private_draft_and_proposal":true,"exact_floor_and_cleanup_note":true,"independent_resume_process_reuses_exact_proposal":true,"different_secret_refused":true,"existing_output_preserved":true,"no_approved_provider_execution_claim":true}) +} From cac8c75b9007d9822da98957bbcd709ce09dfa21 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 12:00:44 +0000 Subject: [PATCH 044/136] test(gateway): exercise approved candidate process journeys --- .../gateway/candidate-process-journey.json | 273 ++++++++ compliance.toml | 4 + docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md | 8 + docs/plans/0074-implementation-status.md | 54 +- .../0009-bound-effect-and-recovery.md | 19 + product/runtime/auths-gateway/Cargo.toml | 4 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/harness.rs | 5 +- .../auths-gateway/src/harness/authoring.rs | 113 ++++ .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/candidate_journey.rs | 626 ++++++++++++++++++ 11 files changed, 1100 insertions(+), 10 deletions(-) create mode 100644 bindings/fixtures/gateway/candidate-process-journey.json create mode 100644 product/runtime/auths-gateway/src/harness/authoring.rs create mode 100644 product/runtime/auths-gateway/tests/candidate_journey.rs diff --git a/bindings/fixtures/gateway/candidate-process-journey.json b/bindings/fixtures/gateway/candidate-process-journey.json new file mode 100644 index 000000000..07f3f4a80 --- /dev/null +++ b/bindings/fixtures/gateway/candidate-process-journey.json @@ -0,0 +1,273 @@ +{ + "schema": "auths.candidate-process-journey/1", + "scope": "production CLI processes, native proof/exact approval, real file custody/journal/floor and counting local HTTP transport; fixed public test keys simulate reviewer; no human presence, live provider, isolation, crash injection or PostgreSQL claim", + "cases": [ + { + "case": "accepted", + "initial_requests": [ + "GET /v1/balance HTTP/1.1", + "GET /v1/account HTTP/1.1", + "GET /v1/customers HTTP/1.1", + "GET /v1/payouts HTTP/1.1" + ], + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "replay": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "rotation_acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "published", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": true, + "competing_acquisition_processes": true, + "old_approval_new_operation_refused": true, + "rotation_preserves_disabled_state": false, + "public_acquisition_excludes_secret_and_account": true + }, + { + "case": "accepted-disabled", + "initial_requests": [ + "GET /v1/balance HTTP/1.1", + "GET /v1/account HTTP/1.1", + "GET /v1/customers HTTP/1.1", + "GET /v1/payouts HTTP/1.1" + ], + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "replay": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "rotation_acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 2, + "response_version_ok": true + }, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "published", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": true, + "competing_acquisition_processes": false, + "old_approval_new_operation_refused": false, + "rotation_preserves_disabled_state": true, + "public_acquisition_excludes_secret_and_account": true + }, + { + "case": "bad-probe", + "initial_requests": [ + "GET /v1/balance HTTP/1.1" + ], + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "replay": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "rotation_acquisition": null, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "refused", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": false, + "competing_acquisition_processes": false, + "old_approval_new_operation_refused": false, + "rotation_preserves_disabled_state": false, + "public_acquisition_excludes_secret_and_account": true + }, + { + "case": "wrong-account", + "initial_requests": [ + "GET /v1/balance HTTP/1.1", + "GET /v1/account HTTP/1.1" + ], + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "replay": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "rotation_acquisition": null, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "refused", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": false, + "competing_acquisition_processes": false, + "old_approval_new_operation_refused": false, + "rotation_preserves_disabled_state": false, + "public_acquisition_excludes_secret_and_account": true + }, + { + "case": "excess-capability", + "initial_requests": [ + "GET /v1/balance HTTP/1.1", + "GET /v1/account HTTP/1.1", + "GET /v1/customers HTTP/1.1", + "GET /v1/payouts HTTP/1.1" + ], + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + "replay": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 2, + "response_version_ok": true + }, + "rotation_acquisition": null, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "refused", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": false, + "competing_acquisition_processes": false, + "old_approval_new_operation_refused": false, + "rotation_preserves_disabled_state": false, + "public_acquisition_excludes_secret_and_account": true + }, + { + "case": "unknown-primary", + "initial_requests": [ + "GET /v1/balance HTTP/1.1", + "GET /v1/account HTTP/1.1", + "GET /v1/customers HTTP/1.1", + "GET /v1/payouts HTTP/1.1" + ], + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "replay": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "rotation_acquisition": null, + "journal_and_allocations_unchanged_on_replay_and_publication": true, + "publication": "refused", + "restart_replay_no_provider_entry": true, + "invalid_approval_no_provider_entry": true, + "approval_alone_no_publication": true, + "rotation_completed": false, + "competing_acquisition_processes": false, + "old_approval_new_operation_refused": false, + "rotation_preserves_disabled_state": false, + "public_acquisition_excludes_secret_and_account": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 6a43a9d65..3edaf7206 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1615,6 +1615,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +candidate-process-journey = [ + "product/runtime/auths-gateway/tests/candidate_journey.rs#approved_candidate_process_journey_fixture_is_current", +] + candidate-installation = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", diff --git a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md index da013fe3a..c60bd4c00 100644 --- a/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md +++ b/docs/operations/GATEWAY_PRODUCTION_RUNBOOK.md @@ -74,6 +74,14 @@ Development provider doubles are selected only on `candidate-acquire no longer accepts a provider transport option. Recipes without credential reads keep the offline installation flow. +The local `candidate-process-journey.json` artifact exercises these commands +through separate production CLI processes and a counting HTTP double, including +active/disabled rotation, replay, failed credential predicates and response loss. +Its reviewer uses public test keys; it is not a live-provider, human-presence, +production-custody or PostgreSQL qualification. In a production installation, +the required signed qualification inputs must permit the candidate reads before +acquisition. Staging alone does not bypass that gate. + ## Provider-secret rotation For the web-identity reference, the operator configuration must explicitly diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index df476d192..fde5de3a2 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -994,6 +994,50 @@ closure regeneration passed after that correction (one artifact-generation test) full process/adapter/differential/formal/performance/hosted evidence. No A01–A22 acceptance criterion closes at this checkpoint. +## Approved candidate process journey checkpoint + +- Added a real production-CLI journey over private installation files, file + custody, generation floor, cleanup journal and actual local HTTP sockets. + Test-only fixed-key native authoring supplies real canonical proof/action and + trust; `effect-candidate-call`, `effect-review`, `effect-approval`, acquisition + and publication still use the shipping compiler, verifier and transaction + owners. No oracle entry predicate or hand-built approved binding is used. +- `candidate-process-journey.json` records six histories: successful first + installation with active rotation; rotation of a disabled predecessor; bad + probe; wrong account; excess final capability; and lost primary response. + The provider counts and checks exact request lines, version/credential headers + and absence of account-scope headers. Successful first install and rotation + each make exactly four declared GETs. Earlier failed predicates stop later + reads. Failed/unknown evidence cannot publish a connection. +- Independent acquisition processes race the same operation: one set of reads + reaches the provider. A new process replays retained history without re-entry; + every non-connection journal record and allocation remains byte-identical + across replay and publication. Lost final response retains unknown and its + invocation charge. Exact publication replay reports `already-current` without + provider I/O. Disabled rotation preserves state while advancing generation. +- Invalid approval and old exact approval for a new operation cause no provider + calls. Approval alone cannot publish. Native literal review includes every + credential request; public acquisition output is scanned for credential and + account sentinels. The test signer simulates an external reviewer and makes no + human-presence, live-provider, process-isolation or PostgreSQL claim. +- Exact artifact generation passed on `ed557dab` plus this source: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --features testkit-harness,loopback-provider --test candidate_journey -- --exact approved_candidate_process_journey_fixture_is_current`. + The final six-case run passed in 7.27 seconds. Final semantic-closure artifact + generation also passed (one exact test). Initial test failures required + clearing macOS's inherited nonblocking socket flag and using the existing + `disable --store-only` command. Test cleanup avoids a second panic during + unwinding. No production check or predicate was weakened to pass the journey. +- Maintained caller inventory still includes Stripe/Airtable demos, qualification + production/live/custody-fault scripts and the refund-approval example. Their + mutation-only trust/grants need explicit candidate read authority and exact + approval; production first install also needs the qualification bootstrap + order preserved. Merely replacing install/rotate command names is insufficient. + The no-read operator simulation retains its offline path. +- This closes the previously missing local approved candidate transport evidence, + not P3 or A01–A22. General acquisition/disclosure/ACK, safe recovery credentials, + maintained consumers, authenticated UI/bindings and full adapter/fault/formal/ + performance/hosted evidence remain required. Hosted CI has not been observed. + ## Phase gates | Phase | State | Outstanding gate | @@ -1001,7 +1045,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Maintained deployment and full approved installation/rotation journeys (staging and candidate CLI wired), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -1014,26 +1058,26 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | --- | --- | --- | --- | | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | -| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter cases / no | Execute concurrent binding conflicts and recovery cutover | +| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission, prerequisite and managed read charge fixtures | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | | A08 | ACK loss, restart, no redelivery, late ACK | Pending / no / no | Typed ACK protocol | | A09 | ACK substitution in every dimension | Pending / no / no | Authenticated exact ACK | -| A10 | Timeout/denial/response/state-match distinction | Pending / no / no | Native projection | +| A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and signed-observation cases / narrow file and native predicate fixtures | Installed lock-wait, independent expiry and adapter races pending | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | -| A17 | Sentinel privacy across errors/logs/public bindings | Pending / no / no | Private audit/public separation | +| A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | | A20 | Generated histories and shipping predicate refinement | Pending / no / no | Update linked artifacts | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | -| A22 | Installed single-human/single-agent full journey/UI | Pending / no / no | Native runtime and local sockets | +| A22 | Installed single-human/single-agent full journey/UI | Partial / local approved candidate CLI / candidate subprocess journey | Full installed read/disclosure/write/observation and authenticated UI | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 02cfee9de..648b43d91 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -483,3 +483,22 @@ Native file evidence and independent CLI restart evidence cover exact restaging, conflicting secret refusal, explicit absence, cleanup ordering and floor checks. No provider predicate is inferred from successful staging, and these artifacts do not close the installed approved provider, fault or PostgreSQL obligations. + + +### Approved candidate process evidence + +The production CLI now has a six-case process/HTTP artifact, generated by +`tests/candidate_journey.rs`. Native test authoring creates real proof/action +bytes with explicitly public fixed keys; the runtime still performs native +verification, exact review/approval, durable acquisition and fenced publication. +Separate CLI processes exercise first install, active/disabled rotation, replay, +competing acquisitions, invalid/reused approval, failed probe/account/final +capability and response loss. Actual external request counts and byte-preserved +journal/allocation snapshots provide evidence independently of intermediate +runtime flags. The local provider remains a domain-specific test reference; +no provider branching or test authoring enters the shipping default runtime. + +This strengthens the existing mechanism comparison without adding a production +abstraction or claiming human presence, deployment isolation, PostgreSQL faults +or live provider qualification. Maintained deployment/demo consumers still need +the exact authority/approval and qualification bootstrap cutover. diff --git a/product/runtime/auths-gateway/Cargo.toml b/product/runtime/auths-gateway/Cargo.toml index 682d8611c..a34dcb546 100644 --- a/product/runtime/auths-gateway/Cargo.toml +++ b/product/runtime/auths-gateway/Cargo.toml @@ -8,8 +8,8 @@ description = "Closed developer-authored request recipes for the Auths gateway" publish = false [features] -# Development and CI only: lets `serve --loopback-provider ` send -# provider requests to a plain-HTTP provider double on 127.0.0.1. +# Development and CI only: lets serve/candidate-acquire select a plain-HTTP +# provider double on 127.0.0.1 with --loopback-provider. loopback-provider = [] testkit-harness = [] # Tests only: lets a production installation keep its provider secret in the diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index e36629586..ba3b5956c 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"00b28be86921dcdc0ad90cce0c62c2961cafefe96ea6c2edf0e926c3d405ccad"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"6f5bd7f233c9d2664716643f56f6b0628186a1271c4e79693f4c928bb5b33b20"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index fa64019e0..8fc333ea8 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -8,6 +8,9 @@ //! Everything here is test infrastructure: the root and observer keys come //! from public fixed seeds. +#[cfg(feature = "testkit-harness")] +pub mod authoring; + use crate::engine::{ GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult, VerifiedCommand, gateway_verifier_configuration, observe_outcome, observe_pre_entry, observe_read_back, @@ -395,7 +398,7 @@ pub(crate) fn context_accepting( ) } -#[cfg(test)] +#[cfg(any(test, feature = "testkit-harness"))] pub(crate) fn context_for_tool( root: &Signer, observer: &PrincipalId, diff --git a/product/runtime/auths-gateway/src/harness/authoring.rs b/product/runtime/auths-gateway/src/harness/authoring.rs new file mode 100644 index 000000000..f1c9074ee --- /dev/null +++ b/product/runtime/auths-gateway/src/harness/authoring.rs @@ -0,0 +1,113 @@ +//! Fixed-key native authoring for installed-process tests. This module is +//! available only in testkit builds. None of its public seeds are credentials. + +use super::{HarnessError, Signer, audience, context_for_tool, fixture, grant_for_tool, window}; +use auths_codec::{ + action_id, action_signing_preimage, body_digest, encode_bundle, encode_canonical_action, + encode_verifier_context, grant_id, plan_id, +}; +use auths_model::{ + ActionEnvelope, AuthorizationPlan, BundleHeader, Challenge, ChannelBindingId, ControlBinding, + CriticalExtensions, EvidenceObject, ProofBundle, ProofRef, SignatureEnvelope, SignedAction, + StatementRef, +}; +use auths_profile_api::ActionProfile as _; +use auths_profile_mcp::{McpProfile, McpToolCall}; + +/// A natively signed exact tool call and its fixed-key test trust. No approval, +/// entry permit, installed configuration or provider result is created here. +pub struct ToolFixture { + /// Canonical native context restricted to this tool's permission. + pub context: Vec, + /// Canonical signed native proof. + pub proof: Vec, + /// Canonical exact tool action. + pub action: Vec, +} + +/// Authors a real native grant/action/proof with public fixed test keys. +/// The call remains the input to the native MCP canonicalizer; the helper does +/// not construct an effect, skip verification or approve execution. +/// +/// # Errors +/// Refuses invalid time ranges, call encodings or native authoring inputs. +pub fn tool_fixture(call: &McpToolCall, now: u64) -> Result { + let root = Signer::new(0x11); + let actor = Signer::new(0x22); + let observer = Signer::new(0x33); + let from = now + .checked_sub(86_400) + .ok_or(HarnessError::Fixture("time"))?; + let until = now + .checked_add(86_400) + .ok_or(HarnessError::Fixture("time"))?; + let context = context_for_tool(&root, &observer.principal, now, call)?; + let grant = grant_for_tool(&root, &actor.principal, None, window(from, until)?, call)?; + let canonical = fixture( + McpProfile.canonicalize(&fixture(call.canonical_bytes(), "call")?), + "canonical action", + )?; + let proof_ref = ProofRef::new([0x0b; 32]); + let plan = AuthorizationPlan::proof(proof_ref); + let envelope = ActionEnvelope::new( + canonical.profile().clone(), + canonical.media_type().clone(), + body_digest(canonical.body()), + canonical.permission().clone(), + None, + audience()?, + Challenge::new([0; 32]), + window(from, until)?, + actor.principal.clone(), + Some(fixture(grant_id(grant.statement()), "grant ID")?), + fixture(plan_id(&plan), "plan ID")?, + fixture(ChannelBindingId::parse("none-v1"), "channel")?, + proof_ref, + Vec::new(), + CriticalExtensions::empty(), + ); + let descriptor = actor.descriptor(); + let signature = actor.sign(&fixture( + action_signing_preimage(&envelope, &descriptor), + "action signing", + )?); + let action = SignedAction::new(envelope, SignatureEnvelope::new(descriptor, signature)); + let bindings = vec![ + fixture( + ControlBinding::new( + StatementRef::Grant(fixture(grant_id(grant.statement()), "grant ID")?), + vec![root.evidence().id()], + ), + "grant control", + )?, + fixture( + ControlBinding::new( + StatementRef::Action(fixture(action_id(action.envelope()), "action ID")?), + vec![actor.evidence().id()], + ), + "action control", + )?, + ]; + let mut evidence = vec![root.evidence(), actor.evidence()]; + evidence.sort_by_key(EvidenceObject::id); + let bundle = fixture( + ProofBundle::new( + BundleHeader::v1(), + vec![grant], + vec![action], + plan, + evidence, + bindings, + Vec::new(), + Vec::new(), + Vec::new(), + Some(canonical.body().to_vec()), + ), + "bundle", + )?; + Ok(ToolFixture { + context: fixture(encode_verifier_context(&context), "context")?, + proof: fixture(encode_bundle(&bundle), "proof")?, + action: fixture(encode_canonical_action(&canonical), "action")?, + }) +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 3cbcfcb02..c55ee6515 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d0fb724949df577d5f1509a94b6975420667de8d6acb92e91fdb4d94d73dede2"; + "4833c3f49cd125a75ce87f9d8b1c62216a681fd3fde43fad7c877a6cc0073954"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/candidate_journey.rs b/product/runtime/auths-gateway/tests/candidate_journey.rs new file mode 100644 index 000000000..6f02671a1 --- /dev/null +++ b/product/runtime/auths-gateway/tests/candidate_journey.rs @@ -0,0 +1,626 @@ +//! Real CLI processes, native signatures, file custody/journal and a counting +//! local HTTP provider. Fixed public test keys simulate the external reviewer; +//! this is no human-presence, live-provider, isolation or PostgreSQL claim. +#![cfg(all(unix, feature = "testkit-harness", feature = "loopback-provider"))] + +use auths_connections::{ConnectionAlias, ConnectionRecord, ProviderKind}; +use auths_gateway::effect::{CANDIDATE_CHECK_TOOL, EffectApprovalRequest, EffectPolicy}; +use auths_gateway::harness::authoring::tool_fixture; +use auths_gateway::{CompiledRecipe, FileGatewayAttemptStore, SharedConnection}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::TcpListener, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + process::{Command, Output, Stdio}, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + thread::{self, JoinHandle}, + time::{Duration, SystemTime, UNIX_EPOCH}, +}; + +const INITIAL: &[u8] = b"rk_test_public_initial_fixture"; +const ROTATED: &[u8] = b"rk_test_public_rotated_fixture"; + +struct Provider { + port: u16, + stop: Arc, + calls: Arc>>, + join: Option>, +} + +impl Provider { + fn start(case: &'static str) -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("listener"); + let port = listener.local_addr().expect("address").port(); + listener.set_nonblocking(true).expect("nonblocking"); + let stop = Arc::new(AtomicBool::new(false)); + let calls = Arc::new(Mutex::new(Vec::new())); + let finished = stop.clone(); + let observed = calls.clone(); + let join = thread::spawn(move || { + while !finished.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(value) => value, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(5)); + continue; + } + Err(error) => panic!("accept: {error}"), + }; + stream + .set_nonblocking(false) + .expect("accepted blocking socket"); + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .expect("read timeout"); + stream + .set_write_timeout(Some(Duration::from_secs(2))) + .expect("write timeout"); + let mut request = Vec::new(); + while request.len() < 16_384 && !request.ends_with(b"\r\n\r\n") { + let mut byte = [0]; + if stream.read_exact(&mut byte).is_err() { + break; + } + request.push(byte[0]); + } + let request = String::from_utf8(request).expect("request UTF-8"); + let line = request.lines().next().expect("request line").to_owned(); + let lowered = request.to_ascii_lowercase(); + assert!(lowered.contains("stripe-version: 2025-03-31.basil\r\n")); + assert!(!lowered.contains("stripe-account:")); + assert!( + lowered.contains(&format!( + "authorization: bearer {}\r\n", + String::from_utf8_lossy(INITIAL) + )) || lowered.contains(&format!( + "authorization: bearer {}\r\n", + String::from_utf8_lossy(ROTATED) + )) + ); + observed.lock().expect("calls").push(line.clone()); + let (status, body) = match line.as_str() { + "GET /v1/balance HTTP/1.1" => ( + 200, + if case == "bad-probe" { + r#"{"livemode":true}"# + } else { + r#"{"livemode":false}"# + }, + ), + "GET /v1/account HTTP/1.1" => ( + 200, + if case == "wrong-account" { + r#"{"id":"acct_TESTOTHER01"}"# + } else { + r#"{"id":"acct_TESTACCOUNT01"}"# + }, + ), + "GET /v1/customers HTTP/1.1" => (403, "{}"), + "GET /v1/payouts HTTP/1.1" if case == "unknown-primary" => continue, + "GET /v1/payouts HTTP/1.1" => ( + if case == "excess-capability" { + 200 + } else { + 403 + }, + "{}", + ), + _ => panic!("unexpected external request: {line}"), + }; + let response = format!( + "HTTP/1.1 {status} Response\r\nContent-Type: application/json\r\nStripe-Version: 2025-03-31.basil\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{body}", + body.len() + ); + stream.write_all(response.as_bytes()).expect("response"); + } + }); + Self { + port, + stop, + calls, + join: Some(join), + } + } + fn calls(&self) -> Vec { + self.calls.lock().expect("calls").clone() + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(join) = self.join.take() { + let result = join.join(); + if !thread::panicking() { + result.expect("provider thread"); + } + } + } +} + +fn private(path: &Path, bytes: &[u8]) { + std::fs::write(path, bytes).expect("write"); + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("mode"); +} +fn cli(command: &str, arguments: &[(&str, &str)], secret: Option<&[u8]>) -> Output { + let mut process = Command::new(env!("CARGO_BIN_EXE_auths-gateway")); + process.arg(command); + for (name, value) in arguments { + process.arg(name).arg(value); + } + if secret.is_some() { + process.arg("--credential-stdin"); + } + let mut child = process + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("CLI"); + if let Some(secret) = secret { + child + .stdin + .take() + .expect("stdin") + .write_all(secret) + .expect("secret input"); + } else { + drop(child.stdin.take()); + } + child.wait_with_output().expect("CLI output") +} +fn success(output: Output) -> Vec { + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + output.stdout +} +fn path(path: &Path) -> &str { + path.to_str().expect("UTF-8 path") +} + +struct Approved { + proposal: PathBuf, + proof: PathBuf, + action: PathBuf, + approval: PathBuf, +} +impl Approved { + fn invoke(&self, command: &str, state: &Path, provider: Option) -> Output { + let port = provider.map(|port| port.to_string()); + let mut args = vec![ + ("--state-dir", path(state)), + ("--candidate", path(&self.proposal)), + ("--proof", path(&self.proof)), + ("--action", path(&self.action)), + ("--approval", path(&self.approval)), + ]; + if let Some(port) = &port { + args.push(("--loopback-provider", port)); + } + cli(command, &args, None) + } +} + +fn approve( + state: &Path, + proposal: PathBuf, + operation: &str, + now: u64, + key: &SigningKey, +) -> Approved { + let call_path = state.join(format!("{operation}.call.json")); + success(cli( + "effect-candidate-call", + &[ + ("--state-dir", path(state)), + ("--candidate", path(&proposal)), + ("--operation", operation), + ("--call-out", path(&call_path)), + ], + None, + )); + let call = McpToolCall::from_canonical_bytes(&std::fs::read(call_path).expect("call")) + .expect("native call"); + let fixture = tool_fixture(&call, now).expect("native signed authority"); + assert_eq!( + std::fs::read(state.join("trusted.context.cbor")).expect("installed trust"), + fixture.context + ); + let proof = state.join(format!("{operation}.proof.cbor")); + let action = state.join(format!("{operation}.action.cbor")); + let request = state.join(format!("{operation}.request.json")); + private(&proof, &fixture.proof); + private(&action, &fixture.action); + let reviewed = success(cli( + "effect-review", + &[ + ("--state-dir", path(state)), + ("--candidate", path(&proposal)), + ("--proof", path(&proof)), + ("--action", path(&action)), + ("--not-before", &(now - 1).to_string()), + ("--expires-at", &(now + 300).to_string()), + ("--request-out", path(&request)), + ], + None, + )); + let review: Value = serde_json::from_slice(&reviewed).expect("private review"); + let signing = + EffectApprovalRequest::from_private_bytes(&std::fs::read(&request).expect("request")) + .expect("native request"); + assert_eq!( + review["signing_message_hex"], + hex::encode(signing.signing_message().expect("message")) + ); + let literal = review["literal_review"].as_str().expect("literal review"); + for required in ["/v1/balance", "/v1/account", "/v1/customers", "/v1/payouts"] { + assert!(literal.contains(required), "missing request {required}"); + } + let signature = key + .sign(&signing.signing_message().expect("message")) + .to_bytes(); + let approval = state.join(format!("{operation}.approval.json")); + private( + &approval, + &success(cli( + "effect-approval", + &[ + ("--request", path(&request)), + ("--signature-hex", &hex::encode(signature)), + ], + None, + )), + ); + Approved { + proposal, + proof, + action, + approval, + } +} + +fn retained_journal(state: &Path) -> std::collections::BTreeMap> { + std::fs::read_dir(state.join("attempts")) + .expect("journal directory") + .map(|entry| entry.expect("entry").path()) + .filter(|path| { + path.extension() + .is_some_and(|extension| extension == "json") + && !path + .file_name() + .expect("name") + .to_string_lossy() + .starts_with("conn-") + }) + .map(|path| { + ( + path.file_name() + .expect("name") + .to_string_lossy() + .into_owned(), + std::fs::read(&path).expect("journal bytes"), + ) + }) + .collect() +} + +fn current(state: &Path) -> Option { + let shared = SharedConnection::new( + Arc::new(FileGatewayAttemptStore::open(state.join("attempts")).expect("store")), + ProviderKind::parse("stripe").expect("provider"), + ConnectionAlias::parse("journey").expect("alias"), + ); + tokio::runtime::Runtime::new() + .expect("runtime") + .block_on(shared.load()) + .expect("load") + .map(|record| record.record().clone()) +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one process journey keeps ordered actions and evidence assertions together" +)] +fn approved_candidate_process_journey_fixture_is_current() { + let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let corpus: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("hostile-recipes-v2.json")).expect("recipes"), + ) + .expect("JSON"); + let source = serde_json::to_vec(&corpus["bases"]["stripe"]["recipe"]).expect("source"); + let lock = serde_json::to_vec(&corpus["bases"]["stripe"]["lock"]).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("recipe"); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock") + .as_secs(); + let bootstrap = tool_fixture( + &McpToolCall::new( + "stripe-refunds", + CANDIDATE_CHECK_TOOL, + serde_json::Map::new(), + ) + .expect("tool"), + now, + ) + .expect("test trust"); + let key = SigningKey::from_bytes(&[29; 32]); + let policy = EffectPolicy::new( + "candidate-process-journey".to_owned(), + 1, + key.verifying_key().to_bytes(), + ) + .expect("policy"); + let mut cases = Vec::new(); + for case in [ + "accepted", + "accepted-disabled", + "bad-probe", + "wrong-account", + "excess-capability", + "unknown-primary", + ] { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let state = root.join("state"); + for (name, bytes) in [ + ("recipe.json", source.as_slice()), + ("lock.json", lock.as_slice()), + ("trust.cbor", bootstrap.context.as_slice()), + ( + "policy.json", + policy.to_private_bytes().expect("policy").as_slice(), + ), + ] { + private(&root.join(name), bytes); + } + let provider = Provider::start(case); + success(cli( + "install", + &[ + ("--state-dir", path(&state)), + ("--recipe", path(&root.join("recipe.json"))), + ("--profile-lock", path(&root.join("lock.json"))), + ("--trusted-context", path(&root.join("trust.cbor"))), + ("--effect-policy", path(&root.join("policy.json"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "stripe"), + ("--alias", "journey"), + ("--account-label", "acct_TESTACCOUNT01"), + ], + Some(INITIAL), + )); + assert!(current(&state).is_none()); + assert!(provider.calls().is_empty()); + let approved = approve( + &state, + state.join("candidate-installation.json"), + "initial", + now, + &key, + ); + assert!( + provider.calls().is_empty(), + "authoring and review perform no provider I/O" + ); + assert!( + !approved + .invoke("candidate-publish", &state, None) + .status + .success(), + "approval without acquired evidence cannot publish" + ); + let valid = std::fs::read(&approved.approval).expect("approval"); + let request: Value = serde_json::from_slice(&valid).expect("approval JSON"); + let mut forged = request; + forged["signature_b64"] = json!("invalid"); + private( + &approved.approval, + &serde_json_canonicalizer::to_vec(&forged).expect("forged"), + ); + assert!( + !approved + .invoke("candidate-acquire", &state, Some(provider.port)) + .status + .success() + ); + assert!(provider.calls().is_empty()); + private(&approved.approval, &valid); + if case == "accepted" { + let substituted = approve( + &state, + approved.proposal.clone(), + "different-operation", + now, + &key, + ); + private(&substituted.approval, &valid); + assert!( + !substituted + .invoke("candidate-acquire", &state, Some(provider.port)) + .status + .success(), + "old exact approval cannot authorize a different operation" + ); + assert!(provider.calls().is_empty()); + } + let acquired = if case == "accepted" { + let (first, second) = thread::scope(|scope| { + let first = scope + .spawn(|| approved.invoke("candidate-acquire", &state, Some(provider.port))); + let second = scope + .spawn(|| approved.invoke("candidate-acquire", &state, Some(provider.port))); + ( + first.join().expect("first acquirer"), + second.join().expect("second acquirer"), + ) + }); + let first_value: Value = + serde_json::from_slice(&first.stdout).expect("first concurrent response"); + let second_value: Value = + serde_json::from_slice(&second.stdout).expect("second concurrent response"); + assert!( + first_value["stage"] == "response-recorded" + || second_value["stage"] == "response-recorded", + "one process completes: {first_value}, {second_value}" + ); + if first_value["stage"] == "response-recorded" { + first + } else { + second + } + } else { + approved.invoke("candidate-acquire", &state, Some(provider.port)) + }; + for secret in [ + INITIAL, + ROTATED, + b"acct_TESTACCOUNT01".as_slice(), + b"acct_TESTOTHER01".as_slice(), + ] { + assert!( + !acquired + .stdout + .windows(secret.len()) + .any(|window| window == secret) + ); + assert!( + !acquired + .stderr + .windows(secret.len()) + .any(|window| window == secret) + ); + } + let acquired: Value = + serde_json::from_slice(&acquired.stdout).expect("native acquisition result"); + let calls = provider.calls(); + assert_eq!( + calls.len(), + match case { + "bad-probe" => 1, + "wrong-account" => 2, + _ => 4, + }, + "{case}: {acquired}" + ); + let journal = retained_journal(&state); + let replay = approved.invoke("candidate-acquire", &state, Some(provider.port)); + let replay: Value = serde_json::from_slice(&replay.stdout).expect("replay result"); + assert_eq!( + provider.calls(), + calls, + "restart replay cannot reenter provider" + ); + assert_eq!( + retained_journal(&state), + journal, + "replay preserves every retained journal fact and allocation" + ); + assert!(current(&state).is_none()); + let mut rotation = Value::Null; + let publication = approved.invoke("candidate-publish", &state, None); + assert_eq!( + retained_journal(&state), + journal, + "publication preserves facts and charges" + ); + if case.starts_with("accepted") { + assert_eq!( + serde_json::from_slice::(&success(publication)).expect("publication"), + json!("published") + ); + assert_eq!(acquired["stage"], "response-recorded"); + assert_eq!(replay, acquired); + assert_eq!(current(&state).expect("published").generation().get(), 1); + assert_eq!( + serde_json::from_slice::(&success(approved.invoke( + "candidate-publish", + &state, + None + ))) + .expect("replay publication"), + json!("already-current") + ); + assert_eq!(provider.calls(), calls); + if case == "accepted-disabled" { + let output = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .args(["disable", "--state-dir", path(&state), "--store-only"]) + .output() + .expect("disable CLI"); + success(output); + } + let previous = current(&state).expect("rotation predecessor"); + let proposal = state.join("rotation.json"); + success(cli( + "candidate-stage-rotation", + &[ + ("--state-dir", path(&state)), + ("--proposal-out", path(&proposal)), + ], + Some(ROTATED), + )); + let rotated = approve(&state, proposal, "rotation", now, &key); + assert_eq!(provider.calls(), calls); + let read: Value = serde_json::from_slice(&success(rotated.invoke( + "candidate-acquire", + &state, + Some(provider.port), + ))) + .expect("rotation read"); + assert_eq!(read["stage"], "response-recorded"); + assert_eq!(provider.calls().len(), 8); + assert_eq!(current(&state).expect("old current"), previous); + let rotation_journal = retained_journal(&state); + assert_eq!( + serde_json::from_slice::(&success(rotated.invoke( + "candidate-publish", + &state, + None + ))) + .expect("rotated"), + json!("published") + ); + assert_eq!( + current(&state).expect("new current").generation().get(), + previous.generation().get() + 1 + ); + assert_eq!( + current(&state).expect("new current").state(), + previous.state() + ); + assert_eq!(provider.calls().len(), 8); + assert_eq!(retained_journal(&state), rotation_journal); + rotation = read; + } else { + assert!( + !publication.status.success(), + "failed checks cannot publish" + ); + assert!(current(&state).is_none()); + assert_eq!(provider.calls(), calls); + if case == "unknown-primary" { + assert_eq!(acquired["stage"], "unknown"); + assert_eq!(replay, acquired); + assert_eq!(acquired["reserved_calls"], 1); + } + } + cases.push(json!({"case":case,"initial_requests":calls,"acquisition":acquired,"replay":replay,"rotation_acquisition":rotation,"journal_and_allocations_unchanged_on_replay_and_publication":true,"publication":if case.starts_with("accepted") {"published"} else {"refused"},"restart_replay_no_provider_entry":true,"invalid_approval_no_provider_entry":true,"approval_alone_no_publication":true,"rotation_completed":case.starts_with("accepted"),"competing_acquisition_processes":case=="accepted","old_approval_new_operation_refused":case=="accepted","rotation_preserves_disabled_state":case=="accepted-disabled","public_acquisition_excludes_secret_and_account":true})); + } + let fixture = serde_json::to_vec_pretty(&json!({"schema":"auths.candidate-process-journey/1","scope":"production CLI processes, native proof/exact approval, real file custody/journal/floor and counting local HTTP transport; fixed public test keys simulate reviewer; no human presence, live provider, isolation, crash injection or PostgreSQL claim","cases":cases})).expect("fixture"); + let output = fixtures.join("candidate-process-journey.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &fixture).expect("write fixture"); + } + assert_eq!(std::fs::read(output).expect("fixture"), fixture); +} From 72fe870ed93df6930337465711c423de85fee6f2 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 12:18:58 +0000 Subject: [PATCH 045/136] feat(gateway): authenticate exact disclosure acknowledgements --- .../gateway/disclosure-acknowledgement.json | 727 ++++++++++++++++++ compliance.toml | 8 +- ...017-bound-effect-and-recovery-ownership.md | 28 + docs/plans/0074-implementation-status.md | 44 +- .../0009-bound-effect-and-recovery.md | 26 + ...ound-effects-and-recovery-state-machine.md | 21 + .../auths-gateway-kernel/src/outcome.rs | 14 +- .../auths-gateway-kernel/src/transition.rs | 185 ++++- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 10 +- .../auths-gateway/src/effect/disclosure.rs | 269 +++++++ .../src/effect_disclosure_tests.rs | 484 ++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 1 + .../auths-gateway/src/store/acquisition.rs | 1 + 15 files changed, 1778 insertions(+), 44 deletions(-) create mode 100644 bindings/fixtures/gateway/disclosure-acknowledgement.json create mode 100644 product/runtime/auths-gateway/src/effect/disclosure.rs create mode 100644 product/runtime/auths-gateway/src/effect_disclosure_tests.rs diff --git a/bindings/fixtures/gateway/disclosure-acknowledgement.json b/bindings/fixtures/gateway/disclosure-acknowledgement.json new file mode 100644 index 000000000..6a22475dc --- /dev/null +++ b/bindings/fixtures/gateway/disclosure-acknowledgement.json @@ -0,0 +1,727 @@ +{ + "schema": "auths.gateway-disclosure-ack-fixture/1", + "scope": "native canonical evidence and pure reducer; no delivery, adapter or isolation claim", + "request": { + "acknowledged_bytes": 42, + "channel": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "delivery_instance": [ + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13 + ], + "effect": [ + 180, + 190, + 235, + 35, + 237, + 125, + 254, + 91, + 22, + 235, + 241, + 187, + 139, + 111, + 11, + 5, + 234, + 226, + 113, + 164, + 107, + 111, + 239, + 86, + 225, + 69, + 35, + 232, + 246, + 213, + 247, + 169 + ], + "maximum_bytes": 100, + "projection": [ + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14 + ], + "protected_content": [ + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11 + ], + "recipient": "key:sha256:keCS5umv4gfJTz2i01opfHh6WMj9F6kc1tsyeyqoi7g", + "recipient_key": [ + 67, + 4, + 107, + 254, + 64, + 146, + 179, + 233, + 73, + 148, + 234, + 218, + 21, + 220, + 194, + 13, + 138, + 170, + 7, + 182, + 88, + 253, + 57, + 84, + 235, + 142, + 14, + 251, + 139, + 220, + 165, + 222 + ], + "schema": "auths.gateway-disclosure-ack/1", + "source_effect": [ + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10 + ] + }, + "acknowledgement": { + "request": { + "acknowledged_bytes": 42, + "channel": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "delivery_instance": [ + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13 + ], + "effect": [ + 180, + 190, + 235, + 35, + 237, + 125, + 254, + 91, + 22, + 235, + 241, + 187, + 139, + 111, + 11, + 5, + 234, + 226, + 113, + 164, + 107, + 111, + 239, + 86, + 225, + 69, + 35, + 232, + 246, + 213, + 247, + 169 + ], + "maximum_bytes": 100, + "projection": [ + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14 + ], + "protected_content": [ + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11 + ], + "recipient": "key:sha256:keCS5umv4gfJTz2i01opfHh6WMj9F6kc1tsyeyqoi7g", + "recipient_key": [ + 67, + 4, + 107, + 254, + 64, + 146, + 179, + 233, + 73, + 148, + 234, + 218, + 21, + 220, + 194, + 13, + 138, + 170, + 7, + 182, + 88, + 253, + 57, + 84, + 235, + 142, + 14, + 251, + 139, + 220, + 165, + 222 + ], + "schema": "auths.gateway-disclosure-ack/1", + "source_effect": [ + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10 + ] + }, + "signature_b64": "2VNGVz6ecwsCyC4lgbfAqr_xoQdP8E3E2HAfbbIWom5cKNZOIWKK1fy0Wh6lEj3Egni3z4UQOswIQ6nfySTfBg" + }, + "edges": { + "checked_protocol_stage_pairs": 576, + "allowed": [ + { + "protocol": "Mutation", + "from": "Reserved", + "to": "EntryGranted" + }, + { + "protocol": "Mutation", + "from": "Reserved", + "to": "NotEntered" + }, + { + "protocol": "Mutation", + "from": "EntryGranted", + "to": "Unknown" + }, + { + "protocol": "Mutation", + "from": "EntryGranted", + "to": "ResponseRecorded" + }, + { + "protocol": "Mutation", + "from": "EntryGranted", + "to": "ObservedByProvider" + }, + { + "protocol": "Mutation", + "from": "Unknown", + "to": "ResponseRecorded" + }, + { + "protocol": "Mutation", + "from": "Unknown", + "to": "ObservedByProvider" + }, + { + "protocol": "Mutation", + "from": "ResponseRecorded", + "to": "Observed" + }, + { + "protocol": "Mutation", + "from": "ResponseRecorded", + "to": "ObservedByProvider" + }, + { + "protocol": "Acquisition", + "from": "Reserved", + "to": "EntryGranted" + }, + { + "protocol": "Acquisition", + "from": "Reserved", + "to": "NotEntered" + }, + { + "protocol": "Acquisition", + "from": "EntryGranted", + "to": "Unknown" + }, + { + "protocol": "Acquisition", + "from": "EntryGranted", + "to": "ResponseRecorded" + }, + { + "protocol": "Acquisition", + "from": "Unknown", + "to": "ResponseRecorded" + }, + { + "protocol": "Disclosure", + "from": "Reserved", + "to": "EntryGranted" + }, + { + "protocol": "Disclosure", + "from": "Reserved", + "to": "NotEntered" + }, + { + "protocol": "Disclosure", + "from": "EntryGranted", + "to": "Unknown" + }, + { + "protocol": "Disclosure", + "from": "EntryGranted", + "to": "Acknowledged" + }, + { + "protocol": "Disclosure", + "from": "Unknown", + "to": "Acknowledged" + } + ] + }, + "histories": [ + { + "events": [ + { + "stage": "Reserved", + "revision": 1 + }, + { + "stage": "NotEntered", + "revision": 2 + } + ], + "exact_ack_replay": false, + "reentry_refused": true, + "fixed_allocation_retained": true + }, + { + "events": [ + { + "stage": "Reserved", + "revision": 1 + }, + { + "stage": "EntryGranted", + "revision": 2 + }, + { + "stage": "Acknowledged", + "revision": 3 + } + ], + "exact_ack_replay": true, + "reentry_refused": true, + "fixed_allocation_retained": true + }, + { + "events": [ + { + "stage": "Reserved", + "revision": 1 + }, + { + "stage": "EntryGranted", + "revision": 2 + }, + { + "stage": "Unknown", + "revision": 3 + } + ], + "exact_ack_replay": false, + "reentry_refused": true, + "fixed_allocation_retained": true + }, + { + "events": [ + { + "stage": "Reserved", + "revision": 1 + }, + { + "stage": "EntryGranted", + "revision": 2 + }, + { + "stage": "Unknown", + "revision": 3 + }, + { + "stage": "Acknowledged", + "revision": 4 + } + ], + "exact_ack_replay": true, + "reentry_refused": true, + "fixed_allocation_retained": true + } + ], + "state_mutations": { + "rejected": [ + "protocol", + "revision", + "fixed", + "entry", + "stage", + "refusal", + "pre-entry", + "response", + "acknowledgement", + "locator", + "reading", + "evidence", + "observation", + "link" + ], + "saturated_revision_refused": true, + "provider_ack_injection_refused": true + }, + "substitutions": { + "bound_dimension_substitutions_refused": [ + "source_effect", + "protected_content", + "recipient", + "channel", + "delivery_instance", + "projection", + "maximum_bytes" + ], + "resigned_assertion_substitutions_refused": [ + "effect", + "source_effect", + "protected_content", + "channel", + "delivery_instance", + "projection", + "maximum_bytes", + "acknowledged_bytes" + ], + "other_operation_refused": true, + "different_byte_count_refused": true, + "over_limit_refused": true, + "other_signer_refused": true, + "forged_signature_refused": true, + "mutation_refused": true + }, + "decoding": { + "duplicate_unknown_obsolete_noncanonical_refused": true, + "empty_limit_limit_plus_one_refused": true, + "short_signature_refused": true + }, + "empty_and_ceiling_byte_counts_verified": true, + "no_current_authority_or_time_required_for_history": true +} diff --git a/compliance.toml b/compliance.toml index 3edaf7206..0d2c90a46 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1604,8 +1604,8 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1615,6 +1615,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +disclosure-acknowledgement-contract = [ + "product/runtime/auths-gateway/src/effect_disclosure_tests.rs#native_disclosure_acknowledgement_fixture_is_current", +] + candidate-process-journey = [ "product/runtime/auths-gateway/tests/candidate_journey.rs#approved_candidate_process_journey_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 5ca7a8bfa..bc86b33a1 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -772,3 +772,31 @@ secret, bad prefix, corrupt cleanup notes, substituted floor and runtime refusal to repair a missing floor. The production CLI artifact exercises actual install and a separate resume process. Full approved provider journeys, process faults and PostgreSQL evidence remain separate unfinished requirements. + + +## Recipient acknowledgement ownership + +`effect::disclosure` constructs and verifies the bounded native +`auths.gateway-disclosure-ack/1` statement. Recipient identity is the existing +raw-key principal derived from the statement's nonweak Ed25519 public key and +must equal the immutable disclosure binding. The exact protected-content length +comes from authoritative retained data, not the ACK. Successful verification +returns a sealed historical assertion, never a transport capability. It accepts +no clock/current-authority input, permitting late evidence after expiry or +revocation. This cannot authorize a new delivery. + +`auths-gateway-kernel::transition::valid_transition` remains the sole transition +owner. Disclosure shares the fixed identity/allocation/revision/grant contract +and adds a separate immutable acknowledgement field and terminal stage. It +cannot acquire provider responses, pre-entry observations, locators or mutation +facts. Provider journal projections supply an empty acknowledgement field. +`exact_acknowledgement_replay` is a read-only equality predicate on consistent +terminal disclosure history, not a second state transition rule. Persistence +must still fence the original record; duplicate ACKs must return retained bytes +and revision without rewriting or recharging. + +This checkpoint implements the evidence contract and pure relation. The +protected-content owner, disclosure admission/entry, recipient transport and +runtime journal projection remain required before this is a managed release +path. Kani oracle source includes disclosure; source-linked Lean regeneration +and refinement are still open P4 obligations, with no new proof claim. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index fde5de3a2..4c31100df 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1038,6 +1038,44 @@ closure regeneration passed after that correction (one artifact-generation test) maintained consumers, authenticated UI/bindings and full adapter/fault/formal/ performance/hosted evidence remain required. Hosted CI has not been observed. +## Native disclosure acknowledgement and reducer checkpoint + +- Extended the existing kernel transition owner with typed disclosure and a + distinct terminal `Acknowledged` stage. ACK bytes are separate from provider + response/observation fields. All protocols retain immutable identity, + allocation, grant and monotonic revision checks. Disclosure cannot acquire + provider facts; mutation/acquisition cannot carry ACKs. The provider outcome + presence predicate refuses the disclosure terminal stage. +- Native `auths.gateway-disclosure-ack/1` binds effect, source, protected content, + raw-key recipient, channel, delivery instance, projection, ceiling and actual + byte count. It uses existing canonical/domain commitment and strict Ed25519 + verification, derives the recipient through the existing raw-key descriptor, + rejects duplicate/unknown/noncanonical/obsolete/oversized input before use, + and returns a sealed historical assertion. Debug is redacted and encoded + buffers are zeroized. Verification supplies no execution authority. +- Late evidence requires no current-authority or time argument. It must still + match the retained delivery and protected content length and pass the shared + reducer. Exact repeated ACKs are read-only comparisons of consistent terminal + history; they do not advance revision, change evidence or issue another grant. +- Exact artifact construction passed on `cac8c75b` plus this source: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact effect::disclosure_tests::native_disclosure_acknowledgement_fixture_is_current`. + The final run passed one test in 0.03 seconds. Its fixture covers 576 protocol/ + stage pairs, four disclosure histories, immutable state-field substitutions, + revision saturation, changed binding dimensions, independently re-signed ACK + assertions, foreign signatures, exact byte-count limits and malformed codecs. + The initial compiler error combined raw-key construction and principal + derivation errors with incompatible Result types; each is now mapped at its + own boundary. Final semantic-closure generation passed one exact test. +- Kani source includes disclosure, the new ACK field and an exact terminal-replay + obligation. Kani and translated Lean/refinement evidence have not been run + or regenerated; they remain P4 work. No broad local gate or hosted CI was run. +- This is a native evidence/reducer slice, not an installed release path. Content + acquisition/custody, disclosure compilation/approval, transactional admission + and entry, authenticated recipient transport, persistent ACK recording and + AP070 Python-owner removal remain required. Synthetic fixed allocations in + this corpus do not establish durable accounting or actual byte delivery. No + A01–A22 acceptance criterion closes. + ## Phase gates | Phase | State | Outstanding gate | @@ -1063,8 +1101,8 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | -| A08 | ACK loss, restart, no redelivery, late ACK | Pending / no / no | Typed ACK protocol | -| A09 | ACK substitution in every dimension | Pending / no / no | Authenticated exact ACK | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer corpus / pure histories executed | Persistent disclosure grant, actual send/ACK loss and restart pending | +| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Wire recipient/channel and journal integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | @@ -1075,7 +1113,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | -| A20 | Generated histories and shipping predicate refinement | Pending / no / no | Update linked artifacts | +| A20 | Generated histories and shipping predicate refinement | Partial / 576 typed stage pairs, ACK histories and Kani source / pure corpus executed | Full generated concurrent histories and source-linked formal artifacts pending | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / local approved candidate CLI / candidate subprocess journey | Full installed read/disclosure/write/observation and authenticated UI | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 648b43d91..259fdfd81 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -502,3 +502,29 @@ This strengthens the existing mechanism comparison without adding a production abstraction or claiming human presence, deployment isolation, PostgreSQL faults or live provider qualification. Maintained deployment/demo consumers still need the exact authority/approval and qualification bootstrap cutover. + + +## Recipient evidence and disclosure reducer checkpoint + +The shared predicate now admits only the disclosure edges reserved→not-entered, +reserved→entry-granted, entry-granted→unknown/acknowledged and +unknown→acknowledged. Fixed allocation bytes and grant bytes survive every edge; +ACK is a separate terminal fact. Exact repeated evidence is a read-only lookup. +Acquisition/mutation cannot carry ACK bytes, and disclosure cannot carry HTTP or +observation facts. Existing provider outcome signing refuses the ACK stage. + +The native Ed25519 ACK contract binds every release dimension and exact protected +content length, using the existing raw-key principal derivation, canonical codec +and domain-separated commitment. It adds no token system, recipient registry or +provider-specific branch. Recipient evidence is historical and independent of +current execution authority; the future entry fence must separately establish +that authority before releasing any content. + +`disclosure-acknowledgement.json` is generated from real native signatures and +the shipping transition predicate: 576 same/cross-protocol stage pairs, four +histories, changed field/signature/encoding cases and read-only replay. Its +retained content identities and journal projections are synthetic. It is neither +AP070 differential equivalence nor a durability, actual delivery, authenticated +channel or process-isolation claim. Those remain required for the direct consumer +cutover. Kani source is extended, not executed; translated Lean/refinement work +remains pending. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index c33b55572..c0170c085 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -443,6 +443,27 @@ This diagram is a projection of a typed state model. `ResponseRecorded` belongs not erase uncertainty, release charges or imply permission to retry. Invalid cross-protocol transitions must be unrepresentable or refused by the sole reducer. +The native recipient evidence contract is `auths.gateway-disclosure-ack/1`, +bounded to 4,096 canonical bytes before decoding. It signs the exact effect, +source effect, protected content commitment, raw-key recipient and Ed25519 key, +channel, delivery instance, projection, byte ceiling and actual acknowledged +byte count. The key must derive the bound recipient through the existing +`raw-key-v1` principal mechanism; a key supplied by the envelope is not a new +trust anchor. The actual byte count is compared with protected content metadata +from the journal/content owner. Unknown fields, duplicates, alternate encodings, +obsolete schemas and noncanonical signatures are refused. All correlations stay +on the private channel; the ACK is not a public receipt. + +ACK verification deliberately has no current permission, approval expiry or +clock input. Its authenticated historical assertion must still match a retained +delivery grant and pass the sole reducer. Only disclosure may carry immutable +ACK bytes and reach `Acknowledged`; provider protocols cannot reinterpret them +as response or observation evidence. Exact repeated canonical ACKs return the +existing revision without a state transition. The signature establishes the +recipient's assertion under the pinned identity, not human attention or proof +of the transport implementation. This evidence contract and pure predicate do +not themselves implement content acquisition, disclosure admission or delivery. + ### 5.3 Retry and recovery contract For this milestone, provider-entry and disclosure-entry permits are one-use, and replay never reissues them. The model distinguishes re-running pure verification, retrying an uncommitted transaction, retrieving existing state, repeating an authorized observation, and repeating an external effect. diff --git a/product/runtime/auths-gateway-kernel/src/outcome.rs b/product/runtime/auths-gateway-kernel/src/outcome.rs index a7e0f5fb5..2b459f801 100644 --- a/product/runtime/auths-gateway-kernel/src/outcome.rs +++ b/product/runtime/auths-gateway-kernel/src/outcome.rs @@ -42,12 +42,12 @@ pub struct OutcomeFacts { pub relative_basis_digest: bool, } -/// Whether an outcome may name `stage`: every stage but `entry-granted`, which -/// an outcome reports as `unknown`. +/// Whether a provider outcome may name `stage`. Entry grants project unknown; +/// recipient acknowledgement belongs to the distinct disclosure projection. #[must_use] pub const fn outcome_stage(stage: Stage) -> bool { match stage { - Stage::EntryGranted => false, + Stage::EntryGranted | Stage::Acknowledged => false, Stage::Reserved | Stage::NotEntered | Stage::Unknown @@ -124,6 +124,7 @@ mod tests { } )); assert!(!outcome_facts_present(Stage::EntryGranted, NONE)); + assert!(!outcome_facts_present(Stage::Acknowledged, NONE)); } #[test] @@ -167,14 +168,15 @@ mod proofs { use super::*; fn any_stage() -> Stage { - match kani::any::() % 7 { + match kani::any::() % 8 { 0 => Stage::EntryGranted, 1 => Stage::NotEntered, 2 => Stage::Unknown, 3 => Stage::ResponseRecorded, 4 => Stage::Observed, 5 => Stage::Reserved, - _ => Stage::ObservedByProvider, + 6 => Stage::ObservedByProvider, + _ => Stage::Acknowledged, } } @@ -198,7 +200,7 @@ mod proofs { let pairs = facts.http_status == facts.response_digest && facts.relative_basis == facts.relative_basis_digest; let table = match stage { - Stage::EntryGranted => false, + Stage::EntryGranted | Stage::Acknowledged => false, Stage::NotEntered => { facts.refusal && !facts.http_status && !facts.observation && !facts.evidence_digest } diff --git a/product/runtime/auths-gateway-kernel/src/transition.rs b/product/runtime/auths-gateway-kernel/src/transition.rs index e6070d792..420c09240 100644 --- a/product/runtime/auths-gateway-kernel/src/transition.rs +++ b/product/runtime/auths-gateway-kernel/src/transition.rs @@ -21,6 +21,8 @@ pub enum Protocol { Mutation, /// A bounded acquisition records a response, never mutation success. Acquisition, + /// Recipient delivery records authenticated acknowledgement, never a provider response. + Disclosure, } /// The stage of an attempt record. @@ -40,6 +42,8 @@ pub enum Stage { Observed, /// A read-back found this action's token and value; terminal. ObservedByProvider, + /// The exact recipient acknowledged this delivery; terminal. + Acknowledged, } /// The read-back comparison recorded with an `observed` stage. @@ -85,6 +89,9 @@ pub struct AttemptView { pub pre_entry: Vec, /// Canonical bytes of the response status and digest; empty when absent. pub response: Vec, + /// Canonical authenticated recipient evidence; empty until acknowledged. + /// The runtime verifies its binding and signature before projecting it here. + pub acknowledgement: Vec, /// Canonical bytes of the response locator; empty when absent. pub locator: Vec, /// The recorded comparison. @@ -159,7 +166,8 @@ pub const fn refusal_stage(stage: Stage) -> bool { | Stage::Unknown | Stage::ResponseRecorded | Stage::Observed - | Stage::ObservedByProvider => false, + | Stage::ObservedByProvider + | Stage::Acknowledged => false, } } @@ -172,7 +180,8 @@ pub const fn requires_response(stage: Stage) -> bool { | Stage::EntryGranted | Stage::NotEntered | Stage::Unknown - | Stage::ObservedByProvider => false, + | Stage::ObservedByProvider + | Stage::Acknowledged => false, } } @@ -181,7 +190,11 @@ pub const fn requires_response(stage: Stage) -> bool { pub const fn permits_response(stage: Stage) -> bool { match stage { Stage::ResponseRecorded | Stage::Observed | Stage::ObservedByProvider => true, - Stage::Reserved | Stage::EntryGranted | Stage::NotEntered | Stage::Unknown => false, + Stage::Reserved + | Stage::EntryGranted + | Stage::NotEntered + | Stage::Unknown + | Stage::Acknowledged => false, } } @@ -195,7 +208,8 @@ pub const fn observed_stage(stage: Stage) -> bool { | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded - | Stage::ObservedByProvider => false, + | Stage::ObservedByProvider + | Stage::Acknowledged => false, } } @@ -209,7 +223,8 @@ pub const fn provider_stage(stage: Stage) -> bool { | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded - | Stage::Observed => false, + | Stage::Observed + | Stage::Acknowledged => false, } } @@ -217,7 +232,9 @@ pub const fn provider_stage(stage: Stage) -> bool { #[must_use] pub const fn terminal_stage(stage: Stage) -> bool { match stage { - Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider => true, + Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider | Stage::Acknowledged => { + true + } Stage::Reserved | Stage::EntryGranted | Stage::Unknown | Stage::ResponseRecorded => false, } } @@ -244,6 +261,7 @@ pub fn consistent(view: &AttemptView) -> bool { && view.revision > 0 && view.revision <= 9_007_199_254_740_991 && requires_entry(view.stage) == !absent(&view.entry) + && acknowledgement_stage(view.stage) == !absent(&view.acknowledgement) && refusal_stage(view.stage) == view.refusal && (!requires_response(view.stage) || has_response) && (!has_response || permits_response(view.stage)) @@ -255,11 +273,18 @@ pub fn consistent(view: &AttemptView) -> bool { && (!view.evidence || has_response || resolves_unknown(view.link)) } -/// Acquisition cannot carry mutation observations, locators or pre-entry reads. +/// Whether a stage requires authenticated recipient evidence. +#[must_use] +pub const fn acknowledgement_stage(stage: Stage) -> bool { + matches!(stage, Stage::Acknowledged) +} + +/// Acquisition and disclosure cannot acquire each other's evidence or mutation +/// observations. A common stage does not make their external boundaries equal. #[must_use] pub fn protocol_consistent(view: &AttemptView) -> bool { match view.protocol { - Protocol::Mutation => true, + Protocol::Mutation => !acknowledgement_stage(view.stage) && absent(&view.acknowledgement), Protocol::Acquisition => { matches!( view.stage, @@ -268,7 +293,24 @@ pub fn protocol_consistent(view: &AttemptView) -> bool { | Stage::NotEntered | Stage::Unknown | Stage::ResponseRecorded - ) && absent(&view.pre_entry) + ) && absent(&view.acknowledgement) + && absent(&view.pre_entry) + && absent(&view.locator) + && !view.observation + && !view.evidence + && matches!(view.reading, Reading::None) + && matches!(view.link, Link::None) + } + Protocol::Disclosure => { + matches!( + view.stage, + Stage::Reserved + | Stage::EntryGranted + | Stage::NotEntered + | Stage::Unknown + | Stage::Acknowledged + ) && absent(&view.response) + && absent(&view.pre_entry) && absent(&view.locator) && !view.observation && !view.evidence @@ -283,7 +325,9 @@ pub fn protocol_consistent(view: &AttemptView) -> bool { pub const fn same_protocol(left: Protocol, right: Protocol) -> bool { matches!( (left, right), - (Protocol::Mutation, Protocol::Mutation) | (Protocol::Acquisition, Protocol::Acquisition) + (Protocol::Mutation, Protocol::Mutation) + | (Protocol::Acquisition, Protocol::Acquisition) + | (Protocol::Disclosure, Protocol::Disclosure) ) } @@ -296,12 +340,14 @@ pub const fn requires_entry(stage: Stage) -> bool { | Stage::Unknown | Stage::ResponseRecorded | Stage::Observed - | Stage::ObservedByProvider => true, + | Stage::ObservedByProvider + | Stage::Acknowledged => true, } } /// The one transition table: a reservation cannot acquire response evidence -/// or become unknown until it has received a durable entry grant. +/// or become unknown until it has received a durable entry grant. Protocol +/// consistency separately confines ACKs to disclosure and responses to providers. #[must_use] pub const fn stage_transition_allowed(from: Stage, to: Stage, link: Link) -> bool { match from { @@ -310,17 +356,19 @@ pub const fn stage_transition_allowed(from: Stage, to: Stage, link: Link) -> boo Stage::Reserved | Stage::NotEntered | Stage::EntryGranted ), Stage::EntryGranted => match to { - Stage::Unknown | Stage::ResponseRecorded => true, + Stage::Unknown | Stage::ResponseRecorded | Stage::Acknowledged => true, Stage::ObservedByProvider => resolves_unknown(link), _ => false, }, Stage::Unknown => match to { - Stage::ResponseRecorded => true, + Stage::ResponseRecorded | Stage::Acknowledged => true, Stage::ObservedByProvider => resolves_unknown(link), _ => false, }, Stage::ResponseRecorded => matches!(to, Stage::Observed | Stage::ObservedByProvider), - Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider => false, + Stage::NotEntered | Stage::Observed | Stage::ObservedByProvider | Stage::Acknowledged => { + false + } } } @@ -375,6 +423,31 @@ pub fn response_kept(old: &AttemptView, new: &AttemptView) -> bool { || (same_bytes(&old.response, &new.response) && same_bytes(&old.locator, &new.locator)) } +/// Authenticated ACK bytes may be added only after a grant, including late +/// evidence for an unknown delivery. They can never be replaced or removed. +#[must_use] +pub fn acknowledgement_kept(old: &AttemptView, new: &AttemptView) -> bool { + if matches!(old.stage, Stage::EntryGranted | Stage::Unknown) && acknowledgement_stage(new.stage) + { + absent(&old.acknowledgement) && !absent(&new.acknowledgement) + } else { + same_bytes(&old.acknowledgement, &new.acknowledgement) + } +} + +/// Exact repeated evidence is an observation of existing history, not a state +/// transition. Callers return the retained revision and must not mint a permit, +/// charge again, rewrite evidence or consult current execution authority. +/// Authentication and exact effect/source/recipient/channel/content matching +/// precede this comparison at the runtime boundary. +#[must_use] +pub fn exact_acknowledgement_replay(view: &AttemptView, acknowledgement: &[u8]) -> bool { + matches!(view.protocol, Protocol::Disclosure) + && acknowledgement_stage(view.stage) + && consistent(view) + && same_bytes(&view.acknowledgement, acknowledgement) +} + /// Whether the stored plan's summary is unchanged. #[must_use] pub const fn plan_kept(old: &AttemptView, new: &AttemptView) -> bool { @@ -418,6 +491,7 @@ pub fn valid_transition(old: &AttemptView, new: &AttemptView) -> bool { && checkpoint_valid(old, new) && pre_entry_kept(old, new) && response_kept(old, new) + && acknowledgement_kept(old, new) && consistent(new) } @@ -426,7 +500,7 @@ mod tests { use super::*; use alloc::vec; - const STAGES: [Stage; 7] = [ + const STAGES: [Stage; 8] = [ Stage::Reserved, Stage::EntryGranted, Stage::NotEntered, @@ -434,6 +508,7 @@ mod tests { Stage::ResponseRecorded, Stage::Observed, Stage::ObservedByProvider, + Stage::Acknowledged, ]; fn view(stage: Stage, link: Link) -> AttemptView { @@ -455,6 +530,7 @@ mod tests { refusal: refusal_stage(stage), pre_entry: Vec::new(), response, + acknowledgement: Vec::new(), locator: Vec::new(), reading: if observed_stage(stage) { Reading::Match @@ -611,14 +687,15 @@ mod proofs { use alloc::vec::Vec; fn any_stage() -> Stage { - match kani::any::() % 7 { + match kani::any::() % 8 { 0 => Stage::EntryGranted, 1 => Stage::NotEntered, 2 => Stage::Unknown, 3 => Stage::ResponseRecorded, 4 => Stage::Observed, 5 => Stage::Reserved, - _ => Stage::ObservedByProvider, + 6 => Stage::ObservedByProvider, + _ => Stage::Acknowledged, } } @@ -651,10 +728,10 @@ mod proofs { fn any_view() -> AttemptView { AttemptView { - protocol: if kani::any() { - Protocol::Mutation - } else { - Protocol::Acquisition + protocol: match kani::any::() % 3 { + 0 => Protocol::Mutation, + 1 => Protocol::Acquisition, + _ => Protocol::Disclosure, }, revision: kani::any(), entry: any_bytes(), @@ -663,6 +740,7 @@ mod proofs { refusal: kani::any(), pre_entry: any_bytes(), response: any_bytes(), + acknowledgement: any_bytes(), locator: any_bytes(), reading: any_reading(), evidence: kani::any(), @@ -677,15 +755,17 @@ mod proofs { (from, to), ( Stage::EntryGranted, - Stage::Unknown | Stage::ResponseRecorded + Stage::Unknown | Stage::ResponseRecorded | Stage::Acknowledged ) | ( Stage::Reserved, Stage::Reserved | Stage::NotEntered | Stage::EntryGranted - ) | (Stage::Unknown, Stage::ResponseRecorded) - | ( - Stage::ResponseRecorded, - Stage::Observed | Stage::ObservedByProvider - ) + ) | ( + Stage::Unknown, + Stage::ResponseRecorded | Stage::Acknowledged + ) | ( + Stage::ResponseRecorded, + Stage::Observed | Stage::ObservedByProvider + ) ) || (matches!( (from, to), ( @@ -704,6 +784,7 @@ mod proofs { Stage::Reserved | Stage::EntryGranted | Stage::Unknown => { !view.refusal && !response && !reading && !view.evidence } + Stage::Acknowledged => !view.refusal && !response && !reading && !view.evidence, Stage::ResponseRecorded => !view.refusal && response && !reading && !view.evidence, Stage::Observed => { !view.refusal && response && reading && view.observation && !view.evidence @@ -717,9 +798,30 @@ mod proofs { } }; let protocol = match view.protocol { - Protocol::Mutation => true, + Protocol::Mutation => { + view.stage != Stage::Acknowledged && view.acknowledgement.is_empty() + } Protocol::Acquisition => { - !matches!(view.stage, Stage::Observed | Stage::ObservedByProvider) + !matches!( + view.stage, + Stage::Observed | Stage::ObservedByProvider | Stage::Acknowledged + ) && view.acknowledgement.is_empty() + && view.pre_entry.is_empty() + && view.locator.is_empty() + && view.reading == Reading::None + && !view.evidence + && !view.observation + && view.link == Link::None + } + Protocol::Disclosure => { + matches!( + view.stage, + Stage::Reserved + | Stage::EntryGranted + | Stage::NotEntered + | Stage::Unknown + | Stage::Acknowledged + ) && view.response.is_empty() && view.pre_entry.is_empty() && view.locator.is_empty() && view.reading == Reading::None @@ -730,6 +832,7 @@ mod proofs { }; shape && protocol + && ((view.stage == Stage::Acknowledged) == !view.acknowledgement.is_empty()) && view.revision > 0 && view.revision <= 9_007_199_254_740_991 && (view.locator.is_empty() || response) @@ -752,6 +855,20 @@ mod proofs { } } + /// Historical ACK replay is exact and read-only; all providers and all + /// pre-ACK stages are refused even if byte fields are otherwise equal. + #[kani::proof] + #[kani::unwind(3)] + fn acknowledgement_replay_requires_exact_terminal_disclosure() { + let view = any_view(); + let evidence = any_bytes(); + let expected = view.protocol == Protocol::Disclosure + && view.stage == Stage::Acknowledged + && fields_match_stage(&view) + && view.acknowledgement == evidence; + assert_eq!(exact_acknowledgement_replay(&view, &evidence), expected); + } + /// Exhaustive over every pair of bounded records (each byte field absent /// or one of two values): `valid_transition` holds exactly when the /// fixed bytes and plan are kept, the stage change is in the table, the @@ -785,6 +902,13 @@ mod proofs { } else { old.entry == new.entry }; + let acknowledgement = if matches!(old.stage, Stage::EntryGranted | Stage::Unknown) + && new.stage == Stage::Acknowledged + { + old.acknowledgement.is_empty() && !new.acknowledgement.is_empty() + } else { + old.acknowledgement == new.acknowledgement + }; let expected = old.revision < 9_007_199_254_740_991 && new.revision == old.revision + 1 && old.fixed == new.fixed @@ -796,6 +920,7 @@ mod proofs { && table(old.stage, new.stage, old.link) && pre_entry && response + && acknowledgement && fields_match_stage(&new); assert_eq!(valid_transition(&old, &new), expected); } diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index ba3b5956c..93365d8fe 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"f2bec99b1c5193f7bc976fb0c6fab8bdf26808520be4a5769c6071b6c8367eaf"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"03b1c503d20b80d19326c35edc1f3e655285a370f406f9c8c1997d62284f56b6"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"00bc31da3d053fbfec99296d6174a3ba672786a21bde817d8175d5d570b2b05c"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2abd78e46b44a1487ba8d973556ea909e670a3534f458fbe78a6a71f6e555696"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"d4aa4c93a044c407524579536fecd5101497be84fa0cfff2c09e5c66af6157e0"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 426f374e1..b15cbf92b 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -20,6 +20,14 @@ use zeroize::Zeroizing; mod acquisition; mod candidate; +mod disclosure; +pub use disclosure::{ + AuthenticatedDisclosureAcknowledgement, DISCLOSURE_ACK_SCHEMA, DisclosureAcknowledgement, + DisclosureAcknowledgementRequest, MAX_DISCLOSURE_ACK_BYTES, +}; +#[cfg(test)] +#[path = "effect_disclosure_tests.rs"] +mod disclosure_tests; pub(crate) use candidate::CandidatePlan; pub use candidate::{ CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, @@ -1508,7 +1516,7 @@ mod tests { ); } - fn wire() -> BindingWire { + pub(super) fn wire() -> BindingWire { BindingWire { schema: EFFECT_BINDING_SCHEMA.to_owned(), namespace: "synthetic".to_owned(), diff --git a/product/runtime/auths-gateway/src/effect/disclosure.rs b/product/runtime/auths-gateway/src/effect/disclosure.rs new file mode 100644 index 000000000..a8bf216a4 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/disclosure.rs @@ -0,0 +1,269 @@ +//! Exact recipient evidence. ACKs describe history and never confer delivery +//! authority. The sole journal reducer decides whether that history can be added. + +use super::{EffectBinding, EffectBindingError, Protocol, canonical, commitment}; +use auths_raw_key::{RawKeyDescriptor, RawKeyType}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use ed25519_dalek::{Signature, VerifyingKey}; +use serde::{Deserialize, Serialize}; +use std::fmt; +use zeroize::Zeroizing; + +/// Only accepted recipient acknowledgement contract. +pub const DISCLOSURE_ACK_SCHEMA: &str = "auths.gateway-disclosure-ack/1"; +/// Maximum canonical acknowledgement or signing request, before decoding. +pub const MAX_DISCLOSURE_ACK_BYTES: usize = 4_096; + +/// Private exact delivery statement for a recipient's Ed25519 signer. +/// Construction is data-only: it neither authenticates receipt of bytes nor +/// establishes native authority, approval, admission or a delivery grant. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct DisclosureAcknowledgementRequest { + schema: String, + effect: [u8; 32], + source_effect: [u8; 32], + protected_content: [u8; 32], + recipient: String, + recipient_key: [u8; 32], + channel: [u8; 32], + delivery_instance: [u8; 32], + projection: [u8; 32], + maximum_bytes: u64, + acknowledged_bytes: u64, +} + +impl fmt::Debug for DisclosureAcknowledgementRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("DisclosureAcknowledgementRequest { private: [redacted] }") + } +} + +impl DisclosureAcknowledgementRequest { + /// Constructs the exact signing statement from a private disclosure binding. + /// `content_bytes` is the length of the protected content the runtime will + /// deliver, not a recipient-supplied limit. Empty content remains distinct + /// from missing content. The recipient must be the bound raw-key principal. + /// + /// # Errors + /// Refuses other protocols, an unrelated/weak key or length above the bound. + pub fn for_delivery( + binding: &EffectBinding, + content_bytes: u64, + recipient_key: [u8; 32], + ) -> Result { + let Protocol::Disclosure { + source_effect, + protected_content, + recipient, + channel, + delivery_instance, + projection, + maximum_bytes, + } = &binding.wire.protocol + else { + return Err(EffectBindingError::Invalid); + }; + let request = Self { + schema: DISCLOSURE_ACK_SCHEMA.to_owned(), + effect: *binding.id().as_bytes(), + source_effect: *source_effect, + protected_content: *protected_content, + recipient: recipient.clone(), + recipient_key, + channel: *channel, + delivery_instance: *delivery_instance, + projection: *projection, + maximum_bytes: *maximum_bytes, + acknowledged_bytes: content_bytes, + }; + request.validate()?; + Ok(request) + } + + fn validate(&self) -> Result<(), EffectBindingError> { + if self.schema != DISCLOSURE_ACK_SCHEMA { + return Err(EffectBindingError::Unsupported); + } + let key = VerifyingKey::from_bytes(&self.recipient_key) + .map_err(|_| EffectBindingError::Invalid)?; + if key.is_weak() + || self.maximum_bytes > 65_536 + || self.acknowledged_bytes > self.maximum_bytes + || self.recipient.len() > 512 + { + return Err(EffectBindingError::Invalid); + } + let principal = RawKeyDescriptor::new(RawKeyType::Ed25519, self.recipient_key.to_vec()) + .map_err(|_| EffectBindingError::Invalid)? + .principal() + .map_err(|_| EffectBindingError::Invalid)?; + if principal.as_str() != self.recipient { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + /// Encodes private signing data with the native canonical codec. + /// + /// # Errors + /// Refuses invalid or oversized statements. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + self.validate()?; + bounded_canonical(self) + } + + /// Decodes data only. Exact encoding and the total bound are mandatory. + /// + /// # Errors + /// Refuses malformed, duplicate, unknown, obsolete, oversized or alternate + /// encodings. Successful decoding is not evidence of an actual delivery. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + check_length(bytes)?; + let request: Self = + serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + if request.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(request) + } + + /// Returns the native domain-separated Ed25519 message. The authenticated + /// recipient signs only after checking the received content and delivery + /// metadata on its bound channel. A signature is the recipient's assertion, + /// not proof of human attention or of the transport's implementation. + /// + /// # Errors + /// Refuses malformed/unsupported statements. + pub fn signing_message(&self) -> Result<[u8; 32], EffectBindingError> { + commitment(DISCLOSURE_ACK_SCHEMA, &self.to_private_bytes()?) + } + + /// Attaches an unverified signature. This creates portable evidence data, + /// never a delivery capability or authenticated journal fact. + #[must_use] + pub fn with_signature(self, signature: [u8; 64]) -> DisclosureAcknowledgement { + DisclosureAcknowledgement { + request: self, + signature_b64: Base64UrlUnpadded::encode_string(&signature), + } + } +} + +/// Bounded portable recipient evidence, subject to native verification against +/// the retained delivery. It contains private correlations and is not a public +/// receipt. There is deliberately no expiry or current-authority field: an +/// exact late ACK may refine history after revocation or approval expiry. +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct DisclosureAcknowledgement { + request: DisclosureAcknowledgementRequest, + signature_b64: String, +} + +impl fmt::Debug for DisclosureAcknowledgement { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("DisclosureAcknowledgement { private: [redacted] }") + } +} + +impl DisclosureAcknowledgement { + /// Encodes private evidence for the protected channel/journal. + /// + /// # Errors + /// Refuses invalid statements, noncanonical signatures or oversized data. + pub fn to_private_bytes(&self) -> Result>, EffectBindingError> { + self.request.validate()?; + self.signature()?; + bounded_canonical(self) + } + + /// Decodes canonical evidence without authenticating it. + /// + /// # Errors + /// Refuses duplicate/unknown fields, obsolete schemas, malformed signatures, + /// alternate encodings and input larger than `MAX_DISCLOSURE_ACK_BYTES`. + pub fn from_private_bytes(bytes: &[u8]) -> Result { + check_length(bytes)?; + let ack: Self = serde_json::from_slice(bytes).map_err(|_| EffectBindingError::Invalid)?; + if ack.to_private_bytes()?.as_slice() != bytes { + return Err(EffectBindingError::Invalid); + } + Ok(ack) + } + + fn signature(&self) -> Result { + let mut bytes = [0_u8; 64]; + let decoded = Base64UrlUnpadded::decode(&self.signature_b64, &mut bytes) + .map_err(|_| EffectBindingError::Invalid)?; + if decoded.len() != 64 || Base64UrlUnpadded::encode_string(decoded) != self.signature_b64 { + return Err(EffectBindingError::Invalid); + } + Ok(Signature::from_bytes(&bytes)) + } + + /// Authenticates exact evidence against the retained disclosure binding + /// and protected content length. The expected values must come from the + /// authoritative journal/content owner, never the incoming ACK. This is a + /// historical assertion only: callers must also require a retained grant + /// and apply the shared reducer before recording it. No fresh permission, + /// credential lease, byte release or refund follows from verification. + /// + /// # Errors + /// Refuses any substituted dimension, length, signer or invalid signature. + pub fn verify( + &self, + binding: &EffectBinding, + content_bytes: u64, + ) -> Result { + let expected = DisclosureAcknowledgementRequest::for_delivery( + binding, + content_bytes, + self.request.recipient_key, + )?; + if self.request != expected { + return Err(EffectBindingError::Invalid); + } + VerifyingKey::from_bytes(&expected.recipient_key) + .map_err(|_| EffectBindingError::Invalid)? + .verify_strict(&expected.signing_message()?, &self.signature()?) + .map_err(|_| EffectBindingError::Invalid)?; + Ok(AuthenticatedDisclosureAcknowledgement { + canonical: self.to_private_bytes()?, + }) + } +} + +/// Sealed authenticated historical assertion. It cannot be deserialized or +/// cloned into execution authority and is never a transport permit. +pub struct AuthenticatedDisclosureAcknowledgement { + canonical: Zeroizing>, +} + +impl fmt::Debug for AuthenticatedDisclosureAcknowledgement { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("AuthenticatedDisclosureAcknowledgement { private: [redacted] }") + } +} + +impl AuthenticatedDisclosureAcknowledgement { + /// Exact private evidence bytes for the journal's immutable ACK field. + /// Persistence still requires its matching original grant and reducer. + #[must_use] + pub fn as_private_bytes(&self) -> &[u8] { + &self.canonical + } +} + +fn check_length(bytes: &[u8]) -> Result<(), EffectBindingError> { + if bytes.is_empty() || bytes.len() > MAX_DISCLOSURE_ACK_BYTES { + return Err(EffectBindingError::Invalid); + } + Ok(()) +} + +fn bounded_canonical(value: &T) -> Result>, EffectBindingError> { + let bytes = canonical(value)?; + check_length(&bytes)?; + Ok(bytes) +} diff --git a/product/runtime/auths-gateway/src/effect_disclosure_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_tests.rs new file mode 100644 index 000000000..ae4c57764 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_disclosure_tests.rs @@ -0,0 +1,484 @@ +//! Native ACK and sole-reducer corpus. Synthetic binding/content identifiers +//! are private test inputs, not evidence of installed disclosure transport. + +use super::*; +use auths_gateway_kernel::transition::{ + self as reducer, AttemptView, Link, Protocol as Kind, Reading, Stage, +}; +use auths_raw_key::{RawKeyDescriptor, RawKeyType}; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde_json::{Value, json}; + +const STAGES: [Stage; 8] = [ + Stage::Reserved, + Stage::EntryGranted, + Stage::NotEntered, + Stage::Unknown, + Stage::ResponseRecorded, + Stage::Observed, + Stage::ObservedByProvider, + Stage::Acknowledged, +]; +const KINDS: [Kind; 3] = [Kind::Mutation, Kind::Acquisition, Kind::Disclosure]; + +fn disclosure(key: &SigningKey) -> EffectBinding { + let mut wire = super::tests::wire(); + wire.reservations = vec![Reservation { + key: [15; 32], + unit: Unit::DisclosureBytes, + amount: 42, + ceiling: 100, + window: ReservationWindow::SourceLifetime, + }]; + wire.protocol = Protocol::Disclosure { + source_effect: [10; 32], + protected_content: [11; 32], + recipient: RawKeyDescriptor::new( + RawKeyType::Ed25519, + key.verifying_key().to_bytes().to_vec(), + ) + .expect("descriptor") + .principal() + .expect("recipient") + .as_str() + .to_owned(), + channel: [12; 32], + delivery_instance: [13; 32], + projection: [14; 32], + maximum_bytes: 100, + }; + EffectBinding::new(wire).expect("synthetic private disclosure") +} + +fn signed(binding: &EffectBinding, length: u64, key: &SigningKey) -> DisclosureAcknowledgement { + let request = DisclosureAcknowledgementRequest::for_delivery( + binding, + length, + key.verifying_key().to_bytes(), + ) + .expect("signing request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + request.with_signature(signature) +} + +fn view(kind: Kind, stage: Stage) -> AttemptView { + AttemptView { + protocol: kind, + revision: 1, + // Identical bytes across protocols deliberately exercise the typed guard. + fixed: vec![1, 2, 3], + entry: if matches!(stage, Stage::Reserved | Stage::NotEntered) { + vec![] + } else { + vec![4] + }, + stage, + refusal: stage == Stage::NotEntered, + pre_entry: vec![], + response: if matches!(stage, Stage::ResponseRecorded | Stage::Observed) { + vec![5] + } else { + vec![] + }, + acknowledgement: if stage == Stage::Acknowledged { + vec![6] + } else { + vec![] + }, + locator: vec![], + reading: if stage == Stage::Observed { + Reading::Match + } else { + Reading::None + }, + evidence: stage == Stage::ObservedByProvider, + observation: kind == Kind::Mutation, + link: if kind == Kind::Mutation { + Link::Verified + } else { + Link::None + }, + } +} + +// Independent specification table. This oracle calls none of the shipping +// shape/stage helpers: evidence, grant, revision and protocol are projected +// independently and each invalid cross-protocol edge is also exercised. +fn expected(kind: Kind, from: Stage, to: Stage) -> bool { + match kind { + Kind::Mutation => matches!( + (from, to), + (Stage::Reserved, Stage::EntryGranted | Stage::NotEntered) + | ( + Stage::EntryGranted, + Stage::Unknown | Stage::ResponseRecorded | Stage::ObservedByProvider + ) + | ( + Stage::Unknown, + Stage::ResponseRecorded | Stage::ObservedByProvider + ) + | ( + Stage::ResponseRecorded, + Stage::Observed | Stage::ObservedByProvider + ) + ), + Kind::Acquisition => matches!( + (from, to), + (Stage::Reserved, Stage::EntryGranted | Stage::NotEntered) + | ( + Stage::EntryGranted, + Stage::Unknown | Stage::ResponseRecorded + ) + | (Stage::Unknown, Stage::ResponseRecorded) + ), + Kind::Disclosure => matches!( + (from, to), + (Stage::Reserved, Stage::EntryGranted | Stage::NotEntered) + | (Stage::EntryGranted, Stage::Unknown | Stage::Acknowledged) + | (Stage::Unknown, Stage::Acknowledged) + ), + } +} + +fn edges() -> Value { + let mut allowed = vec![]; + let mut checked = 0; + for old_kind in KINDS { + for new_kind in KINDS { + for from in STAGES { + for to in STAGES { + let old = view(old_kind, from); + let mut new = view(new_kind, to); + new.revision = 2; + // A provider-linked observation keeps an existing response. + if from == Stage::ResponseRecorded && to == Stage::ObservedByProvider { + new.response.clone_from(&old.response); + } + let actual = reducer::valid_transition(&old, &new); + let want = old_kind == new_kind && expected(old_kind, from, to); + assert_eq!(actual, want, "{old_kind:?}/{from:?} -> {new_kind:?}/{to:?}"); + checked += 1; + if actual { + allowed.push(json!({"protocol": format!("{old_kind:?}"), + "from": format!("{from:?}"), "to": format!("{to:?}")})); + } + } + } + } + } + json!({"checked_protocol_stage_pairs": checked, "allowed": allowed}) +} + +fn histories(evidence: &[u8]) -> Value { + let mut histories = vec![]; + for stages in [ + vec![Stage::Reserved, Stage::NotEntered], + vec![Stage::Reserved, Stage::EntryGranted, Stage::Acknowledged], + vec![Stage::Reserved, Stage::EntryGranted, Stage::Unknown], + vec![ + Stage::Reserved, + Stage::EntryGranted, + Stage::Unknown, + Stage::Acknowledged, + ], + ] { + let mut current = view(Kind::Disclosure, Stage::Reserved); + let mut events = vec![json!({"stage": "Reserved", "revision": 1})]; + for stage in stages.iter().skip(1) { + let mut next = view(Kind::Disclosure, *stage); + next.revision = current.revision + 1; + if *stage == Stage::Acknowledged { + next.acknowledgement = evidence.to_vec(); + } + assert!(reducer::valid_transition(¤t, &next)); + assert_eq!( + next.fixed, current.fixed, + "identity and charge allocation are retained" + ); + current = next; + events.push(json!({"stage": format!("{stage:?}"), "revision": current.revision})); + } + let before = current.clone(); + let replay = reducer::exact_acknowledgement_replay(¤t, evidence); + assert_eq!(replay, current.stage == Stage::Acknowledged); + assert_eq!( + before, current, + "ACK replay is read-only, including revision" + ); + assert!(!reducer::exact_acknowledgement_replay( + ¤t, + b"substituted" + )); + for forbidden in [Stage::Reserved, Stage::EntryGranted] { + let mut next = view(Kind::Disclosure, forbidden); + next.revision = current.revision + 1; + assert!(!reducer::valid_transition(¤t, &next)); + } + histories.push(json!({"events": events, "exact_ack_replay": replay, + "reentry_refused": true, "fixed_allocation_retained": true})); + } + json!(histories) +} + +fn field_mutations(evidence: &[u8]) -> Value { + let old = view(Kind::Disclosure, Stage::Unknown); + let mut valid = view(Kind::Disclosure, Stage::Acknowledged); + valid.revision = 2; + valid.acknowledgement = evidence.to_vec(); + assert!(reducer::valid_transition(&old, &valid)); + let mut rejected = vec![]; + for field in [ + "protocol", + "revision", + "fixed", + "entry", + "stage", + "refusal", + "pre-entry", + "response", + "acknowledgement", + "locator", + "reading", + "evidence", + "observation", + "link", + ] { + let mut next = valid.clone(); + match field { + "protocol" => next.protocol = Kind::Acquisition, + "revision" => next.revision += 1, + "fixed" => next.fixed.push(7), + "entry" => next.entry.push(7), + "stage" => next.stage = Stage::NotEntered, + "refusal" => next.refusal = true, + "pre-entry" => next.pre_entry = vec![7], + "response" => next.response = vec![7], + "acknowledgement" => next.acknowledgement.clear(), + "locator" => next.locator = vec![7], + "reading" => next.reading = Reading::Match, + "evidence" => next.evidence = true, + "observation" => next.observation = true, + "link" => next.link = Link::Verified, + _ => unreachable!(), + } + assert!(!reducer::valid_transition(&old, &next), "{field}"); + rejected.push(field); + } + for kind in [Kind::Mutation, Kind::Acquisition] { + let mut next = view(kind, Stage::Unknown); + next.acknowledgement = evidence.to_vec(); + assert!( + !reducer::consistent(&next), + "ACK cannot be smuggled into provider history" + ); + } + let mut saturated = old.clone(); + saturated.revision = (1 << 53) - 1; + valid.revision = saturated.revision + 1; + assert!(!reducer::valid_transition(&saturated, &valid)); + json!({"rejected": rejected, "saturated_revision_refused": true, + "provider_ack_injection_refused": true}) +} + +#[allow( + clippy::too_many_lines, + reason = "one bounded substitution corpus against both statement and retained binding" +)] +fn substitutions( + binding: &EffectBinding, + ack: &DisclosureAcknowledgement, + key: &SigningKey, +) -> Value { + let original: Value = + serde_json::from_slice(&binding.to_private_bytes().expect("binding")).expect("JSON"); + let mut cases = vec![]; + for field in [ + "source_effect", + "protected_content", + "recipient", + "channel", + "delivery_instance", + "projection", + "maximum_bytes", + ] { + let mut changed = original.clone(); + match field { + "recipient" => changed["protocol"][field] = json!("another-recipient"), + "maximum_bytes" => changed["protocol"][field] = json!(101), + _ => changed["protocol"][field][0] = json!(99), + } + let target = EffectBinding::from_private_bytes(&canonical(&changed).expect("JSON")) + .expect("changed data binding"); + assert!(ack.verify(&target, 42).is_err(), "{field}"); + cases.push(field); + } + // Re-sign each altered assertion while preserving the original effect ID. + // This proves explicit dimension matching, beyond the effect-ID comparison. + let ack_json: Value = + serde_json::from_slice(&ack.to_private_bytes().expect("ACK")).expect("JSON"); + let mut resigned = vec![]; + for field in [ + "effect", + "source_effect", + "protected_content", + "channel", + "delivery_instance", + "projection", + "maximum_bytes", + "acknowledged_bytes", + ] { + let mut statement = ack_json["request"].clone(); + if matches!(field, "maximum_bytes" | "acknowledged_bytes") { + statement[field] = json!(99); + } else { + statement[field][0] = json!(99); + } + let request = DisclosureAcknowledgementRequest::from_private_bytes( + &canonical(&statement).expect("JSON"), + ) + .expect("changed data"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + assert!( + request + .with_signature(signature) + .verify(binding, 42) + .is_err(), + "re-signed {field}" + ); + resigned.push(field); + } + let mut changed = original.clone(); + changed["operation"] = json!("another-operation"); + let target = + EffectBinding::from_private_bytes(&canonical(&changed).expect("JSON")).expect("binding"); + assert!(ack.verify(&target, 42).is_err()); + assert!(ack.verify(binding, 41).is_err()); + assert!( + DisclosureAcknowledgementRequest::for_delivery( + binding, + 101, + key.verifying_key().to_bytes() + ) + .is_err() + ); + let foreign = SigningKey::from_bytes(&[37; 32]); + assert!( + DisclosureAcknowledgementRequest::for_delivery( + binding, + 42, + foreign.verifying_key().to_bytes() + ) + .is_err() + ); + let request = + DisclosureAcknowledgementRequest::for_delivery(binding, 42, key.verifying_key().to_bytes()) + .expect("request"); + let forged = request.clone().with_signature( + foreign + .sign(&request.signing_message().expect("message")) + .to_bytes(), + ); + assert!(forged.verify(binding, 42).is_err()); + let mutation = EffectBinding::new(super::tests::wire()).expect("mutation"); + assert!(ack.verify(&mutation, 42).is_err()); + json!({"bound_dimension_substitutions_refused": cases, "resigned_assertion_substitutions_refused": resigned, "other_operation_refused": true, + "different_byte_count_refused": true, "over_limit_refused": true, + "other_signer_refused": true, "forged_signature_refused": true, "mutation_refused": true}) +} + +fn decoding(ack: &DisclosureAcknowledgement) -> Value { + let bytes = ack.to_private_bytes().expect("canonical ACK"); + let text = std::str::from_utf8(&bytes).expect("JSON"); + for malformed in [ + format!("{text} "), + text.replacen('{', "{\"extra\":0,", 1), + text.replacen( + "\"request\":{", + "\"request\":{\"schema\":\"auths.gateway-disclosure-ack/1\",", + 1, + ), + text.replace(DISCLOSURE_ACK_SCHEMA, "auths.gateway-disclosure-ack/0"), + ] { + assert!(DisclosureAcknowledgement::from_private_bytes(malformed.as_bytes()).is_err()); + } + for length in [0, MAX_DISCLOSURE_ACK_BYTES, MAX_DISCLOSURE_ACK_BYTES + 1] { + assert!(DisclosureAcknowledgement::from_private_bytes(&vec![b' '; length]).is_err()); + assert!(DisclosureAcknowledgementRequest::from_private_bytes(&vec![b' '; length]).is_err()); + } + let mut malformed: Value = serde_json::from_slice(&bytes).expect("JSON"); + malformed["signature_b64"] = json!("AA"); + assert!( + DisclosureAcknowledgement::from_private_bytes(&canonical(&malformed).expect("JSON")) + .is_err() + ); + json!({"duplicate_unknown_obsolete_noncanonical_refused": true, + "empty_limit_limit_plus_one_refused": true, "short_signature_refused": true}) +} + +#[test] +fn native_disclosure_acknowledgement_fixture_is_current() { + let key = SigningKey::from_bytes(&[31; 32]); + let binding = disclosure(&key); + let ack = signed(&binding, 42, &key); + let request = DisclosureAcknowledgementRequest::for_delivery( + &binding, + 42, + key.verifying_key().to_bytes(), + ) + .expect("request"); + let request_bytes = request.to_private_bytes().expect("request bytes"); + assert_eq!( + DisclosureAcknowledgementRequest::from_private_bytes(&request_bytes).expect("request"), + request + ); + let encoded = ack.to_private_bytes().expect("ACK"); + let retained = DisclosureAcknowledgement::from_private_bytes(&encoded).expect("decode"); + let authenticated = retained + .verify(&binding, 42) + .expect("authenticated history"); + assert_eq!(authenticated.as_private_bytes(), encoded.as_slice()); + for length in [0, 100] { + assert!( + signed(&binding, length, &key) + .verify(&binding, length) + .is_ok() + ); + } + assert_eq!( + format!("{request:?}"), + "DisclosureAcknowledgementRequest { private: [redacted] }" + ); + assert_eq!( + format!("{ack:?}"), + "DisclosureAcknowledgement { private: [redacted] }" + ); + assert_eq!( + format!("{authenticated:?}"), + "AuthenticatedDisclosureAcknowledgement { private: [redacted] }" + ); + let fixture = json!({ + "schema": "auths.gateway-disclosure-ack-fixture/1", + "scope": "native canonical evidence and pure reducer; no delivery, adapter or isolation claim", + "request": serde_json::from_slice::(&request_bytes).expect("JSON"), + "acknowledgement": serde_json::from_slice::(&encoded).expect("JSON"), + "edges": edges(), "histories": histories(authenticated.as_private_bytes()), + "state_mutations": field_mutations(authenticated.as_private_bytes()), + "substitutions": substitutions(&binding, &ack, &key), "decoding": decoding(&ack), + "empty_and_ceiling_byte_counts_verified": true, + "no_current_authority_or_time_required_for_history": true, + }); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/disclosure-acknowledgement.json"); + let text = format!( + "{}\n", + serde_json::to_string_pretty(&fixture).expect("fixture JSON") + ); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &text).expect("fixture"); + } + assert_eq!(std::fs::read_to_string(&path).expect("fixture"), text); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index c55ee6515..883a39662 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "4833c3f49cd125a75ce87f9d8b1c62216a681fd3fde43fad7c877a6cc0073954"; + "8ea6b17065e33fe92d53a969668d7967e79d9547630e1092306e6d47293d6aa4"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 508c602d0..09e79e2c5 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -910,6 +910,7 @@ impl Record { .transpose()? .unwrap_or_default(), response, + acknowledgement: Vec::new(), locator: self .state .response_locator diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 34319e883..5d2944f03 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -140,6 +140,7 @@ impl JournalProtocol for AcquisitionState { _ => Vec::new(), }, pre_entry: Vec::new(), + acknowledgement: Vec::new(), locator: Vec::new(), reading: Reading::None, evidence: false, From 5b9d9ecd6166ca51ecedbf7a2245524486895826 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 12:23:21 +0000 Subject: [PATCH 046/136] chore(formal): regenerate qualification artifacts Source-SHA: 72fe870ed93df6930337465711c423de85fee6f2 Workflow-Run: 40686836191 --- formal/qualification/aeneas/source-closure.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index cad6af779..6ca74b7d3 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "49eaf38e97eb68ff43d3668591e55aea64dd2ae8d18261758bc366b07a5815bd", + "digest": "3b23be9569e958891b44f48aa891d691c61603bdcceb08d47a358ea6f32803dd", "files": [ { "path": ".cargo/config.toml", @@ -193,7 +193,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/outcome.rs", - "sha256": "ada90e5fa66775db4e0b407cc79f20d1066fb5f3d4077adadc759bda948d1a23" + "sha256": "ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa" }, { "path": "product/runtime/auths-gateway-kernel/src/ratio.rs", @@ -205,7 +205,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/transition.rs", - "sha256": "c06ca2e3b1337c2906c45ddcd9c7d80a7cde4bf2de5e3873a46c2361279c2b51" + "sha256": "ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc" }, { "path": "product/runtime/auths-lifecycle/Cargo.toml", From eafd6a2bfb68df80747530efb9339fe71ab0c053 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 12:42:11 +0000 Subject: [PATCH 047/136] feat(gateway): compile explicit bounded content acquisitions --- bindings/fixtures/gateway/codes.json | 48 + .../fixtures/gateway/content-compilation.json | 1814 +++++++++++++++++ compliance.toml | 8 +- ...017-bound-effect-and-recovery-ownership.md | 29 + docs/plans/0074-implementation-status.md | 48 +- .../0009-bound-effect-and-recovery.md | 30 + ...ound-effects-and-recovery-state-machine.md | 36 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 15 +- .../auths-gateway/src/effect/acquisition.rs | 31 +- .../auths-gateway/src/effect/content.rs | 228 +++ .../auths-gateway/src/effect_content_tests.rs | 445 ++++ .../auths-gateway/src/effect_native_tests.rs | 3 + .../src/pending_vectors/codes.rs | 6 + product/runtime/auths-gateway/src/recipe.rs | 9 +- .../auths-gateway/src/recipe/content.rs | 328 +++ .../runtime/auths-gateway/src/recipe/lower.rs | 14 + .../auths-gateway/src/recipe/review.rs | 7 + .../auths-gateway/src/recipe/source.rs | 2 + .../auths-gateway/src/recipe/validate.rs | 13 + .../auths-gateway/src/semantic_closure.rs | 2 +- 21 files changed, 3106 insertions(+), 12 deletions(-) create mode 100644 bindings/fixtures/gateway/content-compilation.json create mode 100644 product/runtime/auths-gateway/src/effect/content.rs create mode 100644 product/runtime/auths-gateway/src/effect_content_tests.rs create mode 100644 product/runtime/auths-gateway/src/recipe/content.rs diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 95742f1cf..3576d004e 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -243,6 +243,54 @@ "epic": 5, "case": null }, + { + "code": "gateway.content.content-too-large", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.content.invalid-response", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.content.missing-projection", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.content.response-media-type", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.content.response-status", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.content.response-too-large", + "owner": "ContentProjectionError", + "stage": "projection", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.credential.account-mismatch", "owner": "engine", diff --git a/bindings/fixtures/gateway/content-compilation.json b/bindings/fixtures/gateway/content-compilation.json new file mode 100644 index 000000000..a54962a18 --- /dev/null +++ b/bindings/fixtures/gateway/content-compilation.json @@ -0,0 +1,1814 @@ +{ + "schema": "auths.gateway-content-compilation-fixture/1", + "scope": "native compilation and pure bounded projection; no acquisition entry, custody or disclosure", + "cases": [ + { + "projection": { + "kind": "utf8" + }, + "binding": { + "action": [ + 123, + 101, + 92, + 8, + 173, + 255, + 47, + 178, + 84, + 221, + 211, + 211, + 157, + 10, + 244, + 34, + 210, + 16, + 194, + 46, + 222, + 70, + 90, + 131, + 141, + 87, + 142, + 77, + 5, + 50, + 32, + 65 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 126, + 4, + 253, + 125, + 106, + 36, + 2, + 103, + 170, + 218, + 77, + 164, + 116, + 238, + 163, + 187, + 163, + 42, + 101, + 55, + 28, + 247, + 66, + 106, + 113, + 188, + 5, + 248, + 124, + 127, + 255, + 89 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "observer-demo", + "native_authority": [ + 157, + 99, + 226, + 53, + 129, + 14, + 10, + 92, + 196, + 224, + 24, + 133, + 70, + 13, + 131, + 113, + 33, + 97, + 223, + 212, + 241, + 100, + 140, + 29, + 127, + 6, + 83, + 132, + 33, + 30, + 117, + 133 + ], + "operation": "content-1", + "partition": "synthetic-content", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 1024, + "projection": [ + 186, + 134, + 10, + 64, + 59, + 230, + 78, + 145, + 186, + 124, + 229, + 225, + 104, + 26, + 147, + 18, + 130, + 158, + 9, + 66, + 162, + 160, + 43, + 12, + 79, + 132, + 110, + 59, + 179, + 61, + 92, + 83 + ], + "request": [ + 214, + 240, + 166, + 221, + 112, + 228, + 162, + 33, + 238, + 171, + 168, + 166, + 120, + 148, + 49, + 160, + 197, + 198, + 46, + 163, + 205, + 82, + 67, + 223, + 45, + 156, + 139, + 122, + 15, + 140, + 9, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 83, + 137, + 120, + 1, + 231, + 42, + 164, + 181, + 136, + 48, + 195, + 57, + 129, + 186, + 141, + 180, + 16, + 154, + 233, + 52, + 93, + 205, + 193, + 222, + 118, + 65, + 189, + 144, + 152, + 113, + 240, + 91 + ], + "reservations": [ + { + "amount": 1024, + "ceiling": 16384, + "key": [ + 105, + 41, + 83, + 124, + 233, + 83, + 68, + 118, + 39, + 19, + 130, + 240, + 203, + 11, + 244, + 235, + 184, + 81, + 198, + 153, + 242, + 222, + 102, + 43, + 170, + 4, + 115, + 0, + 89, + 232, + 184, + 172 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 1, + "ceiling": 16, + "key": [ + 247, + 97, + 173, + 99, + 52, + 180, + 40, + 254, + 5, + 133, + 22, + 154, + 109, + 61, + 124, + 66, + 222, + 159, + 107, + 132, + 154, + 217, + 111, + 209, + 174, + 108, + 222, + 216, + 78, + 202, + 9, + 17 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "native_call": { + "operation_id": "content-1", + "operator_namespace": "observer-demo", + "recipe_digest": "53897801e72aa4b58830c33981ba8db4109ae9345dcdc1de7641bd909871f05b", + "content_contract": "ba860a403be64e91ba7ce5e1681a9312829e0942a2a02b0c4f846e3bb33d5c53", + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "maximum_response_bytes": 1024 + }, + "review": { + "binding": { + "action": [ + 123, + 101, + 92, + 8, + 173, + 255, + 47, + 178, + 84, + 221, + 211, + 211, + 157, + 10, + 244, + 34, + 210, + 16, + 194, + 46, + 222, + 70, + 90, + 131, + 141, + 87, + 142, + 77, + 5, + 50, + 32, + 65 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 126, + 4, + 253, + 125, + 106, + 36, + 2, + 103, + 170, + 218, + 77, + 164, + 116, + 238, + 163, + 187, + 163, + 42, + 101, + 55, + 28, + 247, + 66, + 106, + 113, + 188, + 5, + 248, + 124, + 127, + 255, + 89 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "observer-demo", + "native_authority": [ + 157, + 99, + 226, + 53, + 129, + 14, + 10, + 92, + 196, + 224, + 24, + 133, + 70, + 13, + 131, + 113, + 33, + 97, + 223, + 212, + 241, + 100, + 140, + 29, + 127, + 6, + 83, + 132, + 33, + 30, + 117, + 133 + ], + "operation": "content-1", + "partition": "synthetic-content", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 1024, + "projection": [ + 186, + 134, + 10, + 64, + 59, + 230, + 78, + 145, + 186, + 124, + 229, + 225, + 104, + 26, + 147, + 18, + 130, + 158, + 9, + 66, + 162, + 160, + 43, + 12, + 79, + 132, + 110, + 59, + 179, + 61, + 92, + 83 + ], + "request": [ + 214, + 240, + 166, + 221, + 112, + 228, + 162, + 33, + 238, + 171, + 168, + 166, + 120, + 148, + 49, + 160, + 197, + 198, + 46, + 163, + 205, + 82, + 67, + 223, + 45, + 156, + 139, + 122, + 15, + 140, + 9, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 83, + 137, + 120, + 1, + 231, + 42, + 164, + 181, + 136, + 48, + 195, + 57, + 129, + 186, + 141, + 180, + 16, + 154, + 233, + 52, + 93, + 205, + 193, + 222, + 118, + 65, + 189, + 144, + 152, + 113, + 240, + 91 + ], + "reservations": [ + { + "amount": 1024, + "ceiling": 16384, + "key": [ + 105, + 41, + 83, + 124, + 233, + 83, + 68, + 118, + 39, + 19, + 130, + 240, + 203, + 11, + 244, + 235, + 184, + 81, + 198, + 153, + 242, + 222, + 102, + 43, + 170, + 4, + 115, + 0, + 89, + 232, + 184, + 172 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 1, + "ceiling": 16, + "key": [ + 247, + 97, + 173, + 99, + 52, + 180, + 40, + 254, + 5, + 133, + 22, + 154, + 109, + 61, + 124, + 66, + 222, + 159, + 107, + 132, + 154, + 217, + 111, + 209, + 174, + 108, + 222, + 216, + 78, + 202, + 9, + 17 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[123,101,92,8,173,255,47,178,84,221,211,211,157,10,244,34,210,16,194,46,222,70,90,131,141,87,142,77,5,50,32,65],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[126,4,253,125,106,36,2,103,170,218,77,164,116,238,163,187,163,42,101,55,28,247,66,106,113,188,5,248,124,127,255,89],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[157,99,226,53,129,14,10,92,196,224,24,133,70,13,131,113,33,97,223,212,241,100,140,29,127,6,83,132,33,30,117,133],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[186,134,10,64,59,230,78,145,186,124,229,225,104,26,147,18,130,158,9,66,162,160,43,12,79,132,110,59,179,61,92,83],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[83,137,120,1,231,42,164,181,136,48,195,57,129,186,141,180,16,154,233,52,93,205,193,222,118,65,189,144,152,113,240,91],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[105,41,83,124,233,83,68,118,39,19,130,240,203,11,244,235,184,81,198,153,242,222,102,43,170,4,115,0,89,232,184,172],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[247,97,173,99,52,180,40,254,5,133,22,154,109,61,124,66,222,159,107,132,154,217,111,209,174,108,222,216,78,202,9,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "a65b450850b4fda1425590d0f72119cef2b00e4936d4ef0a4377c63fcc191380", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "7b655c08adff2fb254ddd3d39d0af422d210c22ede465a838d578e4d05322041", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "content_contract": "ba860a403be64e91ba7ce5e1681a9312829e0942a2a02b0c4f846e3bb33d5c53", + "maximum_response_bytes": 1024, + "operation_id": "content-1", + "operator_namespace": "observer-demo", + "recipe_digest": "53897801e72aa4b58830c33981ba8db4109ae9345dcdc1de7641bd909871f05b", + "resource_arguments": { + "record_id": "recTEST0000000001" + } + }, + "content": { + "disclosure": "separate-authorization-required", + "maximum_content_bytes": 64, + "maximum_transport_seconds": 15, + "projection": { + "kind": "utf8" + }, + "request": { + "headers": [], + "maximum_response_bytes": 1024, + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain" + }, + "required_media_type": "text/plain", + "required_status": 200, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "schema": "auths.gateway-content-read/1" + }, + "method": "GET", + "prerequisite_acquisitions": [], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "consequences": "Acquire only this bounded resource into private gateway custody. This grants no disclosure, mutation, automatic refetch or refund. Recipient release needs its own current authority, approval and durable grant.", + "content": { + "connection": "7e04fd7d6a240267aada4da474eea3bba32a65371cf7426a71bc05f87c7fff59", + "content": { + "disclosure": "separate-authorization-required", + "maximum_content_bytes": 64, + "maximum_transport_seconds": 15, + "projection": { + "kind": "utf8" + }, + "request": { + "headers": [], + "maximum_response_bytes": 1024, + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain" + }, + "required_media_type": "text/plain", + "required_status": 200, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "schema": "auths.gateway-content-read/1" + }, + "disclosure": "separate-authorization-required", + "maximum_attempts": 16, + "recipe": "53897801e72aa4b58830c33981ba8db4109ae9345dcdc1de7641bd909871f05b", + "schema": "auths.gateway-content-acquisition/1" + }, + "contract": "auths.gateway-content-acquisition/1", + "prerequisite_acquisitions": [] + } + }, + "fresh_recompile_passed": true, + "expired_approval_refused": true, + "new_operation_preserves_capacity": true, + "administrative_metadata_preserves_capacity": true, + "changed_installation_and_resource_refused": true, + "old_approval_new_operation_refused": true, + "changed_limit_extra_arguments_mutation_refused": true + }, + { + "projection": { + "kind": "json-string", + "pointer": "/content" + }, + "binding": { + "action": [ + 254, + 75, + 106, + 241, + 48, + 135, + 66, + 134, + 224, + 169, + 188, + 102, + 74, + 218, + 122, + 253, + 135, + 241, + 38, + 2, + 107, + 192, + 76, + 102, + 120, + 45, + 32, + 206, + 236, + 142, + 87, + 152 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 25, + 124, + 247, + 121, + 35, + 198, + 106, + 221, + 114, + 109, + 191, + 0, + 209, + 210, + 101, + 184, + 13, + 254, + 251, + 13, + 1, + 211, + 112, + 202, + 103, + 233, + 235, + 145, + 235, + 6, + 25, + 134 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "observer-demo", + "native_authority": [ + 170, + 43, + 34, + 186, + 94, + 74, + 1, + 23, + 26, + 178, + 211, + 22, + 146, + 255, + 146, + 213, + 204, + 73, + 133, + 210, + 178, + 214, + 37, + 238, + 193, + 9, + 247, + 156, + 169, + 32, + 156, + 136 + ], + "operation": "content-1", + "partition": "synthetic-content", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 1024, + "projection": [ + 191, + 150, + 64, + 208, + 58, + 68, + 35, + 126, + 95, + 94, + 19, + 188, + 108, + 115, + 122, + 96, + 160, + 146, + 172, + 239, + 103, + 210, + 36, + 215, + 169, + 201, + 137, + 184, + 45, + 3, + 170, + 53 + ], + "request": [ + 214, + 240, + 166, + 221, + 112, + 228, + 162, + 33, + 238, + 171, + 168, + 166, + 120, + 148, + 49, + 160, + 197, + 198, + 46, + 163, + 205, + 82, + 67, + 223, + 45, + 156, + 139, + 122, + 15, + 140, + 9, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 134, + 42, + 110, + 152, + 29, + 156, + 1, + 124, + 179, + 237, + 93, + 249, + 136, + 146, + 86, + 80, + 141, + 248, + 26, + 13, + 254, + 119, + 208, + 6, + 67, + 8, + 74, + 194, + 212, + 254, + 38, + 10 + ], + "reservations": [ + { + "amount": 1024, + "ceiling": 16384, + "key": [ + 10, + 235, + 170, + 233, + 141, + 16, + 25, + 219, + 84, + 66, + 54, + 161, + 67, + 174, + 57, + 187, + 195, + 15, + 251, + 170, + 159, + 44, + 6, + 189, + 118, + 32, + 69, + 81, + 22, + 209, + 79, + 214 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 1, + "ceiling": 16, + "key": [ + 179, + 195, + 13, + 135, + 187, + 169, + 232, + 190, + 251, + 252, + 53, + 195, + 183, + 45, + 200, + 128, + 127, + 218, + 53, + 164, + 187, + 69, + 233, + 162, + 187, + 252, + 180, + 121, + 192, + 243, + 7, + 65 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "native_call": { + "operation_id": "content-1", + "operator_namespace": "observer-demo", + "recipe_digest": "862a6e981d9c017cb3ed5df9889256508df81a0dfe77d00643084ac2d4fe260a", + "content_contract": "bf9640d03a44237e5f5e13bc6c737a60a092acef67d224d7a9c989b82d03aa35", + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "maximum_response_bytes": 1024 + }, + "review": { + "binding": { + "action": [ + 254, + 75, + 106, + 241, + 48, + 135, + 66, + 134, + 224, + 169, + 188, + 102, + 74, + 218, + 122, + 253, + 135, + 241, + 38, + 2, + 107, + 192, + 76, + 102, + 120, + 45, + 32, + 206, + 236, + 142, + 87, + 152 + ], + "approval_policy": { + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "kind": "exact" + }, + "compiler": "auths.gateway-effect-compiler/8", + "configuration": [ + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12 + ], + "connection": [ + 25, + 124, + 247, + 121, + 35, + 198, + 106, + 221, + 114, + 109, + 191, + 0, + 209, + 210, + 101, + 184, + 13, + 254, + 251, + 13, + 1, + 211, + 112, + 202, + 103, + 233, + 235, + 145, + 235, + 6, + 25, + 134 + ], + "credential_generation": 1, + "epoch": 1, + "namespace": "observer-demo", + "native_authority": [ + 170, + 43, + 34, + 186, + 94, + 74, + 1, + 23, + 26, + 178, + 211, + 22, + 146, + 255, + 146, + 213, + 204, + 73, + 133, + 210, + 178, + 214, + 37, + 238, + 193, + 9, + 247, + 156, + 169, + 32, + 156, + 136 + ], + "operation": "content-1", + "partition": "synthetic-content", + "protocol": { + "kind": "acquisition", + "maximum_response_bytes": 1024, + "projection": [ + 191, + 150, + 64, + 208, + 58, + 68, + 35, + 126, + 95, + 94, + 19, + 188, + 108, + 115, + 122, + 96, + 160, + 146, + 172, + 239, + 103, + 210, + 36, + 215, + 169, + 201, + 137, + 184, + 45, + 3, + 170, + 53 + ], + "request": [ + 214, + 240, + 166, + 221, + 112, + 228, + 162, + 33, + 238, + 171, + 168, + 166, + 120, + 148, + 49, + 160, + 197, + 198, + 46, + 163, + 205, + 82, + 67, + 223, + 45, + 156, + 139, + 122, + 15, + 140, + 9, + 146 + ] + }, + "qualification_policy": "optional", + "recipe": [ + 134, + 42, + 110, + 152, + 29, + 156, + 1, + 124, + 179, + 237, + 93, + 249, + 136, + 146, + 86, + 80, + 141, + 248, + 26, + 13, + 254, + 119, + 208, + 6, + 67, + 8, + 74, + 194, + 212, + 254, + 38, + 10 + ], + "reservations": [ + { + "amount": 1024, + "ceiling": 16384, + "key": [ + 10, + 235, + 170, + 233, + 141, + 16, + 25, + 219, + 84, + 66, + 54, + 161, + 67, + 174, + 57, + 187, + 195, + 15, + 251, + 170, + 159, + 44, + 6, + 189, + 118, + 32, + 69, + 81, + 22, + 209, + 79, + 214 + ], + "unit": "response-bytes", + "window": { + "kind": "source-lifetime" + } + }, + { + "amount": 1, + "ceiling": 16, + "key": [ + 179, + 195, + 13, + 135, + 187, + 169, + 232, + 190, + 251, + 252, + 53, + 195, + 183, + 45, + 200, + 128, + 127, + 218, + 53, + 164, + 187, + 69, + 233, + 162, + 187, + 252, + 180, + 121, + 192, + 243, + 7, + 65 + ], + "unit": "acquisition-count", + "window": { + "kind": "source-lifetime" + } + } + ], + "schema": "auths.bound-effect/3", + "scope": { + "kind": "unscoped" + } + }, + "binding_canonical": "{\"action\":[254,75,106,241,48,135,66,134,224,169,188,102,74,218,122,253,135,241,38,2,107,192,76,102,120,45,32,206,236,142,87,152],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[25,124,247,121,35,198,106,221,114,109,191,0,209,210,101,184,13,254,251,13,1,211,112,202,103,233,235,145,235,6,25,134],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[170,43,34,186,94,74,1,23,26,178,211,22,146,255,146,213,204,73,133,210,178,214,37,238,193,9,247,156,169,32,156,136],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[191,150,64,208,58,68,35,126,95,94,19,188,108,115,122,96,160,146,172,239,103,210,36,215,169,201,137,184,45,3,170,53],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[134,42,110,152,29,156,1,124,179,237,93,249,136,146,86,80,141,248,26,13,254,119,208,6,67,8,74,194,212,254,38,10],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[10,235,170,233,141,16,25,219,84,66,54,161,67,174,57,187,195,15,251,170,159,44,6,189,118,32,69,81,22,209,79,214],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[179,195,13,135,187,169,232,190,251,252,53,195,183,45,200,128,127,218,53,164,187,69,233,162,187,252,180,121,192,243,7,65],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "b3c4385772ef4f0500e441a3791d30ad6bb90a45684943d66e9a7d6c0f3f9b7b", + "installation": { + "alias": "synthetic", + "connection_contract": "auths.gateway-operation/1", + "connection_id": "conn_AAAAAAAAAAAAAAAAAAAAAA", + "credential_generation": 1, + "provider": "airtable" + }, + "native": { + "action_commitment": "fe4b6af130874286e0a9bc664ada7afd87f126026bc04c66782d20ceec8e5798", + "actors": [ + "key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg" + ], + "arguments": { + "content_contract": "bf9640d03a44237e5f5e13bc6c737a60a092acef67d224d7a9c989b82d03aa35", + "maximum_response_bytes": 1024, + "operation_id": "content-1", + "operator_namespace": "observer-demo", + "recipe_digest": "862a6e981d9c017cb3ed5df9889256508df81a0dfe77d00643084ac2d4fe260a", + "resource_arguments": { + "record_id": "recTEST0000000001" + } + }, + "content": { + "disclosure": "separate-authorization-required", + "maximum_content_bytes": 64, + "maximum_transport_seconds": 15, + "projection": { + "kind": "json-string", + "pointer": "/content" + }, + "request": { + "headers": [], + "maximum_response_bytes": 1024, + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain" + }, + "required_media_type": "application/json", + "required_status": 200, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "schema": "auths.gateway-content-read/1" + }, + "method": "GET", + "prerequisite_acquisitions": [], + "protocol": "acquisition" + }, + "renderer": "auths.literal-complete-review/1", + "schema": "auths.private-effect-review/2", + "semantic": { + "consequences": "Acquire only this bounded resource into private gateway custody. This grants no disclosure, mutation, automatic refetch or refund. Recipient release needs its own current authority, approval and durable grant.", + "content": { + "connection": "197cf77923c66add726dbf00d1d265b80dfefb0d01d370ca67e9eb91eb061986", + "content": { + "disclosure": "separate-authorization-required", + "maximum_content_bytes": 64, + "maximum_transport_seconds": 15, + "projection": { + "kind": "json-string", + "pointer": "/content" + }, + "request": { + "headers": [], + "maximum_response_bytes": 1024, + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain" + }, + "required_media_type": "application/json", + "required_status": 200, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "schema": "auths.gateway-content-read/1" + }, + "disclosure": "separate-authorization-required", + "maximum_attempts": 16, + "recipe": "862a6e981d9c017cb3ed5df9889256508df81a0dfe77d00643084ac2d4fe260a", + "schema": "auths.gateway-content-acquisition/1" + }, + "contract": "auths.gateway-content-acquisition/1", + "prerequisite_acquisitions": [] + } + }, + "fresh_recompile_passed": true, + "expired_approval_refused": true, + "new_operation_preserves_capacity": true, + "administrative_metadata_preserves_capacity": true, + "changed_installation_and_resource_refused": true, + "old_approval_new_operation_refused": true, + "changed_limit_extra_arguments_mutation_refused": true + } + ], + "projections": [ + { + "projection": "utf8", + "status_media_utf8_and_limits_enforced": true, + "private_content_not_in_contract_or_debug": true, + "request": { + "schema": "auths.gateway-content-read/1", + "request": { + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain", + "headers": [], + "maximum_response_bytes": 1024 + }, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "projection": { + "kind": "utf8" + }, + "maximum_content_bytes": 64, + "required_status": 200, + "required_media_type": "text/plain", + "maximum_transport_seconds": 15, + "disclosure": "separate-authorization-required" + }, + "response_codes": [ + "gateway.content.response-status", + "gateway.content.response-media-type", + "gateway.content.response-too-large", + "gateway.content.invalid-response", + "gateway.content.content-too-large" + ] + }, + { + "projection": "json-string", + "status_media_utf8_and_limits_enforced": true, + "private_content_not_in_contract_or_debug": true, + "request": { + "schema": "auths.gateway-content-read/1", + "request": { + "method": "GET", + "url": "https://api.airtable.com/documents/recTEST0000000001?format=text%2Fplain", + "headers": [], + "maximum_response_bytes": 1024 + }, + "resource_arguments": { + "record_id": "recTEST0000000001" + }, + "projection": { + "kind": "json-string", + "pointer": "/content" + }, + "maximum_content_bytes": 64, + "required_status": 200, + "required_media_type": "application/json", + "maximum_transport_seconds": 15, + "disclosure": "separate-authorization-required" + }, + "response_codes": [ + "gateway.content.response-status", + "gateway.content.response-media-type", + "gateway.content.response-too-large", + "gateway.content.invalid-response", + "gateway.content.content-too-large", + "gateway.content.missing-projection" + ] + } + ], + "invalid_declarations": { + "invalid_fields_refused": [ + "schema", + "resource_field", + "path", + "query", + "projection", + "maximum_response_bytes", + "maximum_content_bytes" + ], + "unsafe_path_query_pointer_refused": true + }, + "undeclared_content_read_refused": true +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 0d2c90a46..0abf4c488 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1604,8 +1604,8 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1615,6 +1615,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +content-compilation-contract = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_compilation_fixture_is_current", +] + disclosure-acknowledgement-contract = [ "product/runtime/auths-gateway/src/effect_disclosure_tests.rs#native_disclosure_acknowledgement_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index bc86b33a1..2050e8974 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -800,3 +800,32 @@ protected-content owner, disclosure admission/entry, recipient transport and runtime journal projection remain required before this is a managed release path. Kani oracle source includes disclosure; source-linked Lean regeneration and refinement are still open P4 obligations, with no new proof claim. + + +## Explicit content recipe compilation + +General content reads are an explicit digest-bound recipe capability rather +than reinterpreted credential checks or mutation observations. The versioned +`content` declaration is optional within the existing source envelope; absent +recipes retain their original canonical bytes/digest and cannot compile content +reads. The declaration has its own closed schema and complete operator review. +`recipe::content` validates resource fields, fixed query pairs and bounded +UTF-8/JSON-string projection. It reuses the existing path/header lowering, +percent encoder and duplicate-rejecting provider parser. No provider-name branch +or new runtime callback is introduced. + +`effect::content` participates in the same native acquisition compilation, +review, exact approval and fresh recompile owner. Its native read call binds the +explicit resource/account arguments and full private contract. A sixteen-entry +source allowance excludes logical operation IDs and administrative metadata; +it includes recipe, connection ID, credential generation/reference and exact +resource/account arguments. The full connection record still binds approval, +so administrative changes demand recompilation without silently refreshing that +allowance. Fixed-window native managed bounds are additionally retained. + +Content projection returns private bytes and typed response errors, not a +receipt or release grant. Runtime must authenticate/retain HTTP metadata and +content under the journal contract and issue a distinct disclosure capability. +The current compiler slice does not add content admission/entry, read-only +installation, AP070 metadata predicates, recipient transport or content custody. +These remain required before migrating the maintained demo. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 4c31100df..d7a1b14d4 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1076,6 +1076,52 @@ closure regeneration passed after that correction (one artifact-generation test) this corpus do not establish durable accounting or actual byte delivery. No A01–A22 acceptance criterion closes. +## Explicit content acquisition compiler checkpoint + +- Added the digest-bound opt-in `content` capability with its own + `auths.gateway-content-read/1` schema. It selects one string/enum resource, + existing fixed/verified path and account headers, bounded sorted literal query + pairs, and UTF-8 or JSON-string projection. The operator review includes the + complete declaration. An absent declaration cannot compile content reads; + the reserved native read tool cannot be installed as a mutation tool. +- Added `ContentReadTarget` and `compile_content_acquisition` to the existing + acquisition compiler. Fresh native read proof, full private target/connection, + source allowance, managed policy counters, prerequisites, exact approval and + complete native review share the existing effect owner. Full revalidation + recompiles content effects. Mutation/recovery/candidate admission cannot be + borrowed by a content effect. No content transport or permit was added here. +- Source allowance keys bind recipe, connection ID, credential generation/ + reference and exact resource/account arguments, excluding logical operation + IDs and administrative metadata. The full connection still binds the approval. + The native corpus checks that disable/enable timestamp changes preserve keys + while old bound approval refuses the changed installation. Durable allocation + enforcement remains part of the next journal work, not a compiler claim. +- Pure projection returns exact private zeroizing bytes, requires status 200, + declared media type and optional UTF-8 charset, and rejects malformed UTF-8, + duplicate JSON, missing/non-string projections and both raw/projected limits. + Six typed response codes distinguish these facts from native authority denial. +- Exact artifact construction passed on `72fe870e` plus this source: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact observed_tests::effect_native_tests::content_tests::native_content_compilation_fixture_is_current pending_vectors::codes::code_inventory_is_current`. + The final two-test run passed in 0.06 seconds. The corpus uses real native + proof/approval signatures for both projections, fresh/expired recompile, + different resource/connection/limit, extra arguments, approval reuse and stable + capacity keys; it checks the declared projection limits and all six error + codes. Final semantic-closure generation passed one exact test. +- Initial fixture construction used a nonexistent review method and accidentally + supplied content source as profile-schema fields. The fixture now invokes + `render_literal` and edits the recipe source while preserving its profile lock. + No production check was weakened. No broad local gate, Kani, Lean or hosted CI + ran. This is compilation/pure projection evidence only. +- Fetch found bot commit `5b9d9ecd`, changing only formal source-closure hashes + for the prior ACK/kernel source. It was inspected and retained by fast-forward; + no hosted result was inspected. +- Next requirements are the content plan in the shared journal, response metadata + and protected retention, separately authorized disclosure entry/transport/ACK + persistence, standalone read-only installation and AP070 metadata predicates/ + consumer cutover. The existing recipe still includes a mutation declaration; + this opt-in content capability is not a claim that standalone read-only + installation or the Google domain cutover is complete. A01–A22 remain open. + ## Phase gates | Phase | State | Outstanding gate | @@ -1083,7 +1129,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery, prerequisite and application recovery routes with managed read budgets wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery/prerequisite runtime and content/ACK compilation wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 259fdfd81..9a716ef78 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -528,3 +528,33 @@ AP070 differential equivalence nor a durability, actual delivery, authenticated channel or process-isolation claim. Those remain required for the direct consumer cutover. Kani source is extended, not executed; translated Lean/refinement work remains pending. + + +## Content acquisition compiler comparison + +AP070 separates exact resource selection, bounded UTF-8 response validation and +later release. Its provider-specific metadata predicates (ID, trash state, +download capability and MIME-dependent endpoint) are additional domain semantics +and are not erased by the new content declaration. They still need reviewed +closed declarations/reference evidence before the AP070 runtime cutover. + +The identical subset implemented here is a fixed-origin GET over verified +resource/account values, literal query parameters, and bounded UTF-8 or one +JSON-string projection. Path/header/percent construction and JSON duplicate +rejection reuse the existing gateway mechanisms. The new declaration has one +resource field, sixteen path segments, eight sorted unique query pairs, 64-byte +ASCII query names, 512-byte query values, the existing 8,192-byte URL bound and +65,536-byte response/content ceilings. It rejects response locators and operation +IDs as content resources. Query values are encoded data; no callback interprets +them. The ADR's narrow primitive exception applies to this construction subset, +not to Google metadata semantics or to a general provider qualification claim. + +`content-compilation.json` uses native signatures, exact approval and recompile +for both projections. It exercises resource/installation/limit changes, +operation-independent and administrative-metadata-independent capacity keys, +expired/reused approval refusal, operator/native review, malformed source/query/ +pointer rejection and all six typed response failures. Projection copies exact +bytes without truncation into a zeroizing buffer and gives no disclosure permit. +This evidence does not establish durable source allocations, actual provider +transport, content custody, standalone read-only deployment, AP070 differential +parity or a recipient release. Those remain part of P3/P4. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index c0170c085..b5a51948c 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -368,6 +368,42 @@ same native binding, review renderer and approval machinery serve both types. This compilation contract does not itself implement read admission, an entry permit, observation evidence or disclosure. +Explicit content acquisition is a versioned opt-in recipe capability, +`content.schema = auths.gateway-content-read/1`, within recipe source `/3`. +It is included in the recipe digest and operator review; absence permits no +content acquisition. The declaration selects one string/enum resource field, +a fixed/verified-resource path (existing 16-segment bound), up to eight sorted +unique literal query pairs (64-byte ASCII names, 512-byte values), and either +exact UTF-8 content or a JSON-string pointer (128 bytes/eight tokens with valid +RFC 6901 escapes). The source origin, credential and registered version/account +headers remain the existing recipe owners. Dynamic URLs, response-derived +locators, operation-ID path parameters and arbitrary callbacks are refused. + +`auths_gateway_content_read_v1` is a reserved native read tool. Its private +`auths.gateway-content-acquisition/1` contract binds the exact installed +connection, recipe, resource/account arguments, GET, projection, response and +content limits. Both byte limits are at most 65,536; the content ceiling cannot +exceed the response ceiling. A source allowance has sixteen attempts and the +full response ceiling per attempt, keyed by recipe, connection ID, credential +generation/reference and resource/account arguments. Changing logical operation +IDs or administrative timestamps/state cannot reset that allowance. Selected +native count/byte policy bounds also apply. Account/denied-capability +prerequisites use the existing compiled plan. Native exact approval and full +recompilation are separate from the resource proof. Credential-check and recovery +admission cannot be borrowed by a content effect. + +Projection requires status 200 and the declared `text/plain` or +`application/json` media type, optionally with UTF-8 charset. It refuses lossy +UTF-8, duplicate-member JSON, missing/non-string selections and over-limit +responses/content instead of truncating. It returns private zeroizing bytes; +projection alone establishes no transport provenance, custody or release +permission. Stable native response errors distinguish status, media type, raw +response limit, malformed input, missing projection and projected-content limit. +The runtime must retain authentic response metadata with the acquired bytes +before using this contract for disclosure. Standalone read-only installation, +AP070 metadata checks, content journal/transport and protected retention remain +implementation requirements; this compiler contract alone is not their cutover. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 93365d8fe..7211b77fd 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2abd78e46b44a1487ba8d973556ea909e670a3534f458fbe78a6a71f6e555696"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"d7705d7a899819248cbe2d15335d765fb73530671efd29cc0a8b40119828a6bb"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"1bde52ae5c9e9d5b706dcad28c47478d436f35aa5d86a97c995fed6842dc8e69"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"f6168ed4b690e6664322de4966b44321e5474dbcab743dea88162904f4b1f428"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"f8702e8b86411cdda27db7e9e10e532cf10ed8eb758b4e868bef73433c697fa1"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"8088b8751ed831dbb48247af953c6290ac95e2a438ccd5bd65eff54be06a1fd1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"e619a6092ae198eadb6571296a9bd48fffff73ae7333f2a9739ad1462c910ddd"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"0abcb1a16af27a8067970fde333ed70cab516e884b9b07abdabc3c7366e49a1f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"3711b17605cb7b0d639bc1b180449231f5882a306cab20e2c7782155cc63b0d4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"d4aa4c93a044c407524579536fecd5101497be84fa0cfff2c09e5c66af6157e0"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"73516b80c3795e30565af62019cc4594f9ed764bf6886ec29e53708149864368"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"c019df98215bdc04c03b512c002282f29a1f8ff24fa389584e27b12a81e95d90"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"0a36f2fde1ec10ec8cfe0d04dda7956872a2636490d40a73e733367593159659"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"875939158f5930ac2547bbdf837721b847691b21e792522bc9101f87bf73c3f1"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4aa0673b5c2583d01500e7017f05c63337ab5b43ca7e2ab7d9ccc445c532cce5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fb7c0e6f7ad4304b9d5066fbee2cfa9a1fcee554a0c5a6d470d2d8c9e8f5f4bf"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"b5886a5dff98d7b3483411e4a7b5439f1982a7a17a70a0314b68dd9bfea2f782"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"d4aa4c93a044c407524579536fecd5101497be84fa0cfff2c09e5c66af6157e0"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index b15cbf92b..dcaac041f 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -20,6 +20,8 @@ use zeroize::Zeroizing; mod acquisition; mod candidate; +mod content; +pub use content::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; mod disclosure; pub use disclosure::{ AuthenticatedDisclosureAcknowledgement, DISCLOSURE_ACK_SCHEMA, DisclosureAcknowledgement, @@ -1102,7 +1104,8 @@ impl ApprovedEffect { match &self.effect.command { CompiledEffect::Acquisition(command) => match &command.target { acquisition::AcquisitionTarget::Candidate(target) => Some(target), - acquisition::AcquisitionTarget::Recovery(_) => None, + acquisition::AcquisitionTarget::Recovery(_) + | acquisition::AcquisitionTarget::Content(_) => None, }, CompiledEffect::Mutation(_) => None, } @@ -1119,7 +1122,8 @@ impl ApprovedEffect { CompiledEffect::Mutation(_) => None, CompiledEffect::Acquisition(command) => match &command.target { acquisition::AcquisitionTarget::Recovery(target) => Some(target), - acquisition::AcquisitionTarget::Candidate(_) => None, + acquisition::AcquisitionTarget::Candidate(_) + | acquisition::AcquisitionTarget::Content(_) => None, }, } } @@ -1218,6 +1222,13 @@ impl ApprovedEffect { &self.effect.proof, &self.effect.action, )?, + acquisition::AcquisitionTarget::Content(target) => compile_content_acquisition( + installed, + target, + now, + &self.effect.proof, + &self.effect.action, + )?, acquisition::AcquisitionTarget::Candidate(target) => compile_candidate_credential( installed, target, diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 8ccde1d31..02fc36ed4 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -431,6 +431,7 @@ impl AcquisitionCapacity { pub(super) enum AcquisitionTarget { Recovery(Box), Candidate(Box), + Content(Box), } pub(super) struct VerifiedAcquisition { @@ -449,7 +450,9 @@ impl VerifiedAcquisition { pub(super) fn journal_plan(&self) -> Result { match &self.target { AcquisitionTarget::Recovery(target) => target.journal_plan(&self.prerequisites), - AcquisitionTarget::Candidate(_) => Err(EffectBindingError::Invalid), + AcquisitionTarget::Candidate(_) | AcquisitionTarget::Content(_) => { + Err(EffectBindingError::Invalid) + } } } @@ -457,6 +460,7 @@ impl VerifiedAcquisition { match &self.target { AcquisitionTarget::Recovery(target) => target.request_bytes(&self.prerequisites), AcquisitionTarget::Candidate(target) => target.request_bytes(), + AcquisitionTarget::Content(target) => target.request_bytes(&self.prerequisites), } } @@ -468,7 +472,7 @@ impl VerifiedAcquisition { "action_commitment": hex::encode(self.action_commitment), "arguments": self.arguments, "method": match &self.target { - AcquisitionTarget::Recovery(_) => "GET", + AcquisitionTarget::Recovery(_) | AcquisitionTarget::Content(_) => "GET", AcquisitionTarget::Candidate(target) => target.method(), }, "prerequisite_acquisitions": self.prerequisites, @@ -476,6 +480,7 @@ impl VerifiedAcquisition { match &self.target { AcquisitionTarget::Recovery(target) => review["recovery"] = target.contract(), AcquisitionTarget::Candidate(target) => review["candidate"] = target.contract(), + AcquisitionTarget::Content(target) => review["content"] = target.private_read_review(), } review } @@ -508,7 +513,7 @@ pub fn compile_recovery_acquisition( #[allow( clippy::too_many_lines, - reason = "one native verification path retains the two closed acquisition target contracts" + reason = "one native verification path retains the closed acquisition target contracts" )] pub(super) fn compile_acquisition( installed: &EffectInstallation<'_>, @@ -531,6 +536,9 @@ pub(super) fn compile_acquisition( AcquisitionTarget::Candidate(target) => target .validate_installation(installed) .map_err(|_| invalid())?, + AcquisitionTarget::Content(target) => target + .validate_installation(installed) + .map_err(|_| invalid())?, } let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; let verified = sealed.action().ok_or_else(invalid)?; @@ -550,6 +558,9 @@ pub(super) fn compile_acquisition( AcquisitionTarget::Candidate(target) => { target.authorization_call(installed.recipe, &operation) } + AcquisitionTarget::Content(target) => { + target.authorization_call(installed.recipe, &operation) + } } .map_err(|_| invalid())?; // Comparing the canonical call also rejects extra fields and channel-binding @@ -571,7 +582,7 @@ pub(super) fn compile_acquisition( let action_commitment = commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; let prerequisites = match &target { - AcquisitionTarget::Recovery(_) => { + AcquisitionTarget::Recovery(_) | AcquisitionTarget::Content(_) => { Prerequisites::credentials(installed.recipe, *installed.connection.account_commitment()) .map_err(|_| invalid())? } @@ -592,6 +603,18 @@ pub(super) fn compile_acquisition( json!({"contract": "auths.gateway-recovery-read/1", "recovery": target.contract(), "consequences": "Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor."}), ), + AcquisitionTarget::Content(target) => ( + target.binding( + installed, + &operation, + action_commitment, + authority, + bound.as_ref(), + &prerequisites, + )?, + json!({"contract": "auths.gateway-content-acquisition/1", "content": target.contract().map_err(|_| invalid())?, + "consequences": "Acquire only this bounded resource into private gateway custody. This grants no disclosure, mutation, automatic refetch or refund. Recipient release needs its own current authority, approval and durable grant."}), + ), AcquisitionTarget::Candidate(target) => ( target.binding( installed, diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs new file mode 100644 index 000000000..3b328d029 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -0,0 +1,228 @@ +//! Independent content read compilation from an explicit recipe capability. +//! Compilation does not grant entry, retain a response or release content. + +use super::acquisition::{AcquisitionTarget, build_binding, compile_acquisition}; +use super::*; +use crate::recipe::ClosedContentRead; +use auths_profile_mcp::McpToolCall; +use serde_json::{Map, Value, json}; + +/// Reserved native content acquisition tool, never a provider mutation tool. +pub const CONTENT_READ_TOOL: &str = "auths_gateway_content_read_v1"; +const CONTRACT: &str = "auths.gateway-content-acquisition/1"; +/// Permanent source allowance per installed recipe/resource/credential binding. +const MAX_CONTENT_ATTEMPTS: u64 = 16; + +/// Exact resource and compiler-owned content GET on one installed connection. +/// Public construction is data-only; no native authority is inferred from an +/// operator's recipe, a connection record or arbitrary resource parameters. +#[derive(Clone)] +pub struct ContentReadTarget { + recipe: [u8; 32], + connection: ConnectionRecord, + arguments: Map, + read: ClosedContentRead, +} + +impl fmt::Debug for ContentReadTarget { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("ContentReadTarget { private: [redacted] }") + } +} + +impl ContentReadTarget { + /// Resolves only the declared recipe content capability and exact resource + /// arguments. The live connection, native proof, exact approval and shared + /// journal must all be checked later before any external entry. + /// + /// # Errors + /// Refuses an absent/invalid content capability, mismatched connection or + /// extra/missing/invalid resource arguments. This performs no custody/I/O. + pub fn new( + recipe: &CompiledRecipe, + connection: &ConnectionRecord, + arguments: Map, + ) -> Result { + GatewayConnectionDescriptor::from_record(connection, recipe) + .map_err(|_| EffectBindingError::Invalid)?; + let read = recipe + .content_read(&arguments) + .map_err(|_| EffectBindingError::Invalid)?; + let target = Self { + recipe: *recipe.digest(), + connection: connection.clone(), + arguments, + read, + }; + canonical(&target.contract()?)?; + Ok(target) + } + + fn connection_commitment(&self) -> Result<[u8; 32], EffectBindingError> { + let bytes = Zeroizing::new( + self.connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + commitment("auths.effect-installation/1", &bytes) + } + + pub(super) fn contract(&self) -> Result { + Ok(json!({ + "schema": CONTRACT, + "recipe": hex::encode(self.recipe), + "connection": hex::encode(self.connection_commitment()?), + "content": self.read.private_contract(), + "maximum_attempts": MAX_CONTENT_ATTEMPTS, + "disclosure": "separate-authorization-required", + })) + } + + pub(super) fn private_read_review(&self) -> Value { + self.read.private_contract() + } + + pub(super) fn request_bytes( + &self, + prerequisites: &Prerequisites, + ) -> Result>, EffectBindingError> { + canonical( + &json!({"request": self.read.private_request(), "prerequisite_acquisitions": prerequisites}), + ) + } + + pub(super) fn validate_installation( + &self, + installed: &EffectInstallation<'_>, + ) -> Result<(), EffectBindingError> { + let current = Self::new( + installed.recipe, + installed.connection, + self.arguments.clone(), + )?; + if self.recipe != *installed.recipe.digest() + || canonical(¤t.contract()?)? != canonical(&self.contract()?)? + { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + /// Authors the native read call to be signed/authorized independently of a + /// mutation or credential check. The resource arguments and full compiler + /// contract are both bound; no caller URL, projection or byte-limit override + /// is accepted. Returned data belongs on private authoring/review channels. + /// + /// # Errors + /// Refuses another recipe or unrepresentable canonical arguments. + pub fn authorization_call( + &self, + recipe: &CompiledRecipe, + operation: &LogicalOperationId, + ) -> Result { + if self.recipe != *recipe.digest() { + return Err(EffectBindingError::Invalid); + } + let arguments = json!({ + "operation_id": operation.as_str(), + "operator_namespace": recipe.namespace().as_str(), + "recipe_digest": recipe.digest_hex(), + "content_contract": hex::encode(commitment(CONTRACT, &canonical(&self.contract()?)?)?), + "resource_arguments": self.arguments, + "maximum_response_bytes": self.read.transport().maximum_response_bytes(), + }) + .as_object() + .cloned() + .ok_or(EffectBindingError::Invalid)?; + McpToolCall::new(recipe.service(), CONTENT_READ_TOOL, arguments) + .map_err(|_| EffectBindingError::Invalid) + } + + pub(super) fn binding( + &self, + installed: &EffectInstallation<'_>, + operation: &LogicalOperationId, + action_commitment: [u8; 32], + native_authority: [u8; 32], + bound: Option<&crate::bounds::BoundAdmission>, + prerequisites: &Prerequisites, + ) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + self.validate_installation(installed) + .map_err(|_| invalid())?; + let contract = commitment( + CONTRACT, + &canonical(&self.contract().map_err(|_| invalid())?).map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?; + let maximum_bytes = self.read.transport().maximum_response_bytes() as u64; + // Administrative timestamps/state and logical operation IDs cannot + // reset this resource allowance. Native policy windows also apply. + let capacity_key = |unit| { + commitment( + "auths.content-acquisition-capacity/1", + &canonical(&( + self.recipe, + self.connection.connection_id().as_str(), + self.connection.credential_generation().get(), + self.connection.credential_reference_commitment(), + &self.arguments, + unit, + ))?, + ) + }; + let capacity = AcquisitionCapacity { + count_key: capacity_key(Unit::AcquisitionCount).map_err(|_| invalid())?, + bytes_key: capacity_key(Unit::ResponseBytes).map_err(|_| invalid())?, + maximum_bytes, + attempts: MAX_CONTENT_ATTEMPTS, + }; + let mut reservations = capacity.reservations(); + reservations.extend(managed_reservations( + bound, + Unit::AcquisitionCount, + Unit::ResponseBytes, + )); + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + build_binding( + installed, + operation, + action_commitment, + native_authority, + Protocol::Acquisition { + request: commitment( + "auths.effect-acquisition-request/2", + &self.request_bytes(prerequisites).map_err(|_| invalid())?, + ) + .map_err(|_| invalid())?, + projection: contract, + maximum_response_bytes: maximum_bytes, + }, + reservations, + ) + } +} + +/// Produces an immutable native content acquisition effect from separately +/// verified read authority and the installed recipe/connection. Exact approval +/// and durable admission/entry remain separate. This cannot execute a mutation, +/// acquire credentials, enter transport or disclose any acquired content. +/// +/// # Errors +/// Refuses invalid native proof, changed target/installation, extra arguments, +/// unrelated scope or invalid managed acquisition limits. +pub fn compile_content_acquisition( + installed: &EffectInstallation<'_>, + target: &ContentReadTarget, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + compile_acquisition( + installed, + AcquisitionTarget::Content(Box::new(target.clone())), + now, + proof, + action, + ) +} diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs new file mode 100644 index 000000000..797d6a739 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -0,0 +1,445 @@ +//! Native recipe/content compilation corpus. No runtime acquisition, content +//! custody, release or provider transport is asserted by these fixtures. +use super::*; +use crate::effect::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; + +fn declaration(projection: Value) -> Value { + json!({"schema": "auths.gateway-content-read/1", "resource_field": "record_id", + "path": [{"kind": "fixed", "value": "documents"}, {"kind": "field", "name": "record_id"}], + "query": [{"name": "format", "value": "text/plain"}], "projection": projection, + "maximum_response_bytes": 1024, "maximum_content_bytes": 64}) +} + +fn content_recipe(content: Value) -> Result { + let (source, lock) = h::recipe_sources(&json!({}), &Value::Null).expect("source/lock"); + let mut source: Value = serde_json::from_slice(&source).expect("source"); + source["content"] = content; + CompiledRecipe::compile(&serde_json::to_vec(&source).expect("source bytes"), &lock) +} + +fn invalid_declarations() -> Value { + let original = declaration(json!({"kind": "json-string", "pointer": "/content"})); + let mut cases = vec![]; + for field in [ + "schema", + "resource_field", + "path", + "query", + "projection", + "maximum_response_bytes", + "maximum_content_bytes", + ] { + let mut changed = original.clone(); + changed[field] = match field { + "schema" => json!("auths.gateway-content-read/0"), + "resource_field" => json!("operation_id"), + "path" => json!([{"kind": "response-field", "pointer": "/url", "max_bytes": 20}]), + "query" => json!([{"name": "format", "value": "a"}, {"name": "format", "value": "b"}]), + "projection" => json!({"kind": "json-string", "pointer": "/bad~3pointer"}), + "maximum_response_bytes" => json!(65537), + "maximum_content_bytes" => json!(1025), + _ => unreachable!(), + }; + assert!(content_recipe(changed).is_err(), "{field}"); + cases.push(field); + } + for path in [ + json!([{"kind": "fixed", "value": ".."}, {"kind": "field", "name": "record_id"}]), + json!([{"kind": "field", "name": "operation_id"}, {"kind": "field", "name": "record_id"}]), + json!([{"kind": "field", "name": "replacement"}, {"kind": "field", "name": "record_id"}]), + ] { + let mut changed = original.clone(); + changed["path"] = path; + assert!(content_recipe(changed).is_err()); + } + for query in [ + json!([{"name": "z", "value": "a"}, {"name": "a", "value": "b"}]), + json!([{"name": "a&evil", "value": "a"}]), + json!([{"name": "a", "value": "x\r\ny"}]), + json!([{"name": "a", "value": "x".repeat(513)}]), + ] { + let mut changed = original.clone(); + changed["query"] = query; + assert!(content_recipe(changed).is_err()); + } + for pointer in ["/bad~", "/bad~3", "", "/a/b/c/d/e/f/g/h/i"] { + let mut changed = original.clone(); + changed["projection"]["pointer"] = json!(pointer); + assert!(content_recipe(changed).is_err()); + } + json!({"invalid_fields_refused": cases, "unsafe_path_query_pointer_refused": true}) +} + +#[allow( + clippy::too_many_lines, + reason = "one bounded representation and stable response-code corpus" +)] +fn projections( + recipe: &CompiledRecipe, + arguments: &Map, + json_string: bool, +) -> Value { + let read = recipe.content_read(arguments).expect("closed read"); + let sentinel = "PRIVATE-CONTENT-SYNTHETIC"; + let body = if json_string { + serde_json::to_vec(&json!({"content": sentinel})).expect("JSON") + } else { + sentinel.as_bytes().to_vec() + }; + let content = read + .project_response(200, read.media_type(), &body) + .expect("private content"); + assert_eq!(content.as_slice(), sentinel.as_bytes()); + assert!( + read.project_response(200, &format!("{}; charset=utf-8", read.media_type()), &body) + .is_ok() + ); + assert!( + read.project_response(403, read.media_type(), &body) + .is_err() + ); + assert!( + read.project_response(200, "application/octet-stream", &body) + .is_err() + ); + assert!( + read.project_response( + 200, + &format!("{}; charset=iso-8859-1", read.media_type()), + &body + ) + .is_err() + ); + assert!( + read.project_response( + 200, + &format!("{}; charset=utf-8; extra=x", read.media_type()), + &body + ) + .is_err() + ); + assert!( + read.project_response(200, read.media_type(), &vec![b'a'; 1025]) + .is_err() + ); + assert!( + read.project_response(200, read.media_type(), &[255]) + .is_err() + ); + for length in [0, 64, 65] { + let body = if json_string { + serde_json::to_vec(&json!({"content": "x".repeat(length)})).expect("JSON") + } else { + vec![b'x'; length] + }; + assert_eq!( + read.project_response(200, read.media_type(), &body).is_ok(), + length <= 64 + ); + } + if json_string { + for body in [ + br#"{"content":"wrong","content":"right"}"#.as_slice(), + br#"{"other":"value"}"#, + br#"{"content":42}"#, + br#"{"content":"ok"} {}"#, + ] { + assert!(read.project_response(200, read.media_type(), body).is_err()); + } + } + let over_content = if json_string { + serde_json::to_vec(&json!({"content": "x".repeat(65)})).expect("JSON") + } else { + vec![b'x'; 65] + }; + let mut codes = vec![ + read.project_response(403, read.media_type(), &body) + .expect_err("status") + .code(), + read.project_response(200, "application/octet-stream", &body) + .expect_err("media") + .code(), + read.project_response(200, read.media_type(), &vec![b'x'; 1025]) + .expect_err("response bound") + .code(), + read.project_response(200, read.media_type(), &[255]) + .expect_err("invalid response") + .code(), + read.project_response(200, read.media_type(), &over_content) + .expect_err("content bound") + .code(), + ]; + assert_eq!( + codes, + vec![ + "gateway.content.response-status", + "gateway.content.response-media-type", + "gateway.content.response-too-large", + "gateway.content.invalid-response", + "gateway.content.content-too-large" + ] + ); + if json_string { + let code = read + .project_response(200, read.media_type(), b"{}") + .expect_err("missing projection") + .code(); + assert_eq!(code, "gateway.content.missing-projection"); + codes.push(code); + } + assert_eq!( + format!("{read:?}"), + "ClosedContentRead { private: [redacted] }" + ); + assert!(!read.private_contract().to_string().contains(sentinel)); + json!({"projection": if json_string {"json-string"} else {"utf8"}, + "status_media_utf8_and_limits_enforced": true, "private_content_not_in_contract_or_debug": true, + "request": read.private_contract(), "response_codes": codes}) +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one native signed compilation corpus with independent negative cases" +)] +fn native_content_compilation_fixture_is_current() { + let root = signer(h::ROOT_SEED); + let reader = signer(0x33); + let observer = signer(h::OBSERVER_SEED); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = EffectPolicy::new("synthetic-content".to_owned(), 1, public).expect("policy"); + let arguments = json!({"record_id": RECORD}) + .as_object() + .expect("arguments") + .clone(); + let mut cases = vec![]; + let mut projection_cases = vec![]; + for projection in [ + json!({"kind": "utf8"}), + json!({"kind": "json-string", "pointer": "/content"}), + ] { + let recipe = content_recipe(declaration(projection.clone())).expect("content recipe"); + assert_eq!( + recipe.review_document()["content_acquisition"]["declaration"], + declaration(projection.clone()) + ); + let connection = connection(&recipe); + let target = ContentReadTarget::new(&recipe, &connection, arguments.clone()) + .expect("content target"); + let operation = LogicalOperationId::parse("content-1").expect("operation"); + let call = target + .authorization_call(&recipe, &operation) + .expect("native read call"); + let read_context = + h::context_for_tool(&root, &observer.principal, NOW, &call).expect("read trust"); + let grant = h::grant_for_tool( + &root, + &reader.principal, + None, + window(NOW - 3600, NOW + 3600), + &call, + ) + .expect("grant"); + let submission = submission_for_call(&root, &reader, &grant, &call, &[]); + let installed = policy.installation( + &recipe, + &read_context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = compile_content_acquisition( + &installed, + &target, + NOW, + &submission.proof, + &submission.action, + ) + .expect("native effect"); + assert!(effect.private_request().is_none(), "not a mutation"); + let review = effect.private_review().expect("review"); + let literal = review + .render_literal(crate::effect::LITERAL_REVIEW_RENDERER) + .expect("complete review"); + assert!(literal.contains("/documents/")); + assert!(literal.contains("format=text%2Fplain")); + assert!(literal.contains("separate-authorization-required")); + let binding: Value = + serde_json::from_slice(&effect.binding().to_private_bytes().expect("binding")) + .expect("JSON"); + assert_eq!(binding["protocol"]["kind"], "acquisition"); + assert_eq!( + binding["reservations"] + .as_array() + .expect("reservations") + .len(), + 2 + ); + let request = effect + .approval_request(NOW, NOW + 30) + .expect("approval request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approval = request.with_signature(signature); + let approved = effect + .approve(approval.clone(), &public, NOW) + .expect("exact approved read"); + approved + .validate_for_entry(&installed, NOW + 1) + .expect("fresh recompile"); + assert!(approved.validate_for_entry(&installed, NOW + 30).is_err()); + assert!( + approved.recovery_plan().is_err(), + "content cannot borrow recovery admission" + ); + assert!( + approved.candidate_target().is_none(), + "content cannot borrow candidate admission" + ); + let next_call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse("content-2").expect("operation"), + ) + .expect("call"); + let next_submission = submission_for_call(&root, &reader, &grant, &next_call, &[]); + let next = compile_content_acquisition( + &installed, + &target, + NOW, + &next_submission.proof, + &next_submission.action, + ) + .expect("next native effect"); + let next_binding: Value = + serde_json::from_slice(&next.binding().to_private_bytes().expect("binding")) + .expect("JSON"); + assert_eq!( + binding["reservations"], next_binding["reservations"], + "new logical operation cannot change source lifetime capacity" + ); + assert!( + next.approve(approval, &public, NOW).is_err(), + "old approval cannot authorize new operation" + ); + let touched = connection + .transition_state(ConnectionState::Disabled, NOW - 10) + .expect("disable") + .transition_state(ConnectionState::Active, NOW - 5) + .expect("enable"); + let touched_target = + ContentReadTarget::new(&recipe, &touched, arguments.clone()).expect("touched target"); + let touched_call = touched_target + .authorization_call( + &recipe, + &LogicalOperationId::parse("content-after-admin").expect("operation"), + ) + .expect("call"); + let touched_submission = submission_for_call(&root, &reader, &grant, &touched_call, &[]); + let touched_installation = policy.installation( + &recipe, + &read_context, + &touched, + crate::QualificationPolicy::Optional, + [12; 32], + ); + assert!( + approved + .validate_for_entry(&touched_installation, NOW + 1) + .is_err(), + "changed installation cannot use old bound approval" + ); + let touched_effect = compile_content_acquisition( + &touched_installation, + &touched_target, + NOW, + &touched_submission.proof, + &touched_submission.action, + ) + .expect("fresh native target"); + let touched_binding: Value = serde_json::from_slice( + &touched_effect + .binding() + .to_private_bytes() + .expect("binding"), + ) + .expect("JSON"); + assert_eq!( + binding["reservations"], touched_binding["reservations"], + "administrative state/time changes cannot reset source allowance" + ); + assert_ne!( + binding["connection"], touched_binding["connection"], + "binding still pins full live connection" + ); + let mut different_resource = arguments.clone(); + different_resource.insert("record_id".to_owned(), json!("recDIFFERENT000001")); + let different_target = ContentReadTarget::new(&recipe, &connection, different_resource) + .expect("different resource"); + assert!( + compile_content_acquisition( + &installed, + &different_target, + NOW, + &submission.proof, + &submission.action + ) + .is_err() + ); + let mut wrong_args = call.arguments().clone(); + wrong_args.insert("maximum_response_bytes".to_owned(), json!(1025)); + let wrong_call = + McpToolCall::new(call.service(), CONTENT_READ_TOOL, wrong_args).expect("call"); + let changed = submission_for_call(&root, &reader, &grant, &wrong_call, &[]); + assert!( + compile_content_acquisition(&installed, &target, NOW, &changed.proof, &changed.action) + .is_err() + ); + let mut extra = arguments.clone(); + extra.insert("url".to_owned(), json!("https://untrusted.invalid/")); + assert!(recipe.content_read(&extra).is_err()); + assert!(recipe.content_read(&Map::new()).is_err()); + assert!( + compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) + .is_err() + ); + projection_cases.push(projections( + &recipe, + &arguments, + projection["kind"] == "json-string", + )); + cases.push(json!({"projection": projection, "binding": binding, "native_call": call.arguments(), + "review": serde_json::from_slice::(&review.to_private_bytes().expect("private review")).expect("JSON"), + "fresh_recompile_passed": true, "expired_approval_refused": true, + "new_operation_preserves_capacity": true, "administrative_metadata_preserves_capacity": true, + "changed_installation_and_resource_refused": true, "old_approval_new_operation_refused": true, + "changed_limit_extra_arguments_mutation_refused": true})); + } + let (source, lock) = h::recipe_sources(&json!({}), &Value::Null).expect("source/lock"); + let mut source: Value = serde_json::from_slice(&source).expect("source"); + let mut lock: Value = serde_json::from_slice(&lock).expect("lock"); + source["tool"] = json!(CONTENT_READ_TOOL); + lock["tool"] = json!(CONTENT_READ_TOOL); + assert!( + CompiledRecipe::compile( + &serde_json::to_vec(&source).expect("source"), + &serde_json::to_vec(&lock).expect("lock") + ) + .is_err() + ); + let no_content = recipe(&json!({}), &Value::Null); + assert!(no_content.content_read(&arguments).is_err()); + let fixture = json!({"schema": "auths.gateway-content-compilation-fixture/1", + "scope": "native compilation and pure bounded projection; no acquisition entry, custody or disclosure", + "cases": cases, "projections": projection_cases, "invalid_declarations": invalid_declarations(), + "undeclared_content_read_refused": true}); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/content-compilation.json"); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(&path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 5ea21527a..9c1c9aad5 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -12,6 +12,9 @@ use ed25519_dalek::{Signer as _, SigningKey}; #[path = "effect_candidate_tests.rs"] mod candidate_tests; +#[path = "effect_content_tests.rs"] +mod content_tests; + #[path = "effect_prerequisite_tests.rs"] mod prerequisite_tests; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 6ecc90ecd..bd762ccf2 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,12 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.content.response-status ContentProjectionError projection new 74 -", + "gateway.content.response-media-type ContentProjectionError projection new 74 -", + "gateway.content.response-too-large ContentProjectionError projection new 74 -", + "gateway.content.invalid-response ContentProjectionError projection new 74 -", + "gateway.content.missing-projection ContentProjectionError projection new 74 -", + "gateway.content.content-too-large ContentProjectionError projection new 74 -", "gateway.recovery.binding effect recovery new 74 -", "gateway.recovery.unavailable effect recovery new 74 -", "gateway.acquisition.binding effect compile new 74 -", diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 225ac1162..546b772e1 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -20,6 +20,8 @@ use url::{Host, Url}; pub use auths_gateway_kernel::{construct, recovery}; +mod content; +pub use content::{CONTENT_READ_SCHEMA, ClosedContentRead, ContentProjectionError}; mod effect_review; mod lower; mod response; @@ -539,7 +541,9 @@ impl CompiledRecipe { if source.schema != RECIPE_SOURCE_SCHEMA || matches!( source.tool.as_str(), - crate::effect::RECOVERY_READ_TOOL | crate::effect::CANDIDATE_CHECK_TOOL + crate::effect::RECOVERY_READ_TOOL + | crate::effect::CANDIDATE_CHECK_TOOL + | crate::effect::CONTENT_READ_TOOL ) { return Err(GatewayRecipeError::InvalidSource); @@ -558,6 +562,9 @@ impl CompiledRecipe { credential_requirement(&source.credential).validate()?; validate_origin(&source.origin)?; validate::validate_source(&source, &fields)?; + if let Some(content) = &source.content { + content.validate(&fields)?; + } let canonical = serde_json_canonicalizer::to_vec(&source) .map_err(|_| GatewayRecipeError::InvalidSource)?; let mut hasher = Sha256::new(); diff --git a/product/runtime/auths-gateway/src/recipe/content.rs b/product/runtime/auths-gateway/src/recipe/content.rs new file mode 100644 index 000000000..fea7952cb --- /dev/null +++ b/product/runtime/auths-gateway/src/recipe/content.rs @@ -0,0 +1,328 @@ +//! Recipe-declared content acquisition. Request construction reuses the closed +//! path/header leaf; response projection is bounded and never releases bytes. + +use super::*; +use std::collections::BTreeSet; +use zeroize::Zeroizing; + +/// Versioned opt-in capability inside the digest-bound recipe source. +pub const CONTENT_READ_SCHEMA: &str = "auths.gateway-content-read/1"; + +/// Why retained provider evidence cannot produce the declared private content. +/// These are response facts, never native authorization denials. +#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)] +pub enum ContentProjectionError { + /// The response status differs from the declared successful status. + #[error("provider response status does not permit content projection")] + Status, + /// Response media type or charset differs from the declared representation. + #[error("provider response media type does not permit content projection")] + MediaType, + /// Raw response exceeds its independently charged bound. + #[error("provider response exceeds the declared byte limit")] + ResponseLimit, + /// Invalid UTF-8, malformed or duplicate-member JSON. + #[error("provider content is malformed")] + Malformed, + /// The declared JSON pointer is absent or does not select a string. + #[error("provider response lacks the declared string projection")] + Projection, + /// The exact projected content exceeds the limit; it is never truncated. + #[error("projected content exceeds the declared byte limit")] + ContentLimit, +} + +impl ContentProjectionError { + /// Stable redacted failure code, independent of provider content. + #[must_use] + pub const fn code(self) -> &'static str { + match self { + Self::Status => "gateway.content.response-status", + Self::MediaType => "gateway.content.response-media-type", + Self::ResponseLimit => "gateway.content.response-too-large", + Self::Malformed => "gateway.content.invalid-response", + Self::Projection => "gateway.content.missing-projection", + Self::ContentLimit => "gateway.content.content-too-large", + } + } +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct ContentSource { + schema: String, + resource_field: String, + path: Vec, + query: Vec, + projection: ContentProjection, + maximum_response_bytes: u64, + maximum_content_bytes: u64, +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct QueryPair { + name: String, + value: String, +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +enum ContentProjection { + Utf8, + JsonString { pointer: String }, +} + +impl ContentSource { + pub(super) fn validate( + &self, + fields: &BTreeMap, + ) -> Result<(), GatewayRecipeError> { + if self.schema != CONTENT_READ_SCHEMA + || matches!( + self.resource_field.as_str(), + "operation_id" | "operator_namespace" | "recipe_digest" + ) + || !fields + .get(&self.resource_field) + .is_some_and(FieldSchema::is_path_scalar) + || !(1..=65_536).contains(&self.maximum_response_bytes) + || !(1..=self.maximum_response_bytes).contains(&self.maximum_content_bytes) + || self.query.len() > 8 + || !self.path.iter().any( + |part| matches!(part, PathSegment::Field { name } if name == &self.resource_field), + ) + || self.path.iter().any(|part| match part { + PathSegment::Fixed { .. } => false, + PathSegment::Field { name } => name != &self.resource_field, + PathSegment::Echo | PathSegment::ResponseField { .. } => true, + }) + { + return Err(GatewayRecipeError::InvalidSource); + } + super::validate::validate_content_path(&self.path, fields)?; + let mut previous = None; + for query in &self.query { + if query.name.is_empty() + || query.name.len() > 64 + || !query + .name + .bytes() + .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-')) + || query.value.len() > 512 + || query.value.chars().any(char::is_control) + || previous.is_some_and(|name: &str| name >= query.name.as_str()) + { + return Err(GatewayRecipeError::InvalidSource); + } + previous = Some(query.name.as_str()); + } + if let ContentProjection::JsonString { pointer } = &self.projection { + if !super::validate::valid_response_pointer(pointer) || !valid_escapes(pointer) { + return Err(GatewayRecipeError::InvalidSource); + } + } + Ok(()) + } +} + +fn valid_escapes(pointer: &str) -> bool { + let mut bytes = pointer.bytes(); + while let Some(byte) = bytes.next() { + if byte == b'~' && !matches!(bytes.next(), Some(b'0' | b'1')) { + return false; + } + } + true +} + +/// Compiler-owned GET and projection. It is data, never an acquisition or +/// disclosure permit, and has no deserializer. Content cannot be derived from +/// credential probes or recovery reads by selecting this type at runtime. +#[derive(Clone)] +pub struct ClosedContentRead { + read: ClosedActionRead, + projection: ContentProjection, + maximum_content_bytes: usize, + arguments: Map, +} + +impl std::fmt::Debug for ClosedContentRead { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("ClosedContentRead { private: [redacted] }") + } +} + +impl ClosedContentRead { + pub(crate) const fn transport(&self) -> &ClosedActionRead { + &self.read + } + + pub(crate) fn private_request(&self) -> Value { + serde_json::json!({ + "method": "GET", "url": self.read.url(), + "headers": self.read.headers().iter().map(|h| (h.name(), h.value())).collect::>(), + "maximum_response_bytes": self.read.maximum_response_bytes(), + }) + } + /// Complete private request and interpretation contract for native review + /// and effect identity. It contains no provider response or credential. + #[must_use] + pub fn private_contract(&self) -> Value { + serde_json::json!({ + "schema": CONTENT_READ_SCHEMA, + "request": self.private_request(), + "resource_arguments": self.arguments, + "projection": self.projection, + "maximum_content_bytes": self.maximum_content_bytes, + "required_status": 200, + "required_media_type": self.media_type(), + "maximum_transport_seconds": 15, + "disclosure": "separate-authorization-required", + }) + } + + /// The exact expected response media type. Only an optional UTF-8 charset + /// is accepted by projection; compressed bodies are a transport refusal. + #[must_use] + pub const fn media_type(&self) -> &'static str { + match self.projection { + ContentProjection::Utf8 => "text/plain", + ContentProjection::JsonString { .. } => "application/json", + } + } + + /// Projects an acquired response into a private, zeroizing buffer. This + /// function does no I/O and authorizes no disclosure. The caller must supply + /// authenticated transport facts from the corresponding durable acquisition. + /// No truncation, lossy UTF-8 conversion or last-key-wins JSON is permitted. + /// + /// # Errors + /// Refuses status/media mismatch, oversized content, invalid UTF-8, duplicate + /// JSON, missing/non-string projections or malformed provider responses. + pub fn project_response( + &self, + status: u16, + media_type: &str, + body: &[u8], + ) -> Result>, ContentProjectionError> { + if status != 200 { + return Err(ContentProjectionError::Status); + } + if body.len() > self.read.maximum_response_bytes() { + return Err(ContentProjectionError::ResponseLimit); + } + if media_type.len() > 128 || !self.accepts_media_type(media_type) { + return Err(ContentProjectionError::MediaType); + } + let content = match &self.projection { + ContentProjection::Utf8 => { + std::str::from_utf8(body).map_err(|_| ContentProjectionError::Malformed)?; + Zeroizing::new(body.to_vec()) + } + ContentProjection::JsonString { pointer } => { + let document = + parse_provider_response(body).ok_or(ContentProjectionError::Malformed)?; + let value = document + .pointer(pointer) + .and_then(Value::as_str) + .ok_or(ContentProjectionError::Projection)?; + Zeroizing::new(value.as_bytes().to_vec()) + } + }; + if content.len() > self.maximum_content_bytes { + return Err(ContentProjectionError::ContentLimit); + } + Ok(content) + } + + fn accepts_media_type(&self, value: &str) -> bool { + let mut parts = value.split(';'); + let matches = parts + .next() + .is_some_and(|base| base.trim().eq_ignore_ascii_case(self.media_type())); + matches + && match (parts.next(), parts.next()) { + (None, None) => true, + (Some(parameter), None) => parameter.trim().eq_ignore_ascii_case("charset=utf-8"), + _ => false, + } + } +} + +impl CompiledRecipe { + /// Compiles the recipe's explicit content capability for an exact resource + /// and optional account scope. The argument set is closed: unused fields, + /// operation IDs, caller URLs and implicit recovery targets are refused. + /// This authoring data must later be bound to native read authority and exact + /// approval; constructing it grants neither custody nor external entry. + /// + /// # Errors + /// Refuses an absent declaration, missing/extra/invalid arguments, unsafe + /// path values or a request exceeding the existing 8,192-byte URL bound. + pub fn content_read( + &self, + arguments: &Map, + ) -> Result { + let source = self + .source + .content + .as_ref() + .ok_or(GatewayRecipeError::InvalidSource)?; + let mut names = BTreeSet::from([source.resource_field.as_str()]); + if let Some(scope) = &self.source.account_scope { + names.insert(scope.field.as_str()); + } + if arguments.len() != names.len() + || arguments.keys().any(|name| !names.contains(name.as_str())) + { + return Err(GatewayRecipeError::ActionMismatch); + } + for (name, value) in arguments { + if !self + .fields + .get(name) + .is_some_and(|schema| schema.validate_value(value)) + { + return Err(GatewayRecipeError::ActionMismatch); + } + } + // Unused profile slots are deliberately non-path values. The closed + // plan may consume only the exact resource and declared account scope. + let values = self + .fields + .iter() + .map(|(name, schema)| { + arguments + .get(name) + .and_then(|value| schema.argument_value(value)) + .unwrap_or(ArgumentValue::Boolean(false)) + }) + .collect::>(); + let plan = super::lower::content_plan(&self.source, &self.fields, &source.path)?; + let mut read = ClosedActionRead::construct( + &plan, + &values, + bounded_usize(source.maximum_response_bytes), + )?; + if !source.query.is_empty() { + let mut url = read.url.into_bytes(); + for (index, pair) in source.query.iter().enumerate() { + url.push(if index == 0 { b'?' } else { b'&' }); + url = construct::append_path_encoded(url, pair.name.as_bytes()); + url.push(b'='); + url = construct::append_path_encoded(url, pair.value.as_bytes()); + } + if url.len() > construct::MAX_PATH_BYTES { + return Err(GatewayRecipeError::UnsafePath); + } + read.url = ascii(url)?; + } + Ok(ClosedContentRead { + read, + projection: source.projection.clone(), + maximum_content_bytes: bounded_usize(source.maximum_content_bytes), + arguments: arguments.clone(), + }) + } +} diff --git a/product/runtime/auths-gateway/src/recipe/lower.rs b/product/runtime/auths-gateway/src/recipe/lower.rs index d90713cdf..b16d99bec 100644 --- a/product/runtime/auths-gateway/src/recipe/lower.rs +++ b/product/runtime/auths-gateway/src/recipe/lower.rs @@ -417,3 +417,17 @@ pub(super) fn plans( denied, }) } + +/// Reuses the reviewed action-read lowering for an explicit content capability. +pub(super) fn content_plan( + source: &RecipeSource, + fields: &BTreeMap, + path: &[PathSegment], +) -> Result { + Lowering { + fields, + origin: source.origin.as_bytes().to_vec(), + headers: header_plan(source, fields)?, + } + .action_read(path) +} diff --git a/product/runtime/auths-gateway/src/recipe/review.rs b/product/runtime/auths-gateway/src/recipe/review.rs index 66c27e92a..81969df1c 100644 --- a/product/runtime/auths-gateway/src/recipe/review.rs +++ b/product/runtime/auths-gateway/src/recipe/review.rs @@ -332,6 +332,13 @@ impl CompiledRecipe { ) }); document["credential_guard"] = self.guard_review(); + if let Some(content) = &source.content { + document["content_acquisition"] = json!({ + "declaration": content, + "method": "GET", + "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry", + }); + } document["idempotency"] = source .write diff --git a/product/runtime/auths-gateway/src/recipe/source.rs b/product/runtime/auths-gateway/src/recipe/source.rs index c1789f725..c341df0dc 100644 --- a/product/runtime/auths-gateway/src/recipe/source.rs +++ b/product/runtime/auths-gateway/src/recipe/source.rs @@ -31,6 +31,8 @@ pub(super) struct RecipeSource { pub(super) relative_ceiling: Option, pub(super) write: WriteSource, #[serde(default, skip_serializing_if = "Option::is_none")] + pub(super) content: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) observation: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) echo: Option, diff --git a/product/runtime/auths-gateway/src/recipe/validate.rs b/product/runtime/auths-gateway/src/recipe/validate.rs index a28d09b77..11927cdac 100644 --- a/product/runtime/auths-gateway/src/recipe/validate.rs +++ b/product/runtime/auths-gateway/src/recipe/validate.rs @@ -804,3 +804,16 @@ pub(super) fn validate_source( } Ok(()) } + +/// Content GETs use the existing fixed/verified-field path grammar. No +/// response locator or echo can select their resource. +pub(super) fn validate_content_path( + path: &[PathSegment], + fields: &BTreeMap, +) -> Result<(), GatewayRecipeError> { + Rules { + fields, + consumed: Consumption::default(), + } + .path(path, PathRole::Write) +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 883a39662..65124dc31 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "8ea6b17065e33fe92d53a969668d7967e79d9547630e1092306e6d47293d6aa4"; + "50bad92473dab4b4643e6078ac9227db1d555e58861a07b41e16bf89d0500a35"; #[cfg(test)] mod tests { From 71fd4f7f0388bb34b399f1891a6768d04758dee1 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 13:05:37 +0000 Subject: [PATCH 048/136] feat(gateway): journal approved content acquisitions through sealed transport --- .../fixtures/gateway/content-journal.json | 308 ++++++++++++++ compliance.toml | 6 +- ...017-bound-effect-and-recovery-ownership.md | 33 +- docs/plans/0074-implementation-status.md | 44 +- .../0009-bound-effect-and-recovery.md | 23 ++ ...ound-effects-and-recovery-state-machine.md | 26 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/candidate_runtime.rs | 4 +- product/runtime/auths-gateway/src/effect.rs | 16 + .../auths-gateway/src/effect/acquisition.rs | 6 +- .../auths-gateway/src/effect/content.rs | 210 +++++++++- .../auths-gateway/src/effect_content_tests.rs | 386 +++++++++++++++++- product/runtime/auths-gateway/src/engine.rs | 106 ++++- .../auths-gateway/src/recipe/content.rs | 3 +- .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/src/store/acquisition.rs | 157 ++++++- product/runtime/auths-gateway/src/submit.rs | 34 ++ .../runtime/auths-gateway/src/transport.rs | 142 ++++++- 18 files changed, 1431 insertions(+), 77 deletions(-) create mode 100644 bindings/fixtures/gateway/content-journal.json diff --git a/bindings/fixtures/gateway/content-journal.json b/bindings/fixtures/gateway/content-journal.json new file mode 100644 index 000000000..a5fcbfc44 --- /dev/null +++ b/bindings/fixtures/gateway/content-journal.json @@ -0,0 +1,308 @@ +{ + "schema": "auths.gateway-content-journal-fixture/1", + "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", + "permanent_source_attempts": 16, + "history": [ + { + "case": 0, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } + } + }, + { + "case": 1, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "single", + "value": "gzip" + } + } + }, + { + "case": 2, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "invalid" + }, + "encoding": { + "kind": "missing" + } + } + }, + { + "case": 3, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "missing" + }, + "encoding": { + "kind": "missing" + } + } + }, + { + "case": 4, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "invalid" + } + } + }, + { + "case": 5, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "application/json" + }, + "encoding": { + "kind": "missing" + } + } + }, + { + "case": 6, + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "private_response_metadata": null + }, + { + "case": 7, + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 403, + "response_bytes": 25, + "response_version_ok": true + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "lost-permit", + "snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + }, + { + "case": "source-exhausted", + "snapshot": { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 0abf4c488..76e9e0380 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1612,9 +1612,13 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +content-journal-transport = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", +] + content-compilation-contract = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_compilation_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 2050e8974..93ae6bdd4 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -826,6 +826,33 @@ allowance. Fixed-window native managed bounds are additionally retained. Content projection returns private bytes and typed response errors, not a receipt or release grant. Runtime must authenticate/retain HTTP metadata and content under the journal contract and issue a distinct disclosure capability. -The current compiler slice does not add content admission/entry, read-only -installation, AP070 metadata predicates, recipient transport or content custody. -These remain required before migrating the maintained demo. +The initial compiler slice supplied no admission/entry; the following section +records that integration. Read-only installation, AP070 metadata predicates, +recipient transport and protected projected-content custody remain required +before migrating the maintained demo. + + +## Content acquisition journal and transport + +The content plan is a concrete variant of the existing acquisition journal. +Its current source is the exact connection row, checked under the same fence as +native authority, configuration, qualification, all source/policy allocations +and credential prerequisites. The plan validates its reconstruction data against +the full signed request/projection commitments; decoding it grants no authority. +The engine uses the common acquisition driver. A content permit can enter only +the metadata-preserving content GET path and is consumed once. + +Content responses have a distinct private journal variant mapped to the existing +kernel acquisition response stage. They retain bounded raw bytes and typed +media/encoding facts, without upgrading them to usable content or a disclosure. +Missing, duplicate, oversized and non-text header values cannot become a valid +single header. Transport requests identity encoding and explicitly disables +automatic decompression. Query support is confined to the compiler-owned content +request; other transports retain their previous URL restriction. No new retry, +transition owner, decoder compatibility path or generic request callback is added. + +The `content-journal.json` corpus exercises installed native entry against the +file adapter, actual loopback HTTP, durable source exhaustion and reopened +journal replay. Protected projected-content construction, separate disclosure, +full engine/CLI process journeys, PostgreSQL faults and AP070 differential +cutover remain required; this evidence grants no provider qualification. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d7a1b14d4..d8b336809 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1122,6 +1122,48 @@ closure regeneration passed after that correction (one artifact-generation test) this opt-in content capability is not a claim that standalone read-only installation or the Google domain cutover is complete. A01–A22 remain open. +## Content acquisition journal and transport checkpoint + +- Content now has a typed plan in the existing acquisition owner. It binds the + exact current connection, resource capacity, request/projection and credential + prerequisites. Admission and final grant share the existing native fence and + permanent count/byte allocations. Content cannot borrow candidate/recovery + admission or ordinary response evidence. Current connection changes refuse. +- Added engine compilation/acquisition APIs using the existing preparation, + custody and acquisition sequence. Terminal replay precedes transport/custody + preparation. Public results remain acquisition facts without raw bytes, + content commitments or a disclosure permit. +- The sealed content permit sends the compiler-owned GET and fixed query over + the pinned transport. It requests identity encoding and disables automatic + decompression; other request paths retain their query prohibition. A distinct + response phase privately retains bounded raw bytes, status, version agreement, + receipt time and missing/single/invalid media/encoding facts (128 bytes each). + It maps to the existing kernel response stage, not a new reducer. Oversized + responses and lost permits retain unknown and full charges. Partial read + accumulation is zeroized on error. +- Exact artifact construction passed on `eafd6a2b` plus this source: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --lib -- --exact observed_tests::effect_native_tests::content_tests::native_content_journal_fixture_is_current observed_tests::effect_native_tests::content_tests::native_content_compilation_fixture_is_current`. + The final two-test run passed in 2.04 seconds. The new fixture uses installed + native entry validation, the file adapter and eight real loopback HTTP calls, + checks 16 permanent allocations and seventeenth refusal, one-use grants, + reopened replay/unchanged bytes, exact queries and request headers, retained + response metadata, record downgrade rejection and public sentinel privacy. + Source/connection equality is checked separately. An initial compile failure + used a nonexistent policy key method; the test now uses the existing native + `GatewayAttemptKey::for_operation`. No production check was weakened. +- This is not a full engine/CLI process journey, PostgreSQL/fault evidence, + content projection provenance, protected content commitment or disclosure. + Protected projected-content construction must consume the recorded metadata + and reject bad encoding/media/version/projection without refetch. Read-only + installation, AP070 metadata and Python-owner removal, maintained consumers, + authenticated UI/bindings and P4 evidence remain. No A01–A22 case closes. +- After the bounded-buffer zeroization change, final generation of + `native_content_journal_fixture_is_current` and + `semantic_closure::tests::semantic_closure_is_current` passed together (two + exact tests, 2.15 seconds). No broad local gate or hosted CI has been run or + observed. Bounded decoded response buffers and partial transport accumulation + are zeroized on drop. Fetch found no new upstream commits. + ## Phase gates | Phase | State | Outstanding gate | @@ -1129,7 +1171,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery/prerequisite runtime and content/ACK compilation wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Recovery/prerequisite/content acquisition runtime and ACK compilation wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 9a716ef78..9af27c06a 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -558,3 +558,26 @@ bytes without truncation into a zeroizing buffer and gives no disclosure permit. This evidence does not establish durable source allocations, actual provider transport, content custody, standalone read-only deployment, AP070 differential parity or a recipient release. Those remain part of P3/P4. + + +## Content acquisition durable comparison + +The shared mechanism is the existing acquisition admission/entry/replay order, +with the connection row as source and the compiler's resource capacity keys. +Content keeps a distinct response carrier: status, version agreement, raw bytes, +receipt time and bounded media/encoding facts. Credential-purpose evaluation and +mutation observation cannot consume this carrier. It establishes neither an +AP070 metadata predicate nor recipient delivery. Fixed reviewed query parameters +are sent only through a sealed content permit, using the same pinned-origin, +no-proxy/no-redirect transport policy and explicit identity encoding. + +`content-journal.json` is constructed by native signed authority/approval, +installed entry validation and the file adapter, with eight real local HTTP +requests. It checks exact query/Accept/encoding headers, raw-body bounds, +duplicate/missing/encoded/wrong-media response metadata, retained HTTP denial, +one-use grants, reopen replay without record changes, permanent charges after +lost permits and refusal of attempt seventeen. A typed-record downgrade is +rejected. Synthetic credential/provider data stays private; the artifact contains +only public snapshots and synthetic response header facts. This is not an +independent-process, PostgreSQL, full engine, protected-content/disclosure, +AP070 equivalence or isolation claim. These evidence gates remain open. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index b5a51948c..a3bbb5d27 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -399,10 +399,28 @@ responses/content instead of truncating. It returns private zeroizing bytes; projection alone establishes no transport provenance, custody or release permission. Stable native response errors distinguish status, media type, raw response limit, malformed input, missing projection and projected-content limit. -The runtime must retain authentic response metadata with the acquired bytes -before using this contract for disclosure. Standalone read-only installation, -AP070 metadata checks, content journal/transport and protected retention remain -implementation requirements; this compiler contract alone is not their cutover. +Content acquisition now uses the shared journal admission, permanent source +allocations, prerequisite sequence and final native entry fence. The sealed +content permit selects a separate metadata-preserving HTTPS response path. Only +that compiler-owned GET may carry the reviewed fixed query; mutation, credential +and recovery transports continue to reject query overrides. The client requests +identity encoding, disables automatic decompression and retains bounded raw +bytes with status, required-version agreement, receipt time and typed media-type/ +encoding facts. Each header is missing, one value of at most 128 bytes, or invalid +(including duplicate/oversized/non-text values). These facts cannot be stripped +by decoding a content record as ordinary prerequisite/recovery evidence. + +The typed `content-response-recorded` phase projects to the existing acquisition +response stage under the sole reducer. Neither this stage nor HTTP success proves +that a body is usable content. Later protected-content construction must reject +bad encoding/media/version/projection using retained metadata; it cannot refetch. +Restart and post-grant replay return recorded facts without a credential lease +or new provider permit. Unknown/oversized responses retain their full charges. + +The content engine API returns redacted acquisition facts only. Standalone +read-only installation, AP070 metadata predicates, protected projected-content +commitments/retention, disclosure entry/transport and installed CLI/binding +journeys remain required before the complete consumer cutover. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 7211b77fd..496fcc0ec 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"0b7267a23b56c8ff06bcc437f6d1dd967aef7355b0f82ff223995f56280bf13a"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"73516b80c3795e30565af62019cc4594f9ed764bf6886ec29e53708149864368"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"c019df98215bdc04c03b512c002282f29a1f8ff24fa389584e27b12a81e95d90"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"0a36f2fde1ec10ec8cfe0d04dda7956872a2636490d40a73e733367593159659"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"875939158f5930ac2547bbdf837721b847691b21e792522bc9101f87bf73c3f1"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"855c29e31d38083bdc9113a0819acc6173b91dcd83248e5e87121990203ec3ed"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4aa0673b5c2583d01500e7017f05c63337ab5b43ca7e2ab7d9ccc445c532cce5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fb7c0e6f7ad4304b9d5066fbee2cfa9a1fcee554a0c5a6d470d2d8c9e8f5f4bf"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"b5886a5dff98d7b3483411e4a7b5439f1982a7a17a70a0314b68dd9bfea2f782"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"d4aa4c93a044c407524579536fecd5101497be84fa0cfff2c09e5c66af6157e0"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"cc4ee6e18545c4819551e2c2b3b189f84f2c02a7885292929f4b2b9cd9b32189"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"364f9551014386f8a2fe4ee95c979b284e1a5bae5482da461603002f05ce5a8a"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2cd71cd41dae16846f0105d43e1f607d512fb596518119b9db3d98d6b8d0416c"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"92f320a018cd29d994d5c692718aec4933ffa5043d5987102c85c30e276f300d"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"47ef6078825920004c3896f578af008f10fcb78d1cf2c653e54e6a4b57dba3eb"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4aa0673b5c2583d01500e7017f05c63337ab5b43ca7e2ab7d9ccc445c532cce5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fb7c0e6f7ad4304b9d5066fbee2cfa9a1fcee554a0c5a6d470d2d8c9e8f5f4bf"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"60dfc187a1339ae93f527034e89c19d018b8a91d5e70e666e5d14064162eb8c8"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"7096dbb40fffc85cd60b5959529a32c6127f5d0218bca053d903ea2e6713cd8a"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"33dd10d7139a231632424e747117e99c719434d04fc65dc4c411f3c59d26f4a9"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index 606e370ff..76f218406 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -426,7 +426,7 @@ impl GatewayEngine { Err(crate::GatewayAttemptError::BindingConflict) => { return Err(not_entered("gateway.effect.operation-conflict")); } - Err(_) => return self.recovery_projection(&approved).await, + Err(_) => return self.acquisition_projection(&approved).await, }; let result = async { let _flight = submit::InFlight::enter(&io); @@ -461,7 +461,7 @@ impl GatewayEngine { .await; match result { Ok(snapshot) => Ok(snapshot), - Err(_) => self.recovery_projection(&approved).await, + Err(_) => self.acquisition_projection(&approved).await, } } } diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index dcaac041f..83120de5d 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -1100,6 +1100,22 @@ impl ApprovedEffect { } } + pub(crate) fn content_target(&self) -> Option<&ContentReadTarget> { + match &self.effect.command { + CompiledEffect::Acquisition(command) => match &command.target { + acquisition::AcquisitionTarget::Content(target) => Some(target), + _ => None, + }, + CompiledEffect::Mutation(_) => None, + } + } + + pub(crate) fn content_plan(&self) -> Result { + self.content_target() + .ok_or(EffectBindingError::Invalid)? + .journal_plan(self.prerequisites()) + } + pub(crate) fn candidate_target(&self) -> Option<&CandidateCredentialTarget> { match &self.effect.command { CompiledEffect::Acquisition(command) => match &command.target { diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 02fc36ed4..c860fb272 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -264,6 +264,7 @@ pub(crate) struct RecoveryPlan { pub(crate) enum AcquisitionPlan { Recovery(RecoveryPlan), Candidate(super::candidate::CandidatePlan), + Content(super::content::ContentPlan), Prerequisite(PrerequisitePlan), } @@ -271,6 +272,7 @@ impl AcquisitionPlan { pub(crate) fn source_id(&self) -> Result<[u8; 32], EffectBindingError> { match self { Self::Candidate(plan) => plan.source_id(), + Self::Content(plan) => plan.source_id(), _ => Ok(*self.source()?.id().as_bytes()), } } @@ -278,7 +280,7 @@ impl AcquisitionPlan { pub(crate) fn source(&self) -> Result { match self { Self::Recovery(plan) => plan.source(), - Self::Candidate(_) => Err(EffectBindingError::Invalid), + Self::Candidate(_) | Self::Content(_) => Err(EffectBindingError::Invalid), Self::Prerequisite(plan) => plan.source(), } } @@ -286,6 +288,7 @@ impl AcquisitionPlan { match self { Self::Recovery(plan) => plan.capacity(), Self::Candidate(plan) => plan.capacity(), + Self::Content(plan) => plan.capacity(), Self::Prerequisite(plan) => plan.capacity(), } } @@ -296,6 +299,7 @@ impl AcquisitionPlan { match self { Self::Recovery(plan) => plan.validate(binding), Self::Candidate(plan) => plan.validate(binding), + Self::Content(plan) => plan.validate(binding), Self::Prerequisite(plan) => plan.validate(binding), } } diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index 3b328d029..a4e58dec6 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -138,6 +138,29 @@ impl ContentReadTarget { .map_err(|_| EffectBindingError::Invalid) } + pub(crate) fn closed_read(&self) -> &ClosedContentRead { + &self.read + } + + pub(super) fn journal_plan( + &self, + prerequisites: &Prerequisites, + ) -> Result { + let encode = |bytes: Zeroizing>| { + String::from_utf8(bytes.to_vec()).map_err(|_| EffectBindingError::Invalid) + }; + Ok(ContentPlan { + recipe: self.recipe, + connection: hex::encode( + self.connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ), + transport: encode(self.request_bytes(prerequisites)?)?, + contract: encode(canonical(&self.contract()?)?)?, + }) + } + pub(super) fn binding( &self, installed: &EffectInstallation<'_>, @@ -155,28 +178,11 @@ impl ContentReadTarget { &canonical(&self.contract().map_err(|_| invalid())?).map_err(|_| invalid())?, ) .map_err(|_| invalid())?; - let maximum_bytes = self.read.transport().maximum_response_bytes() as u64; - // Administrative timestamps/state and logical operation IDs cannot - // reset this resource allowance. Native policy windows also apply. - let capacity_key = |unit| { - commitment( - "auths.content-acquisition-capacity/1", - &canonical(&( - self.recipe, - self.connection.connection_id().as_str(), - self.connection.credential_generation().get(), - self.connection.credential_reference_commitment(), - &self.arguments, - unit, - ))?, - ) - }; - let capacity = AcquisitionCapacity { - count_key: capacity_key(Unit::AcquisitionCount).map_err(|_| invalid())?, - bytes_key: capacity_key(Unit::ResponseBytes).map_err(|_| invalid())?, - maximum_bytes, - attempts: MAX_CONTENT_ATTEMPTS, - }; + let capacity = self + .journal_plan(prerequisites) + .and_then(|plan| plan.capacity()) + .map_err(|_| invalid())?; + let maximum_bytes = capacity.maximum_bytes; let mut reservations = capacity.reservations(); reservations.extend(managed_reservations( bound, @@ -226,3 +232,163 @@ pub fn compile_content_acquisition( action, ) } + +/// Immutable reconstruction data, never a transport capability. The signed +/// binding pins the complete contract and request; current connection bytes +/// must also match under the common admission and entry fence. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct ContentPlan { + recipe: [u8; 32], + connection: String, + transport: String, + contract: String, +} + +impl ContentPlan { + fn connection(&self) -> Result { + if self.connection.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let bytes = + Zeroizing::new(hex::decode(&self.connection).map_err(|_| EffectBindingError::Invalid)?); + if hex::encode(bytes.as_slice()) != self.connection { + return Err(EffectBindingError::Invalid); + } + ConnectionRecord::from_canonical_cbor(&bytes).map_err(|_| EffectBindingError::Invalid) + } + + pub(crate) fn source_key(&self) -> Result { + let connection = self.connection()?; + Ok(crate::connection_key( + connection.provider_kind(), + connection.alias(), + )) + } + + pub(crate) fn source_id(&self) -> Result<[u8; 32], EffectBindingError> { + commitment("auths.content-source/1", &self.capacity()?.count_key) + } + + pub(crate) fn source_matches( + &self, + bytes: Option<&[u8]>, + ) -> Result<(bool, u64), EffectBindingError> { + let connection = self.connection()?; + let expected = Zeroizing::new( + connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + Ok(( + bytes == Some(expected.as_slice()), + connection.updated_at_unix_seconds(), + )) + } + + fn witness(&self) -> Result { + if self.contract.len() > MAX_EFFECT_BYTES || self.transport.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let contract: Value = + serde_json::from_str(&self.contract).map_err(|_| EffectBindingError::Invalid)?; + let transport: Value = + serde_json::from_str(&self.transport).map_err(|_| EffectBindingError::Invalid)?; + let connection = self.connection()?; + let bytes = Zeroizing::new( + connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + if canonical(&contract)?.as_slice() != self.contract.as_bytes() + || canonical(&transport)?.as_slice() != self.transport.as_bytes() + || contract["schema"] != CONTRACT + || contract["recipe"] != hex::encode(self.recipe) + || contract["connection"] + != hex::encode(commitment("auths.effect-installation/1", &bytes)?) + || contract["maximum_attempts"] != MAX_CONTENT_ATTEMPTS + || contract["disclosure"] != "separate-authorization-required" + || contract["content"]["schema"] != crate::recipe::CONTENT_READ_SCHEMA + || transport["request"] != contract["content"]["request"] + || !contract["content"]["resource_arguments"].is_object() + { + return Err(EffectBindingError::Invalid); + } + Ok(contract) + } + + pub(crate) fn capacity(&self) -> Result { + let contract = self.witness()?; + let maximum_bytes = contract["content"]["request"]["maximum_response_bytes"] + .as_u64() + .filter(|value| (1..=65_536).contains(value)) + .ok_or(EffectBindingError::Invalid)?; + let connection = self.connection()?; + // Administrative state/timestamps and logical operations never reset + // the lifetime allowance for this credential and exact resource. + let key = |unit| { + commitment( + "auths.content-acquisition-capacity/1", + &canonical(&( + self.recipe, + connection.connection_id().as_str(), + connection.credential_generation().get(), + connection.credential_reference_commitment(), + &contract["content"]["resource_arguments"], + unit, + ))?, + ) + }; + Ok(AcquisitionCapacity { + count_key: key(Unit::AcquisitionCount)?, + bytes_key: key(Unit::ResponseBytes)?, + maximum_bytes, + attempts: MAX_CONTENT_ATTEMPTS, + }) + } + + pub(crate) fn validate( + &self, + binding: &EffectBinding, + ) -> Result { + let capacity = self.capacity()?; + let connection = self.connection()?; + let bytes = Zeroizing::new( + connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + if binding.wire.recipe != self.recipe + || binding.wire.connection != commitment("auths.effect-installation/1", &bytes)? + || binding.wire.credential_generation != connection.credential_generation().get() + || binding.wire.protocol + != (Protocol::Acquisition { + request: commitment( + "auths.effect-acquisition-request/2", + self.transport.as_bytes(), + )?, + projection: commitment(CONTRACT, self.contract.as_bytes())?, + maximum_response_bytes: capacity.maximum_bytes, + }) + || binding + .wire + .reservations + .iter() + .filter(|r| r.window == ReservationWindow::SourceLifetime) + .cloned() + .collect::>() + != capacity.reservations() + || binding.wire.reservations.iter().any(|r| { + matches!(r.window, ReservationWindow::Fixed { .. }) + && match r.unit { + Unit::AcquisitionCount => r.amount != 1, + Unit::ResponseBytes => r.amount != capacity.maximum_bytes, + _ => true, + } + }) + { + return Err(EffectBindingError::Invalid); + } + Ok(capacity) + } +} diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index 797d6a739..6d191e675 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -1,5 +1,5 @@ -//! Native recipe/content compilation corpus. No runtime acquisition, content -//! custody, release or provider transport is asserted by these fixtures. +//! Native content compilation and durable acquisition corpora. Transport +//! evidence is scoped to the journal fixture; neither corpus claims disclosure. use super::*; use crate::effect::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; @@ -443,3 +443,385 @@ fn native_content_compilation_fixture_is_current() { } assert_eq!(std::fs::read(&path).expect("fixture"), bytes); } + +#[tokio::test] +#[allow( + clippy::too_many_lines, + reason = "one installed native admission/entry and bounded HTTP evidence corpus" +)] +async fn native_content_journal_fixture_is_current() { + use auths_connections::{ConnectionCredentialStore as _, SecretBytes}; + use std::sync::Arc; + use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _}; + use tokio::net::TcpListener; + let root = signer(h::ROOT_SEED); + let reader = signer(0x33); + let observer = signer(h::OBSERVER_SEED); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = + EffectPolicy::new("synthetic-content-journal".to_owned(), 1, public).expect("policy"); + let recipe = content_recipe(declaration(json!({"kind": "utf8"}))).expect("recipe"); + let initial = connection(&recipe); + let credentials = auths_connections::InMemoryCredentialStore::new(1, 1024).expect("custody"); + let reference = credentials + .install( + initial.connection_id(), + initial.credential_generation(), + SecretBytes::new(b"SYNTHETIC-CONTENT-TEST-CREDENTIAL".to_vec()).expect("secret"), + ) + .await + .expect("install"); + let record = ConnectionRecord::new( + initial.provider_kind().clone(), + initial.alias().clone(), + initial.connection_id().clone(), + initial.contract().clone(), + initial.descriptor_schema().clone(), + initial.descriptor().to_vec(), + *initial.account_commitment(), + *reference.as_bytes(), + initial.generation(), + initial.state(), + initial.allowed_workloads().to_vec(), + initial.allowed_profiles().to_vec(), + initial.created_at_unix_seconds(), + initial.updated_at_unix_seconds(), + None, + ) + .expect("record"); + let args = json!({"record_id": RECORD}) + .as_object() + .expect("args") + .clone(); + let target = ContentReadTarget::new(&recipe, &record, args).expect("target"); + let call = target + .authorization_call( + &recipe, + &LogicalOperationId::parse("content-journal-0").expect("op"), + ) + .expect("call"); + let trust = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("trust"); + let grant = h::grant_for_tool( + &root, + &reader.principal, + None, + window(NOW - 3600, NOW + 3600), + &call, + ) + .expect("grant"); + let installed = policy.installation( + &recipe, + &trust, + &record, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let approve = |operation: &str| { + let call = target + .authorization_call(&recipe, &LogicalOperationId::parse(operation).expect("op")) + .expect("call"); + let signed = submission_for_call(&root, &reader, &grant, &call, &[]); + let effect = + compile_content_acquisition(&installed, &target, NOW, &signed.proof, &signed.action) + .expect("effect"); + let request = effect.approval_request(NOW, NOW + 60).expect("request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW) + .expect("approval"), + ) + }; + let directory = tempfile::tempdir().expect("directory"); + let path = std::fs::canonicalize(directory.path()) + .expect("path") + .join("journal"); + let store: Arc = + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("store")); + let attempts = + crate::GatewayAttempts::new(Arc::clone(&store), policy.clone()).expect("attempts"); + let shared = crate::SharedConnection::new( + Arc::clone(&store), + record.provider_kind().clone(), + record.alias().clone(), + ); + let clock = Arc::new(crate::FixedClock::at(NOW)); + let qualification = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::clone(&clock)), + auths_recipe_qualification::VerifierState::default(), + )); + let configuration = crate::configuration::SharedConfiguration::new( + Arc::clone(&store), + policy.configuration_key(recipe.namespace()).expect("key"), + installed.configuration, + ); + configuration + .initialize(&qualification) + .expect("configuration"); + let approved = approve("content-journal-0"); + assert!( + attempts + .claim_content( + &approved, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW } + ) + .await + .is_err(), + "missing connection" + ); + shared.insert(&record).await.expect("connection"); + let loaded = shared.load().await.expect("load").expect("connection"); + let validation = || { + crate::entry::EntryValidation::Installed(Box::new(crate::entry::InstalledEntry { + recipe: recipe.clone(), + trust: trust.clone(), + observer: None, + policy: policy.clone(), + configuration: configuration.clone(), + connection: crate::entry::EntryConnection::Installed(Box::new(loaded.clone())), + connection_key: crate::connection_key(record.provider_kind(), record.alias()), + qualification: Arc::clone(&qualification), + workload: record.allowed_workloads()[0].clone(), + profile: record.allowed_profiles()[0].clone(), + started: std::time::Instant::now(), + #[cfg(unix)] + commissioning: None, + })) + }; + assert!( + attempts + .claim_recovery(&approved, NOW, validation()) + .await + .is_err() + ); + assert!( + attempts + .claim_candidate(&approved, NOW, validation()) + .await + .is_err() + ); + let lease = credentials + .lease_secret( + &record.credential_binding(), + std::time::Instant::now() + std::time::Duration::from_secs(30), + ) + .await + .expect("lease"); + let mut histories = vec![]; + for index in 0..17 { + let approved = approve(&format!("content-journal-{index}")); + let claim = attempts + .claim_content(&approved, NOW, validation()) + .await + .expect("claim"); + if index == 16 { + let crate::AcquisitionClaim::Existing(snapshot) = claim else { + panic!("source allowance exceeded"); + }; + assert_eq!(snapshot.stage, crate::AcquisitionStage::NotEntered); + assert_eq!(snapshot.reserved_calls, 0); + histories.push(json!({"case": "source-exhausted", "snapshot": snapshot})); + continue; + } + let crate::AcquisitionClaim::Reserved(reserved) = claim else { + panic!("reservation"); + }; + let crate::AcquisitionClaim::Reserved(stale) = attempts + .claim_content(&approved, NOW, validation()) + .await + .expect("resume") + else { + panic!("resume reservation"); + }; + let (granted, permit) = reserved + .grant_entry(Arc::clone(&approved), validation(), NOW) + .await + .expect("native grant"); + assert!( + stale + .grant_entry(Arc::clone(&approved), validation(), NOW) + .await + .is_err(), + "one grant only" + ); + if index >= 8 { + drop(permit); + let snapshot = granted.record_unknown().await.expect("unknown"); + assert_eq!(snapshot.reserved_calls, 1); + assert_eq!(snapshot.reserved_bytes, 1024); + histories.push(json!({"case": "lost-permit", "snapshot": snapshot})); + continue; + } + let headers = match index { + 0 => "Content-Type: text/plain\r\n", + 1 => "Content-Type: text/plain\r\nContent-Encoding: gzip\r\n", + 2 => "Content-Type: text/plain\r\nContent-Type: application/json\r\n", + 3 => "", + 4 => { + "Content-Type: text/plain\r\nContent-Encoding: identity\r\nContent-Encoding: gzip\r\n" + } + 5 => "Content-Type: application/json\r\n", + 6 | 7 => "Content-Type: text/plain\r\n", + _ => unreachable!(), + }; + let body = if index == 6 { + vec![b'x'; 1025] + } else { + b"PRIVATE-SYNTHETIC-CONTENT".to_vec() + }; + let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); + let port = listener.local_addr().expect("port").port(); + let server = tokio::spawn(async move { + let (mut stream, _) = listener.accept().await.expect("accept"); + let mut head = vec![]; + while !head.ends_with(b"\r\n\r\n") { + let mut byte = [0]; + stream.read_exact(&mut byte).await.expect("request"); + head.push(byte[0]); + assert!(head.len() < 8192); + } + let head = String::from_utf8(head).expect("head"); + assert!(head.starts_with(&format!( + "GET /documents/{RECORD}?format=text%2Fplain HTTP/1.1\r\n" + ))); + assert!(head.to_ascii_lowercase().contains("accept: text/plain\r\n")); + assert!( + head.to_ascii_lowercase() + .contains("accept-encoding: identity\r\n") + ); + assert!(!head.to_ascii_lowercase().contains("idempotency-key")); + let status = if index == 7 { + "403 Forbidden" + } else { + "200 OK" + }; + stream.write_all(format!("HTTP/1.1 {status}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n", body.len()).as_bytes()).await.expect("headers"); + stream.write_all(&body).await.expect("body"); + }); + let transport = crate::transport::GatewayHttpTransport::for_loopback_test(&recipe, port); + let response = transport.acquire_content(permit, &lease).await; + server.await.expect("server"); + let snapshot = match response { + Some(response) => granted + .record_content_response(response, NOW) + .await + .expect("retained"), + None => granted.record_unknown().await.expect("unknown"), + }; + assert_eq!( + snapshot.stage, + if index == 6 { + crate::AcquisitionStage::Unknown + } else { + crate::AcquisitionStage::ResponseRecorded + } + ); + let key = crate::GatewayAttemptKey::for_operation( + &policy, + recipe.namespace(), + &LogicalOperationId::parse(&format!("content-journal-{index}")).expect("op"), + ) + .expect("key"); + let retained = store + .load(crate::GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("retained"); + let value: Value = serde_json::from_slice(&retained).expect("record JSON"); + let phase = &value["state"]["facts"]["phase"]; + let metadata = &phase["metadata"]; + if index != 6 { + assert_eq!(phase["stage"], "content-response-recorded"); + let expected_media = match index { + 2 => json!({"kind": "invalid"}), + 3 => json!({"kind": "missing"}), + 5 => json!({"kind": "single", "value": "application/json"}), + _ => json!({"kind": "single", "value": "text/plain"}), + }; + let expected_encoding = match index { + 1 => json!({"kind": "single", "value": "gzip"}), + 4 => json!({"kind": "invalid"}), + _ => json!({"kind": "missing"}), + }; + assert_eq!(metadata["media_type"], expected_media); + assert_eq!(metadata["encoding"], expected_encoding); + assert_eq!( + phase["response"]["body_b64"], + base64ct::Base64::encode_string(b"PRIVATE-SYNTHETIC-CONTENT") + ); + // Content cannot be decoded as ordinary credential evidence by + // stripping the authenticated transport metadata variant. + let mut downgraded = value.clone(); + let phase = downgraded["state"]["facts"]["phase"] + .as_object_mut() + .expect("phase"); + phase.insert("stage".to_owned(), json!("response-recorded")); + phase.remove("metadata"); + let changed = serde_json_canonicalizer::to_vec(&downgraded).expect("corrupt bytes"); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &retained, &changed) + .expect("inject corruption"); + assert!(attempts.read_acquisition(&approved).await.is_err()); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &changed, &retained) + .expect("restore fixture"); + } else { + assert_eq!(phase["stage"], "unknown"); + } + let retained_text = String::from_utf8(retained.clone()).expect("JSON"); + assert!(!retained_text.contains("SYNTHETIC-CONTENT-TEST-CREDENTIAL")); + let reopened = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen")), + policy.clone(), + ) + .expect("attempts"); + let crate::AcquisitionClaim::Existing(replay) = reopened + .claim_content(&approved, NOW, validation()) + .await + .expect("replay") + else { + panic!("no fresh permit"); + }; + assert_eq!(snapshot, replay); + assert_eq!( + store + .load(crate::GatewayRecordKind::Attempt, &key) + .expect("reload") + .expect("record"), + retained + ); + let public_json = serde_json::to_string(&snapshot).expect("public"); + assert!(!public_json.contains("PRIVATE-SYNTHETIC-CONTENT")); + histories.push( + json!({"case": index, "snapshot": snapshot, "private_response_metadata": metadata}), + ); + } + // A different current connection cannot satisfy this retained source; + // changing administrative metadata leaves capacity keys unchanged. + let changed = record + .transition_state(ConnectionState::Disabled, NOW - 10) + .expect("disable"); + let plan = approved.content_plan().expect("content plan"); + assert!( + !plan + .source_matches(Some(&changed.to_canonical_cbor().expect("bytes"))) + .expect("source match") + .0 + ); + let fixture = json!({"schema": "auths.gateway-content-journal-fixture/1", + "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", + "permanent_source_attempts": 16, "history": histories}); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/content-journal.json"); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(&path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 118d93457..9bcc87e5c 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1279,6 +1279,68 @@ impl GatewayEngine { .map_err(|_| not_entered("gateway.acquisition.binding")) } + /// Compiles a declared content GET from exact resource arguments using + /// fresh independent native read authority. Performs no custody or provider + /// I/O and returns private review/approval data only. + /// + /// # Errors + /// Refuses invalid resource arguments, missing content declaration, changed + /// installation/configuration or invalid native read authority. + pub async fn compile_content_effect( + &self, + arguments: serde_json::Map, + proof: &[u8], + action: &[u8], + ) -> Result { + let (loaded, now) = self.effect_compilation_inputs().await?; + let target = + crate::effect::ContentReadTarget::new(&self.recipe, loaded.record(), arguments) + .map_err(|_| not_entered("gateway.acquisition.binding"))?; + crate::effect::compile_content_acquisition( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + &target, + now, + proof, + action, + ) + } + + /// Acquires and privately retains one exactly approved content response. + /// Returns redacted journal facts only; a provider response grants no + /// permission to disclose bytes. Replay cannot lease or fetch again. + /// + /// # Errors + /// Refuses invalid native authority/approval/configuration or unavailable + /// custody/state. Uncertain entry retains its permanent count/byte charges. + pub async fn acquire_content( + &self, + arguments: serde_json::Map, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self + .compile_content_effect(arguments, proof, action) + .await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + self.acquire_read_approved(approved, now, started).await + } + /// Compiles independently authorized recovery through the same installed /// binding and exact approval machinery as a mutation. The source writer's /// authority is provenance, not current read permission. No provider I/O, @@ -1339,10 +1401,10 @@ impl GatewayEngine { .approve(approval, self.effect_policy.approver(), now) .map_err(|_| not_entered("gateway.effect.approval"))?, ); - self.acquire_recovery_approved(approved, now, started).await + self.acquire_read_approved(approved, now, started).await } - async fn acquire_recovery_approved( + async fn acquire_read_approved( &self, approved: Arc, now: u64, @@ -1384,24 +1446,29 @@ impl GatewayEngine { io.revalidate(&approved, fresh) .map_err(|_| not_entered("gateway.effect.authority-unavailable"))?; let validation = io.entry_validation().map_err(not_entered)?; - let reserved = match self - .attempts - .claim_recovery(&approved, now, validation) - .await - { + let claim = if approved.content_target().is_some() { + self.attempts + .claim_content(&approved, now, validation) + .await + } else { + self.attempts + .claim_recovery(&approved, now, validation) + .await + }; + let reserved = match claim { Ok(crate::AcquisitionClaim::Existing(snapshot)) => return Ok(snapshot), Ok(crate::AcquisitionClaim::Reserved(reserved)) => reserved, Err(crate::GatewayAttemptError::BindingConflict) => { return Err(not_entered("gateway.effect.operation-conflict")); } - Err(_) => return self.recovery_projection(&approved).await, + Err(_) => return self.acquisition_projection(&approved).await, }; match self - .run_recovery_reservation(*reserved, Arc::clone(&approved), &io) + .run_read_reservation(*reserved, Arc::clone(&approved), &io) .await { Ok(snapshot) => Ok(snapshot), - Err(_) => self.recovery_projection(&approved).await, + Err(_) => self.acquisition_projection(&approved).await, } } @@ -1433,8 +1500,7 @@ impl GatewayEngine { .map_err(|_| not_entered("gateway.effect.approval"))?, ); let operation = approved.effect().binding().journal_identity().1.to_owned(); - self.acquire_recovery_approved(approved, now, started) - .await?; + self.acquire_read_approved(approved, now, started).await?; self.refine_recovery(source_operation, &operation) .await .map_err(|code| GatewaySubmitResult::Indeterminate { @@ -1477,7 +1543,7 @@ impl GatewayEngine { Ok(snapshot) } - async fn recovery_projection( + async fn acquisition_projection( &self, approved: &ApprovedEffect, ) -> Result { @@ -1491,7 +1557,7 @@ impl GatewayEngine { }) } - async fn run_recovery_reservation( + async fn run_read_reservation( &self, reserved: crate::ReservedAcquisition, approved: Arc, @@ -2000,6 +2066,18 @@ impl SubmitIo for EngineIo<'_> { } } + async fn acquire_content( + &self, + lease: &StoredSecretLease, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + self.prepared + .get()? + .transport + .acquire_content(permit, lease) + .await + } + async fn acquire( &self, lease: &StoredSecretLease, diff --git a/product/runtime/auths-gateway/src/recipe/content.rs b/product/runtime/auths-gateway/src/recipe/content.rs index fea7952cb..2e6ad4a2d 100644 --- a/product/runtime/auths-gateway/src/recipe/content.rs +++ b/product/runtime/auths-gateway/src/recipe/content.rs @@ -183,7 +183,8 @@ impl ClosedContentRead { } /// The exact expected response media type. Only an optional UTF-8 charset - /// is accepted by projection; compressed bodies are a transport refusal. + /// is accepted by projection. The caller must establish identity encoding + /// from retained transport metadata before projecting response bytes. #[must_use] pub const fn media_type(&self) -> &'static str { match self.projection { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 65124dc31..79e639b7f 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "50bad92473dab4b4643e6078ac9227db1d555e58861a07b41e16bf89d0500a35"; + "c9a9f6193d4f4119d74bbd4914c981e459af8d7f3cf7450842209639cf8db5c2"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 5d2944f03..5e246d8b8 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -71,9 +71,17 @@ pub(super) struct AcquisitionState { enum AcquisitionPhase { Reserved, EntryGranted, - NotEntered { code: String }, + NotEntered { + code: String, + }, Unknown, - ResponseRecorded { response: AcquisitionResponse }, + ResponseRecorded { + response: AcquisitionResponse, + }, + ContentResponseRecorded { + response: AcquisitionResponse, + metadata: crate::transport::ContentResponseMetadata, + }, } #[derive(Clone, Deserialize, Serialize)] @@ -92,7 +100,9 @@ impl AcquisitionPhase { Self::EntryGranted => transition::Stage::EntryGranted, Self::NotEntered { .. } => transition::Stage::NotEntered, Self::Unknown => transition::Stage::Unknown, - Self::ResponseRecorded { .. } => transition::Stage::ResponseRecorded, + Self::ResponseRecorded { .. } | Self::ContentResponseRecorded { .. } => { + transition::Stage::ResponseRecorded + } } } } @@ -137,6 +147,9 @@ impl JournalProtocol for AcquisitionState { refusal: matches!(record.state.phase, AcquisitionPhase::NotEntered { .. }), response: match &record.state.phase { AcquisitionPhase::ResponseRecorded { response } => canonical(response)?, + AcquisitionPhase::ContentResponseRecorded { response, metadata } => { + canonical(&(response, metadata))? + } _ => Vec::new(), }, pre_entry: Vec::new(), @@ -160,7 +173,9 @@ impl JournalProtocol for AcquisitionState { if record.state.allocation.is_some() && matches!( record.state.plan, - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) ) { let counts: Vec<_> = counters @@ -195,11 +210,28 @@ impl JournalProtocol for AcquisitionState { { return Err(GatewayAttemptError::Corrupt); } + if matches!( + record.state.phase, + AcquisitionPhase::ContentResponseRecorded { .. } + ) && !matches!(record.state.plan, AcquisitionPlan::Content(_)) + || matches!( + record.state.phase, + AcquisitionPhase::ResponseRecorded { .. } + ) && matches!(record.state.plan, AcquisitionPlan::Content(_)) + { + return Err(GatewayAttemptError::Corrupt); + } + if let AcquisitionPhase::ContentResponseRecorded { metadata, .. } = &record.state.phase + && !metadata.valid() + { + return Err(GatewayAttemptError::Corrupt); + } match &record.state.phase { AcquisitionPhase::NotEntered { code } if !valid_code(code) => { return Err(GatewayAttemptError::Corrupt); } - AcquisitionPhase::ResponseRecorded { response } => { + AcquisitionPhase::ResponseRecorded { response } + | AcquisitionPhase::ContentResponseRecorded { response, .. } => { let body = response.body(&capacity)?; let entry = record.entry.as_ref().ok_or(GatewayAttemptError::Corrupt)?; if response.received_at < entry.granted_at @@ -217,11 +249,16 @@ impl JournalProtocol for AcquisitionState { } impl AcquisitionResponse { - fn body(&self, capacity: &AcquisitionCapacity) -> Result, GatewayAttemptError> { + fn body( + &self, + capacity: &AcquisitionCapacity, + ) -> Result>, GatewayAttemptError> { if self.body_b64.len() > MAX_EVIDENCE_BYTES.div_ceil(3) * 4 { return Err(GatewayAttemptError::Corrupt); } - let body = Base64::decode_vec(&self.body_b64).map_err(|_| GatewayAttemptError::Corrupt)?; + let body = zeroize::Zeroizing::new( + Base64::decode_vec(&self.body_b64).map_err(|_| GatewayAttemptError::Corrupt)?, + ); if body.len() as u64 > capacity.maximum_bytes || Base64::encode_string(&body) != self.body_b64 { @@ -245,7 +282,8 @@ impl Record { (AcquisitionStage::Unknown, None, None) } AcquisitionPhase::NotEntered { .. } => (AcquisitionStage::NotEntered, None, None), - AcquisitionPhase::ResponseRecorded { response } => ( + AcquisitionPhase::ResponseRecorded { response } + | AcquisitionPhase::ContentResponseRecorded { response, .. } => ( AcquisitionStage::ResponseRecorded, Some(response.status), Some(response.body(&capacity)?.len() as u64), @@ -275,7 +313,10 @@ impl Record { response_status, response_bytes, response_version_ok: match &self.state.phase { - AcquisitionPhase::ResponseRecorded { response } => Some(response.version_ok), + AcquisitionPhase::ResponseRecorded { response } + | AcquisitionPhase::ContentResponseRecorded { response, .. } => { + Some(response.version_ok) + } _ => None, }, }) @@ -388,7 +429,7 @@ impl Record { response: crate::transport::ProviderResponse { status: response.status, version_ok: response.version_ok, - body: response.body(&capacity)?, + body: response.body(&capacity)?.to_vec(), }, received_at: response.received_at, observed_at, @@ -439,7 +480,9 @@ impl GatewayAttempts { &self, approved: &ApprovedEffect, ) -> Result, GatewayAttemptError> { - if (approved.recovery_target().is_none() && approved.candidate_target().is_none()) + if (approved.recovery_target().is_none() + && approved.candidate_target().is_none() + && approved.content_target().is_none()) || !self.policy.contains(approved.effect().binding()) { return Err(GatewayAttemptError::BindingConflict); @@ -504,6 +547,21 @@ impl GatewayAttempts { .await } + pub(crate) async fn claim_content( + &self, + approved: &Arc, + evaluated_at: u64, + validation: crate::entry::EntryValidation, + ) -> Result { + let plan = AcquisitionPlan::Content( + approved + .content_plan() + .map_err(|_| GatewayAttemptError::InvalidTransition)?, + ); + self.claim_acquisition(approved, plan, evaluated_at, validation) + .await + } + pub(crate) async fn claim_prerequisite( &self, approved: &Arc, @@ -544,6 +602,11 @@ impl GatewayAttempts { LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; let key = self.key(&namespace, &operation)?; let (source_kind, source_key) = match &plan { + AcquisitionPlan::Content(plan) => ( + GatewayRecordKind::Connection, + plan.source_key() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), AcquisitionPlan::Candidate(plan) => ( GatewayRecordKind::Connection, plan.source_key() @@ -560,13 +623,15 @@ impl GatewayAttempts { } }; let key = match &plan { - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => key, + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) => key, AcquisitionPlan::Prerequisite(plan) => prerequisite_key(source_key, plan.index()), }; let bound = match &plan { - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => { - approved.acquisition_bound().cloned() - } + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) => approved.acquisition_bound().cloned(), AcquisitionPlan::Prerequisite(_) => None, }; let expected_plan = plan.clone(); @@ -755,6 +820,20 @@ impl ReservedAcquisition { authorization_started_at: u64, ) -> Result<(GrantedAcquisition, AcquisitionEntryPermit), GatewayAttemptError> { let (plan, request) = match &self.attempt.record.state.plan { + AcquisitionPlan::Content(_) => ( + AcquisitionPlan::Content( + approved + .content_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Content( + approved + .content_target() + .ok_or(GatewayAttemptError::InvalidTransition)? + .closed_read() + .clone(), + ), + ), AcquisitionPlan::Recovery(_) => { let target = approved .recovery_target() @@ -805,7 +884,10 @@ impl ReservedAcquisition { let mut keys = vec![ (GatewayRecordKind::Attempt, attempt.key), ( - if matches!(plan, AcquisitionPlan::Candidate(_)) { + if matches!( + plan, + AcquisitionPlan::Candidate(_) | AcquisitionPlan::Content(_) + ) { GatewayRecordKind::Connection } else { GatewayRecordKind::Attempt @@ -822,7 +904,9 @@ impl ReservedAcquisition { keys.extend(capacity::dependencies(&attempt.record.state.counters)?); let counter_end = keys.len(); let prerequisites = match &plan { - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => approved + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) => approved .prerequisite_plans() .map_err(|_| GatewayAttemptError::Corrupt)?, AcquisitionPlan::Prerequisite(_) => Vec::new(), @@ -868,9 +952,9 @@ impl ReservedAcquisition { ) .map_err(|_| GatewayAttemptError::InvalidTransition)?; let bound = match &plan { - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) => { - approved.acquisition_bound() - } + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) => approved.acquisition_bound(), AcquisitionPlan::Prerequisite(_) => None, }; capacity::validate_reservations( @@ -891,7 +975,9 @@ impl ReservedAcquisition { )?; if matches!( plan, - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) ) { validation .validate_prerequisite_evidence( @@ -934,6 +1020,7 @@ impl ReservedAcquisition { } pub(crate) enum AcquisitionRequest { + Content(crate::recipe::ClosedContentRead), Recovery(ClosedObservationRequest), Prerequisite(ClosedPrerequisiteRead), } @@ -960,6 +1047,27 @@ impl GrantedAcquisition { self.attempt.advance(next).await?.record.snapshot() } + pub(crate) async fn record_content_response( + self, + response: crate::transport::ContentProviderResponse, + received_at: u64, + ) -> Result { + if !matches!(self.attempt.record.state.plan, AcquisitionPlan::Content(_)) { + return Err(GatewayAttemptError::InvalidTransition); + } + let mut next = self.attempt.record.clone(); + next.state.phase = AcquisitionPhase::ContentResponseRecorded { + response: AcquisitionResponse { + status: response.status, + version_ok: response.version_ok, + body_b64: Base64::encode_string(&response.body), + received_at, + }, + metadata: response.metadata, + }; + self.attempt.advance(next).await?.record.snapshot() + } + pub(crate) async fn record_response( self, status: u16, @@ -1057,6 +1165,9 @@ fn eligible_source( key: GatewayAttemptKey, ) -> Result<(bool, u64), GatewayAttemptError> { match plan { + AcquisitionPlan::Content(plan) => plan + .source_matches(source_bytes) + .map_err(|_| GatewayAttemptError::Corrupt), AcquisitionPlan::Candidate(plan) => plan .source_matches(source_bytes) .map_err(|_| GatewayAttemptError::Corrupt), @@ -1085,7 +1196,9 @@ fn eligible_source( source.validate_header()?, matches!( source.state.plan, - AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) ) && matches!(source.state.phase, AcquisitionPhase::Reserved), source.entry.is_some(), source.evaluated_at, diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 9ab7068fc..0f63f0a21 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -107,6 +107,15 @@ pub(crate) trait SubmitIo { permit: crate::store::ProviderEntryPermit, ) -> Result; + /// Content uses a distinct metadata-preserving response path. + async fn acquire_content( + &self, + _lease: &Self::Lease, + _permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + None + } + /// Consumes one durably acknowledged permit for an exact compiled read. async fn acquire( &self, @@ -123,6 +132,13 @@ pub(crate) trait AcquisitionIo { fn acquisition_leave(&self); fn acquisition_clock(&self) -> Option; fn acquisition_validation(&self) -> Result; + async fn acquisition_content_send( + &self, + _lease: &Self::Lease, + _permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + None + } async fn acquisition_send( &self, lease: &Self::Lease, @@ -144,6 +160,13 @@ impl AcquisitionIo for T { fn acquisition_validation(&self) -> Result { self.entry_validation() } + async fn acquisition_content_send( + &self, + lease: &Self::Lease, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + self.acquire_content(lease, permit).await + } async fn acquisition_send( &self, lease: &Self::Lease, @@ -232,10 +255,21 @@ pub(crate) async fn complete_acquisition( let now = io .acquisition_clock() .ok_or("gateway.verify.clock-unavailable")?; + let content = approved.content_target().is_some(); let (granted, permit) = reserved .grant_entry(approved, validation, now) .await .map_err(|_| "gateway.entry.unavailable")?; + if content { + return match io.acquisition_content_send(lease, permit).await { + Some(response) => match io.acquisition_clock() { + Some(received_at) => granted.record_content_response(response, received_at).await, + None => granted.record_unknown().await, + }, + None => granted.record_unknown().await, + } + .map_err(|_| "gateway.attempt.state-unavailable"); + } match io.acquisition_send(lease, permit).await { Some(response) => match io.acquisition_clock() { Some(received_at) => { diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 76a6d6423..90ca171f6 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -65,6 +65,69 @@ pub(crate) struct ProviderResponse { pub(crate) body: Vec, } +/// Content responses retain the transport metadata needed for projection. +/// Ordinary credential/recovery evidence cannot be promoted to content. +pub(crate) struct ContentProviderResponse { + pub(crate) status: u16, + pub(crate) version_ok: bool, + pub(crate) body: Zeroizing>, + pub(crate) metadata: ContentResponseMetadata, +} + +#[derive(Clone, serde::Deserialize, serde::Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct ContentResponseMetadata { + media_type: ContentResponseHeader, + encoding: ContentResponseHeader, +} + +#[derive(Clone, serde::Deserialize, serde::Serialize)] +#[serde( + tag = "kind", + content = "value", + rename_all = "kebab-case", + deny_unknown_fields +)] +enum ContentResponseHeader { + Missing, + Single(String), + Invalid, +} + +impl ContentResponseHeader { + fn capture(headers: &HeaderMap, name: HeaderName) -> Self { + let mut values = headers.get_all(name).iter(); + let Some(value) = values.next() else { + return Self::Missing; + }; + if values.next().is_some() || value.as_bytes().len() > 128 { + return Self::Invalid; + } + match value.to_str() { + Ok(value) => Self::Single(value.to_owned()), + Err(_) => Self::Invalid, + } + } + fn valid(&self) -> bool { + match self { + Self::Single(value) => value.len() <= 128 && HeaderValue::from_str(value).is_ok(), + Self::Missing | Self::Invalid => true, + } + } +} + +impl ContentResponseMetadata { + fn capture(headers: &HeaderMap) -> Self { + Self { + media_type: ContentResponseHeader::capture(headers, CONTENT_TYPE), + encoding: ContentResponseHeader::capture(headers, reqwest::header::CONTENT_ENCODING), + } + } + pub(crate) fn valid(&self) -> bool { + self.media_type.valid() && self.encoding.valid() + } +} + impl ProviderResponse { /// Whether the status is 2xx. pub(crate) const fn success(&self) -> bool { @@ -88,6 +151,7 @@ pub(crate) trait ProviderPort { permit: crate::store::AcquisitionEntryPermit, ) -> Option { match permit.request() { + crate::store::AcquisitionRequest::Content(_) => None, crate::store::AcquisitionRequest::Recovery(read) => { self.action_read(read.url(), read.headers(), read.maximum_response_bytes()) .await @@ -268,6 +332,10 @@ impl GatewayHttpTransport { } let origin = review.origin(); let client = Client::builder() + .no_gzip() + .no_brotli() + .no_deflate() + .no_zstd() .no_proxy() .redirect(reqwest::redirect::Policy::none()) .connect_timeout(Duration::from_secs(5)) @@ -374,6 +442,7 @@ impl GatewayHttpTransport { ) -> Option { let secret = lease.expose(Instant::now()).ok()?; match permit.request() { + crate::store::AcquisitionRequest::Content(_) => None, crate::store::AcquisitionRequest::Recovery(request) => { self.read( reqwest::Method::GET, @@ -402,6 +471,51 @@ impl GatewayHttpTransport { } } + /// Consumes the content-only permit and sends exactly the compiler-owned + /// GET, including reviewed fixed query pairs. No caller URL is accepted. + pub(crate) async fn acquire_content( + &self, + permit: crate::store::AcquisitionEntryPermit, + lease: &StoredSecretLease, + ) -> Option { + let crate::store::AcquisitionRequest::Content(content) = permit.request() else { + return None; + }; + let read = content.transport(); + if !self.owns_content_url(read.url()) { + return None; + } + let secret = lease.expose(Instant::now()).ok()?; + let credential = credential_headers(&self.requirement, secret).ok()?; + let mut outbound = self + .client + .get(self.target(read.url())) + .headers(credential) + .header(ACCEPT, content.media_type()) + .header(reqwest::header::ACCEPT_ENCODING, "identity"); + for header in read.headers() { + outbound = outbound.header( + provider_header_name(header).ok()?, + provider_header_value(header).ok()?, + ); + } + let outbound = outbound.build().ok()?; + if let Some(witness) = &self.witness { + witness.read(); + } + let mut response = self.client.execute(outbound).await.ok()?; + let status = response.status().as_u16(); + let version_ok = self.versions_echoed(response.headers()); + let metadata = ContentResponseMetadata::capture(response.headers()); + let body = read_bounded(&mut response, read.maximum_response_bytes()).await?; + Some(ContentProviderResponse { + status, + version_ok, + metadata, + body: Zeroizing::new(body), + }) + } + /// One bounded read with `secret`: the complete response of any status, /// or `None` after a transport failure or an oversized body. Redirects /// are never followed, so a 3xx comes back as its own status. @@ -461,6 +575,10 @@ impl GatewayHttpTransport { let review = recipe.review(); Self { client: Client::builder() + .no_gzip() + .no_brotli() + .no_deflate() + .no_zstd() .no_proxy() .redirect(reqwest::redirect::Policy::none()) .pool_max_idle_per_host(0) @@ -479,6 +597,18 @@ impl GatewayHttpTransport { format!("{}{}", self.target_origin, &owned[self.origin.len()..]) } + fn owns_content_url(&self, candidate: &str) -> bool { + candidate.len() <= 8192 + && candidate.starts_with(&self.origin) + && candidate.as_bytes().get(self.origin.len()) == Some(&b'/') + && Url::parse(candidate).is_ok_and(|url| { + url.origin().ascii_serialization() == self.origin + && url.fragment().is_none() + && url.username().is_empty() + && url.password().is_none() + }) + } + fn owns_url(&self, candidate: &str) -> bool { candidate.starts_with(&self.origin) && candidate.as_bytes().get(self.origin.len()) == Some(&b'/') @@ -504,6 +634,10 @@ fn provider_header_value(header: &RequestHeader) -> Result Result { Client::builder() + .no_gzip() + .no_brotli() + .no_deflate() + .no_zstd() .https_only(true) .no_proxy() .redirect(reqwest::redirect::Policy::none()) @@ -548,14 +682,14 @@ fn credential_headers( } async fn read_bounded(response: &mut reqwest::Response, maximum: usize) -> Option> { - let mut bytes = Vec::new(); + let mut bytes = Zeroizing::new(Vec::new()); while let Some(chunk) = response.chunk().await.ok()? { if bytes.len().checked_add(chunk.len())? > maximum { return None; } bytes.extend_from_slice(&chunk); } - Some(bytes) + Some(std::mem::take(&mut *bytes)) } fn public_ipv4(ip: Ipv4Addr) -> bool { @@ -736,6 +870,10 @@ mod tests { let provider = tokio::spawn(async move { capture_heads(&listener, 2).await }); let transport = GatewayHttpTransport { client: Client::builder() + .no_gzip() + .no_brotli() + .no_deflate() + .no_zstd() .no_proxy() .redirect(reqwest::redirect::Policy::none()) .pool_max_idle_per_host(0) From 10a548eec0c42bd97d93c149f1d113b37fc09532 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 21:17:48 +0000 Subject: [PATCH 049/136] feat(gateway)!: retain protected content with acquisition responses --- Cargo.lock | 1 + architecture/dependency-graph.json | 12 + .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 16 ++ .../fixtures/gateway/content-journal.json | 209 ++++++++++++++---- .../fixtures/gateway/prerequisite-entry.json | 2 +- compliance.toml | 9 +- ...017-bound-effect-and-recovery-ownership.md | 30 +++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 47 ++++ .../0009-bound-effect-and-recovery.md | 23 ++ ...ound-effects-and-recovery-state-machine.md | 43 +++- product/runtime/auths-gateway/Cargo.toml | 1 + .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6577 -> 6577 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6460 -> 6460 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5732 -> 5732 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5031 -> 5031 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 1 + .../auths-gateway/src/effect/content.rs | 12 + .../auths-gateway/src/effect_content_tests.rs | 124 ++++++++++- .../src/effect_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/lib.rs | 18 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 2 + .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- product/runtime/auths-gateway/src/recipe.rs | 2 + .../auths-gateway/src/recipe/content.rs | 68 +++++- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 8 +- .../auths-gateway/src/store/acquisition.rs | 55 ++++- .../src/store/acquisition/content.rs | 147 ++++++++++++ .../runtime/auths-gateway/src/transport.rs | 21 ++ 40 files changed, 773 insertions(+), 108 deletions(-) create mode 100644 product/runtime/auths-gateway/src/store/acquisition/content.rs diff --git a/Cargo.lock b/Cargo.lock index aca959af0..255f50963 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -641,6 +641,7 @@ dependencies = [ "ed25519-dalek 2.2.0", "getrandom 0.3.4", "hex", + "hmac 0.12.1", "minicbor", "p256", "postgres", diff --git a/architecture/dependency-graph.json b/architecture/dependency-graph.json index 6ee389cb2..782bdd5be 100644 --- a/architecture/dependency-graph.json +++ b/architecture/dependency-graph.json @@ -3785,6 +3785,18 @@ "default_features": true, "features": [] }, + { + "source": "auths-gateway", + "source_layer": "product", + "target": "hmac", + "target_layer": null, + "scope": "external", + "kind": "normal", + "target_condition": null, + "optional": false, + "default_features": true, + "features": [] + }, { "source": "auths-gateway", "source_layer": "product", diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 3783e22ac..c5d2af1d6 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/12", + "attempt_schema": "auths.gateway-attempt/13", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 3576d004e..2d58d66d6 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -267,6 +267,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.content.response-encoding", + "owner": "ContentProjectionError", + "stage": "response", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.content.response-media-type", "owner": "ContentProjectionError", @@ -291,6 +299,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.content.response-version", + "owner": "ContentProjectionError", + "stage": "response", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.credential.account-mismatch", "owner": "engine", diff --git a/bindings/fixtures/gateway/content-journal.json b/bindings/fixtures/gateway/content-journal.json index a5fcbfc44..d39e249c2 100644 --- a/bindings/fixtures/gateway/content-journal.json +++ b/bindings/fixtures/gateway/content-journal.json @@ -1,7 +1,10 @@ { - "schema": "auths.gateway-content-journal-fixture/1", + "schema": "auths.gateway-content-journal-fixture/2", "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", "permanent_source_attempts": 16, + "real_http_requests": 15, + "protected_content_mutations_refused": true, + "same_content_foreign_source_refused": true, "history": [ { "case": 0, @@ -14,7 +17,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 25 + } }, "private_response_metadata": { "media_type": { @@ -37,7 +44,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-encoding" + } }, "private_response_metadata": { "media_type": { @@ -61,7 +72,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-media-type" + } }, "private_response_metadata": { "media_type": { @@ -83,7 +98,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-media-type" + } }, "private_response_metadata": { "media_type": { @@ -105,7 +124,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-encoding" + } }, "private_response_metadata": { "media_type": { @@ -128,7 +151,11 @@ "policy_byte_counters": 0, "response_status": 200, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-media-type" + } }, "private_response_metadata": { "media_type": { @@ -166,7 +193,11 @@ "policy_byte_counters": 0, "response_status": 403, "response_bytes": 25, - "response_version_ok": true + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-status" + } }, "private_response_metadata": { "media_type": { @@ -179,101 +210,193 @@ } }, { - "case": "lost-permit", + "case": 8, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 25 + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { - "case": "lost-permit", + "case": 9, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 0, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 0 + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { - "case": "lost-permit", + "case": 10, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 64, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 64 + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { - "case": "lost-permit", + "case": 11, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 65, + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.content-too-large" + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { - "case": "lost-permit", + "case": 12, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 1, + "response_version_ok": true, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.invalid-response" + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { - "case": "lost-permit", + "case": 13, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 25, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 25 + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "single", + "value": "identity" + } } }, { - "case": "lost-permit", + "case": 14, "snapshot": { "revision": 3, - "stage": "unknown", + "stage": "response-recorded", "reserved_calls": 1, "reserved_bytes": 1024, "policy_count_counters": 0, "policy_byte_counters": 0, - "response_status": null, - "response_bytes": null, - "response_version_ok": null + "response_status": 200, + "response_bytes": 25, + "response_version_ok": false, + "content_projection": { + "kind": "rejected", + "code": "gateway.content.response-version" + } + }, + "private_response_metadata": { + "media_type": { + "kind": "single", + "value": "text/plain" + }, + "encoding": { + "kind": "missing" + } } }, { diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index e0ce510f0..73acc70c2 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/12", + "attempt_schema": "auths.gateway-attempt/13", "cases": [ { "recipe": "stripe", diff --git a/compliance.toml b/compliance.toml index 76e9e0380..98f6b616c 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/12", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/13", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1604,7 +1604,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/12", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/13", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1612,9 +1612,12 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +protected-content-retention = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", +] content-journal-transport = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 93ae6bdd4..d0dcf09a3 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -856,3 +856,33 @@ file adapter, actual loopback HTTP, durable source exhaustion and reopened journal replay. Protected projected-content construction, separate disclosure, full engine/CLI process journeys, PostgreSQL faults and AP070 differential cutover remain required; this evidence grants no provider qualification. + + +## Protected content in the response transaction + +Attempt `/13` extends the existing content response fact with one closed +protected/refused result. Projection and key generation happen before the same +response acknowledgement; a crash cannot leave a published content identifier +without its retained response, or re-create a provider permit. Loading recomputes +projection/refusal from the bound contract and retained transport facts. No +separate content lifecycle, external write, schema migration or retry rule is +introduced. Ready projected bytes are reconstructed only inside the native owner. + +The receipt disclosure protector is a storage port, and MCP execution references +are bound to another protocol; neither supplies the required content commitment. +The gateway therefore uses the already-pinned workspace `hmac` primitive with +SHA-256 and the existing native canonical/domain codec. A fresh private 32-byte +key scopes each commitment to one source effect, projection, exact length and +private content digest. The key is stored under the same private-journal policy, +not returned in public snapshots. The snapshot exposes only readiness/length or +a stable refusal. This is hiding against public offline guesses while the key is +private; it is not journal encryption or protection against malicious journal +administration. No new cryptographic algorithm or general protection framework +is extracted. + +`content-journal.json` now includes fifteen HTTP cases, empty/exact/over-limit +content, bad UTF-8/version/encoding/media, original-byte replay, altered protected +fields and substitution from another valid acquisition with identical content. +The same pure projection leaf serves compiler-only and durable response paths. +Disclosure still needs separate native authority, approval, accounting, recipient +channel authentication and the shared final-entry fence. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 2a8c58e96..5d99ea3d3 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -188,7 +188,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/12`; a store holding obsolete records is refused as + `auths.gateway-attempt/13`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d8b336809..e1cf92f14 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1164,6 +1164,53 @@ closure regeneration passed after that correction (one artifact-generation test) observed. Bounded decoded response buffers and partial transport accumulation are zeroized on drop. Fetch found no new upstream commits. +## Protected content projection checkpoint + +- The previous goal turn made progress (`71fd4f7f`, committed/pushed); this + continuation adds protected content to that same response transaction. + Attempt `/13` rejects all obsolete `/12` state, without a compatibility reader. + A complete content response now retains either protected readiness or the + exact typed projection refusal. Neither result grants disclosure authority. +- The compiler and retained-response paths share one pure projection leaf. + Retained version agreement, identity encoding and exact media/projection are + enforced; empty content is valid. Encoded/wrong-media/malformed/over-limit + responses stay recorded and charged. Public snapshots expose only byte count + or stable refusal; response-version/encoding have distinct native codes. +- Protected content uses the pinned workspace HMAC-SHA256 primitive plus native + domain/canonical framing, with a fresh private 32-byte key and exact source, + projection, byte count and private content digest. Loads reproject and verify + the keyed commitment (or recompute the refusal); replay preserves the key and + original record bytes. No plaintext digest, key, commitment or body is public. + Existing journal access protection remains required; no encryption or defense + against a malicious journal/key administrator is claimed. +- Exact artifact generation passed on `71fd4f7f` plus this source: content + compilation/journal, code inventory, attempt scenarios, prerequisite entry + and native entry/fuzz seeds (six exact generators, 9.31 seconds). The initial + compile failure used a nonexistent pointer helper; it now invokes the existing + response-pointer and escape validators. A schema-edit script initially read + ripgrep stdin rather than the tree; it was corrected to an explicit `.` root. +- The strengthened `native_content_journal_fixture_is_current` generator then + passed (one test, 3.30 seconds). Version-2 evidence contains fifteen real HTTP + cases: repeated/empty/exact/over-limit/invalid UTF-8 content, identity/gzip/ + duplicate encodings, wrong/missing media, missing required version, HTTP denial + and oversized response, plus lost permit and seventeenth source refusal. + It rejects key/tag/length/schema/body/version/media mutations and swapping + protected material between independently valid sources containing the same + bytes. Reopened replay leaves the private key and complete record unchanged. +- `cargo xtask arch --update` completed required dependency-snapshot generation; + the reviewed delta is only `auths-gateway -> hmac` (no package or other edge + changes). Building that generator surfaced existing unused observation/raw-read + helpers, now gated to their test/testkit consumers instead of shipping unused + production read interfaces. Final semantic-closure generation passed (one exact + test, 0.28 seconds). These are artifact construction, not broad local gates or + hosted CI evidence. Fetch found no upstream commits; no hosted results were + inspected. +- Next: sealed retained source and native disclosure compilation, then shared + disclosure admission/entry, authenticated transport and persistent ACKs. The + standalone read-only installation, AP070 metadata/owner cutover, full + engine/CLI/UI/binding journey and P4 adapter/fault/differential/formal/performance + evidence remain required. No A01–A22 case closes at this checkpoint. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 9af27c06a..25f0aa934 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -581,3 +581,26 @@ rejected. Synthetic credential/provider data stays private; the artifact contain only public snapshots and synthetic response header facts. This is not an independent-process, PostgreSQL, full engine, protected-content/disclosure, AP070 equivalence or isolation claim. These evidence gates remain open. + + +## Protected projection comparison + +The durable content owner now invokes the same bounded projection leaf as the +compiler corpus after checking retained version and encoding facts. The domain +boundary remains unchanged: no Google file-ID/trash/canDownload/MIME predicate is +inferred. JSON-string projection is data-only and duplicate rejecting; UTF-8 is +exact and never lossy or truncated. Ready content is reconstructible from the +immutable raw response and contract, while refusal stays a distinct retained +fact. This performs no additional provider read or recipient delivery. + +The hiding commitment is a direct composition of the pinned HMAC-SHA256 primitive, +native canonical tuples and native domain commitments. Its private per-source +key and source/projection/length/content binding are explicit. It does not reuse +the unrelated MCP execution-reference format or turn a receipt-protection port +into a semantic owner. The protected journal remains a deployment assumption. +`content-journal.json` version 2 covers fifteen actual HTTP responses plus lost +permit/exhaustion, typed response refusal, key/tag/length/body/metadata mutation, +foreign-source material, old-schema refusal and unchanged replay. Random keys +and tags are never emitted into the canonical fixture; only checked facts and +public redacted statuses are stored. This is still narrow file-adapter evidence, +not PostgreSQL, independent-process or AP070 differential qualification. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index a3bbb5d27..3d4689d49 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -323,7 +323,7 @@ read proof/approval. Custody is checked for the exact staged reference before publication; independently stored custody and connection state are not claimed to be one atomic transaction. -The concrete journal encoding is `auths.gateway-attempt/12`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/13`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded @@ -411,16 +411,41 @@ encoding facts. Each header is missing, one value of at most 128 bytes, or inval by decoding a content record as ordinary prerequisite/recovery evidence. The typed `content-response-recorded` phase projects to the existing acquisition -response stage under the sole reducer. Neither this stage nor HTTP success proves -that a body is usable content. Later protected-content construction must reject -bad encoding/media/version/projection using retained metadata; it cannot refetch. +response stage under the sole reducer. Attempt schema `/13` atomically retains +one additional closed result: protected content or a typed projection refusal. +Obsolete `/12` records are rejected; no compatibility decoder or migration exists. +Required-version agreement, identity encoding, one valid media type and the exact +compiled projection must all hold before protected content is constructed. +Encoding may be absent or a single case-insensitive `identity` value; compressed +or ambiguous encodings refuse. Empty content is valid and distinct from absence. +The raw response and refusal remain durable even when projection fails; charges +are not refunded. Two additional stable codes distinguish response-version and +response-encoding failure. + +The private `auths.gateway-protected-content/1` record contains a freshly sampled +32-byte key, a 32-byte HMAC-SHA256 commitment and the exact projected byte count. +The MAC message is the existing native domain commitment under that schema over +the canonical tuple `(source EffectId, acquisition projection commitment, byte +count, private content digest)`. The private content digest uses +`auths.gateway-content-bytes/1` over the exact projected bytes. The content digest +and key are never public identifiers; the key stays private with the journal. +This reuses the workspace HMAC primitive and native canonical/domain framing. +Every load reprojects the retained response and verifies the byte count and MAC +with constant-time verification. A refusal is also recomputed rather than trusted +as an arbitrary stored code. The projected bytes need not be duplicated in the +journal: immutable raw evidence and the bound projection reconstruct them exactly +without provider I/O. Key fields and decoded/projected buffers are zeroized on +drop where supported. Existing protected-journal access policy is required; this +mechanism is not encryption or defense against an attacker controlling that +journal and its keys. + Restart and post-grant replay return recorded facts without a credential lease or new provider permit. Unknown/oversized responses retain their full charges. - -The content engine API returns redacted acquisition facts only. Standalone -read-only installation, AP070 metadata predicates, protected projected-content -commitments/retention, disclosure entry/transport and installed CLI/binding -journeys remain required before the complete consumer cutover. +The public acquisition projection reports only `ready { bytes }` or +`rejected { code }`, never the private key, content digest, hiding commitment or +plaintext. A ready result grants no disclosure authority. Standalone read-only +installation, AP070 metadata predicates, native disclosure compilation/entry/ +transport and installed CLI/binding journeys remain required for the cutover. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/Cargo.toml b/product/runtime/auths-gateway/Cargo.toml index a34dcb546..23e613565 100644 --- a/product/runtime/auths-gateway/Cargo.toml +++ b/product/runtime/auths-gateway/Cargo.toml @@ -63,6 +63,7 @@ base64ct.workspace = true clap.workspace = true ed25519-dalek.workspace = true hex.workspace = true +hmac.workspace = true minicbor.workspace = true getrandom.workspace = true rustix.workspace = true diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 5f77fc2ae..d4d047d64 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 970ae734f..30ff21324 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 5216cace9..a7200a8b5 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index c02a7fb52..7f2a47c20 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index 07b7b9fd0..bf1d8aa49 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/12","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 5f8e775cfbd94213edfe50268a2637a2fcac1487..d3f48214788a5829d8d83685f551ad5eaa9861a3 100644 GIT binary patch delta 23 ccmdmJywP}qF{ANDlX*NK@+Q~jHR7yH0A#`k$N&HU delta 23 ccmdmJywP}qF{9B&lX*NK@+Q~jHR7yH0A#2K#sB~S diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 977a7e4e2eb014573dac3e6e022ff7be237ae186..c4979b17ce63101cacc72316670d425d50d70c83 100644 GIT binary patch delta 23 ccmdmEw8vpF diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-entry-granted-synthetic-entry index e00709661dba534e5caf8f94f4bb41ff274bbc77..4db8a9588f49929012e6852d90c9a84e7cbc6f0a 100644 GIT binary patch delta 25 ecmaE&^F(KYF{AP3ubijYH~(Y*#t3HT^8f&oDhjCp delta 25 ecmaE&^F(KYF{9DuubijYH~(Y*#t3HT^8f&o5(=jP diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-reserved-to-not-entered-synthetic-entry index adea1cb8273a3cebe89d01cc5d1ae14b0675628e..46884b32ea23147837d701c1551337833f937810 100644 GIT binary patch delta 24 gcmZ3kzFd8RF{AO~ubdp4O*jrPG8%9G%DIUX0Bnf}jQ{`u delta 24 gcmZ3kzFd8RF{9Dqubdp4O*jrPG8%3E%DIUX0BmvyivR!s diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 496fcc0ec..79d1b2a50 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"0e75e2fdef44e79e57797ac6661295ae58ddb8de4a1990a6fd22ce6c54f78604"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"554b61e82205a78927fa92d2fef88c0ef45c3b198afc34f59b1594eff23d3946"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"2cd71cd41dae16846f0105d43e1f607d512fb596518119b9db3d98d6b8d0416c"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"92f320a018cd29d994d5c692718aec4933ffa5043d5987102c85c30e276f300d"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"47ef6078825920004c3896f578af008f10fcb78d1cf2c653e54e6a4b57dba3eb"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"3baed924dab86d78710390151bcc0fc2608c8a6f0af375447e8e5b816f91d8c6"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"eca744b81fbbcd791d7c7de97b067bbf538cf0d09f1d3098c8977063676339b1"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"281854eb6f0e3d6ff69495d5097a691fbe4cf1bb3a7bd1143bd685cd2c56fc09"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"4aa0673b5c2583d01500e7017f05c63337ab5b43ca7e2ab7d9ccc445c532cce5"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"5b1b342adc52aecbc7993b8086ab152b6104efdbed7e2641259123c1d84a728a"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"521025fe24eebe47aaa613b624d510aba4f151a4ef9ccd23caa0fdeea1cf53b5"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fb7c0e6f7ad4304b9d5066fbee2cfa9a1fcee554a0c5a6d470d2d8c9e8f5f4bf"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"60dfc187a1339ae93f527034e89c19d018b8a91d5e70e666e5d14064162eb8c8"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"da8627a171a98d69c0aeab4e27bea59c6311566a7b9de102e0db0d8908628a6e"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"da84ef3f68739b4534a58b2631269970b5f59ac7ee6d4260096376fcfa367bd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"7096dbb40fffc85cd60b5959529a32c6127f5d0218bca053d903ea2e6713cd8a"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"33dd10d7139a231632424e747117e99c719434d04fc65dc4c411f3c59d26f4a9"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"3c5e1b290d8510625745c7f213663eb7ad69031a3bcdf356e018b7c53f5a2ab9"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"09fa22147093afbfc92cf242981e47c745adf4c380bb5eac028974381c706e2d"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"727ebf1d5a0d3c38f657f306822d4358728cc2f162c2fadcf161570fe62d5289"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"9f2e494a411c02c6cdac6545a2b7cd57300af000c5c7a1ac5f9ebc3b953eaf81"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b1b4190a96eacf823fb4dce56fa1125cfcb6c7cea3dc7ce3ca5a34dd0565f161"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"fb5592bd7a45d561ba9431ade8c0b33eac63284f845be43f27646241a8500387"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"da128cacea0fcb8d53e4b70a3756245c66b55564d1a754f630c5522b2abd9108"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"cfe2145ba822adab1e2cd30643ef4762ab8749af3f2d8fc74f359e0646f501b0"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"4e7b4edb55d284d83e9e79282b985bd73f20a3a4d08022c80fdfd82eae09ad52"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"5bd9f47e530918b2df56be8e78082f9ac4f2e25994412b10cbdbecea586be1df"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"4a2a8593fbcfae99c7ba5cd393d4158735046fc8146929bc52bb09e5a982dec9"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"30b7b139b60678da9a3e46343bebbc9d2ef95879079cb1eb830045f11aeb83f7"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"e7f40d8c13210dda9e8a385584e6a055824cdd18a0a459c7eb4d801b79a65e27"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"878ed4b99e743675ee2840233d1df37fd95d5508fd00b290145d499547d7c244"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 83120de5d..8dfcd4787 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -21,6 +21,7 @@ use zeroize::Zeroizing; mod acquisition; mod candidate; mod content; +pub(crate) use content::ContentPlan; pub use content::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; mod disclosure; pub use disclosure::{ diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index a4e58dec6..d28713024 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -317,6 +317,17 @@ impl ContentPlan { Ok(contract) } + pub(crate) fn projection( + &self, + ) -> Result { + crate::recipe::ContentProjectionSpec::from_contract(&self.witness()?["content"]) + .ok_or(EffectBindingError::Invalid) + } + + pub(crate) fn projection_commitment(&self) -> Result<[u8; 32], EffectBindingError> { + commitment(CONTRACT, self.contract.as_bytes()) + } + pub(crate) fn capacity(&self) -> Result { let contract = self.witness()?; let maximum_bytes = contract["content"]["request"]["maximum_response_bytes"] @@ -352,6 +363,7 @@ impl ContentPlan { binding: &EffectBinding, ) -> Result { let capacity = self.capacity()?; + self.projection()?; let connection = self.connection()?; let bytes = Zeroizing::new( connection diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index 6d191e675..a89db7f6c 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -461,7 +461,13 @@ async fn native_content_journal_fixture_is_current() { let public = key.verifying_key().to_bytes(); let policy = EffectPolicy::new("synthetic-content-journal".to_owned(), 1, public).expect("policy"); - let recipe = content_recipe(declaration(json!({"kind": "utf8"}))).expect("recipe"); + let (source, lock) = h::recipe_sources(&json!({}), &Value::Null).expect("source"); + let mut source: Value = serde_json::from_slice(&source).expect("source JSON"); + source["content"] = declaration(json!({"kind": "utf8"})); + source["provider_headers"] = json!({"Stripe-Version": "2024-06-20"}); + let recipe = + CompiledRecipe::compile(&serde_json::to_vec(&source).expect("source bytes"), &lock) + .expect("recipe"); let initial = connection(&recipe); let credentials = auths_connections::InMemoryCredentialStore::new(1, 1024).expect("custody"); let reference = credentials @@ -615,6 +621,7 @@ async fn native_content_journal_fixture_is_current() { .await .expect("lease"); let mut histories = vec![]; + let mut first_protected = Value::Null; for index in 0..17 { let approved = approve(&format!("content-journal-{index}")); let claim = attempts @@ -651,7 +658,7 @@ async fn native_content_journal_fixture_is_current() { .is_err(), "one grant only" ); - if index >= 8 { + if index == 15 { drop(permit); let snapshot = granted.record_unknown().await.expect("unknown"); assert_eq!(snapshot.reserved_calls, 1); @@ -668,14 +675,19 @@ async fn native_content_journal_fixture_is_current() { "Content-Type: text/plain\r\nContent-Encoding: identity\r\nContent-Encoding: gzip\r\n" } 5 => "Content-Type: application/json\r\n", - 6 | 7 => "Content-Type: text/plain\r\n", + 6..=12 | 14 => "Content-Type: text/plain\r\n", + 13 => "Content-Type: text/plain\r\nContent-Encoding: identity\r\n", _ => unreachable!(), }; - let body = if index == 6 { - vec![b'x'; 1025] - } else { - b"PRIVATE-SYNTHETIC-CONTENT".to_vec() + let body = match index { + 6 => vec![b'x'; 1025], + 9 => vec![], + 10 => vec![b'x'; 64], + 11 => vec![b'x'; 65], + 12 => vec![255], + _ => b"PRIVATE-SYNTHETIC-CONTENT".to_vec(), }; + let expected_body = body.clone(); let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); let port = listener.local_addr().expect("port").port(); let server = tokio::spawn(async move { @@ -702,7 +714,16 @@ async fn native_content_journal_fixture_is_current() { } else { "200 OK" }; - stream.write_all(format!("HTTP/1.1 {status}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n", body.len()).as_bytes()).await.expect("headers"); + assert!( + head.to_ascii_lowercase() + .contains("stripe-version: 2024-06-20\r\n") + ); + let version = if index == 14 { + "" + } else { + "Stripe-Version: 2024-06-20\r\n" + }; + stream.write_all(format!("HTTP/1.1 {status}\r\n{headers}{version}Content-Length: {}\r\nConnection: close\r\n\r\n", body.len()).as_bytes()).await.expect("headers"); stream.write_all(&body).await.expect("body"); }); let transport = crate::transport::GatewayHttpTransport::for_loopback_test(&recipe, port); @@ -747,13 +768,14 @@ async fn native_content_journal_fixture_is_current() { let expected_encoding = match index { 1 => json!({"kind": "single", "value": "gzip"}), 4 => json!({"kind": "invalid"}), + 13 => json!({"kind": "single", "value": "identity"}), _ => json!({"kind": "missing"}), }; assert_eq!(metadata["media_type"], expected_media); assert_eq!(metadata["encoding"], expected_encoding); assert_eq!( phase["response"]["body_b64"], - base64ct::Base64::encode_string(b"PRIVATE-SYNTHETIC-CONTENT") + base64ct::Base64::encode_string(&expected_body) ); // Content cannot be decoded as ordinary credential evidence by // stripping the authenticated transport metadata variant. @@ -763,6 +785,7 @@ async fn native_content_journal_fixture_is_current() { .expect("phase"); phase.insert("stage".to_owned(), json!("response-recorded")); phase.remove("metadata"); + phase.remove("content"); let changed = serde_json_canonicalizer::to_vec(&downgraded).expect("corrupt bytes"); store .replace(crate::GatewayRecordKind::Attempt, &key, &retained, &changed) @@ -774,6 +797,81 @@ async fn native_content_journal_fixture_is_current() { } else { assert_eq!(phase["stage"], "unknown"); } + let projection = serde_json::to_value(&snapshot.content_projection).expect("status"); + let expected_projection = match index { + 0 | 8 | 9 | 10 | 13 => json!({"kind": "ready", "bytes": expected_body.len()}), + 1 | 4 => json!({"kind": "rejected", "code": "gateway.content.response-encoding"}), + 2 | 3 | 5 => json!({"kind": "rejected", "code": "gateway.content.response-media-type"}), + 6 => Value::Null, + 7 => json!({"kind": "rejected", "code": "gateway.content.response-status"}), + 11 => json!({"kind": "rejected", "code": "gateway.content.content-too-large"}), + 12 => json!({"kind": "rejected", "code": "gateway.content.invalid-response"}), + 14 => json!({"kind": "rejected", "code": "gateway.content.response-version"}), + _ => unreachable!(), + }; + assert_eq!(projection, expected_projection); + if index == 0 { + first_protected = phase["content"].clone(); + for pointer in [ + "/schema", + "/state/facts/phase/content/value/key/0", + "/state/facts/phase/content/value/commitment/0", + "/state/facts/phase/content/value/bytes", + "/state/facts/phase/content/value/schema", + "/state/facts/phase/response/body_b64", + "/state/facts/phase/response/version_ok", + "/state/facts/phase/metadata/media_type/value", + ] { + let mut changed = value.clone(); + let cell = changed.pointer_mut(pointer).expect("field"); + *cell = match pointer { + "/schema" => json!("auths.gateway-attempt/12"), + "/state/facts/phase/content/value/schema" => { + json!("auths.gateway-protected-content/0") + } + "/state/facts/phase/response/body_b64" => { + json!(base64ct::Base64::encode_string(b"CHANGED-PRIVATE-CONTENT")) + } + "/state/facts/phase/response/version_ok" => json!(false), + "/state/facts/phase/metadata/media_type/value" => json!("application/json"), + _ => json!(cell.as_u64().expect("number") ^ 1), + }; + let bytes = serde_json_canonicalizer::to_vec(&changed).expect("changed bytes"); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &retained, &bytes) + .expect("inject"); + assert!( + attempts.read_acquisition(&approved).await.is_err(), + "{pointer}" + ); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &bytes, &retained) + .expect("restore"); + } + } + if index == 8 { + assert_ne!( + phase["content"]["value"]["key"], + first_protected["value"]["key"] + ); + assert_ne!( + phase["content"]["value"]["commitment"], + first_protected["value"]["commitment"] + ); + let mut changed = value.clone(); + changed["state"]["facts"]["phase"]["content"] = first_protected.clone(); + let bytes = serde_json_canonicalizer::to_vec(&changed).expect("changed bytes"); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &retained, &bytes) + .expect("substitute source"); + assert!( + attempts.read_acquisition(&approved).await.is_err(), + "same bytes from another source do not satisfy this commitment" + ); + store + .replace(crate::GatewayRecordKind::Attempt, &key, &bytes, &retained) + .expect("restore"); + } let retained_text = String::from_utf8(retained.clone()).expect("JSON"); assert!(!retained_text.contains("SYNTHETIC-CONTENT-TEST-CREDENTIAL")); let reopened = crate::GatewayAttempts::new( @@ -798,6 +896,8 @@ async fn native_content_journal_fixture_is_current() { ); let public_json = serde_json::to_string(&snapshot).expect("public"); assert!(!public_json.contains("PRIVATE-SYNTHETIC-CONTENT")); + assert!(!public_json.contains("commitment")); + assert!(!public_json.contains("key")); histories.push( json!({"case": index, "snapshot": snapshot, "private_response_metadata": metadata}), ); @@ -814,9 +914,11 @@ async fn native_content_journal_fixture_is_current() { .expect("source match") .0 ); - let fixture = json!({"schema": "auths.gateway-content-journal-fixture/1", + let fixture = json!({"schema": "auths.gateway-content-journal-fixture/2", "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", - "permanent_source_attempts": 16, "history": histories}); + "permanent_source_attempts": 16, "real_http_requests": 15, + "protected_content_mutations_refused": true, "same_content_foreign_source_refused": true, + "history": histories}); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/content-journal.json"); let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 9294ae45a..9514d70f1 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -239,7 +239,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/12", + "attempt_schema": "auths.gateway-attempt/13", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index a8deb58de..c6a456861 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -136,15 +136,15 @@ pub use separation::{ }; pub use store::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, - ClaimedGatewayAttempt, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, - GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, - GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, - GatewayInsert, GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, - GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, - GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, - PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, - ReservedAcquisition, check_private_directory, check_private_directory_owned_by, - pre_entry_digest, + ClaimedGatewayAttempt, ContentProjectionStatus, FileGatewayAttemptStore, GatewayAttemptError, + GatewayAttemptKey, GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, + GatewayAttempts, GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, + GatewayFenceDecision, GatewayInsert, GatewayObservationFact, GatewayOperationStage, + GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, + GatewayRecoveryReport, GatewayRelativeBasis, ObservableGatewayAttempt, + PostgresGatewayAttemptStore, PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, + RecoverySourceFacts, ReservedAcquisition, check_private_directory, + check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 5a94685c3..e5edb64f5 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/12"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/13"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index bd762ccf2..92887e4b4 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,8 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.content.response-version ContentProjectionError response new 74 -", + "gateway.content.response-encoding ContentProjectionError response new 74 -", "gateway.content.response-status ContentProjectionError projection new 74 -", "gateway.content.response-media-type ContentProjectionError projection new 74 -", "gateway.content.response-too-large ContentProjectionError projection new 74 -", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 69876f5b7..655186c65 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/12"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/13"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index a8034b4ba..ef89b1cd3 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/12", + "store_schema": "auths.gateway-attempt/13", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index 546b772e1..b3d50359d 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -21,6 +21,7 @@ use url::{Host, Url}; pub use auths_gateway_kernel::{construct, recovery}; mod content; +pub(crate) use content::ContentProjectionSpec; pub use content::{CONTENT_READ_SCHEMA, ClosedContentRead, ContentProjectionError}; mod effect_review; mod lower; @@ -1322,6 +1323,7 @@ impl ClosedObservationRequest { /// Extracts the observed value and, when an echo field is declared and /// present, its value from bounded response bytes. A response that is too /// large, not JSON, or lacks the observed value yields `None`. + #[cfg(any(test, feature = "testkit-harness"))] pub(crate) fn observed_values(&self, response: &[u8]) -> Option<(Value, Option)> { if response.len() > self.maximum_response_bytes { return None; diff --git a/product/runtime/auths-gateway/src/recipe/content.rs b/product/runtime/auths-gateway/src/recipe/content.rs index 2e6ad4a2d..f4a181af1 100644 --- a/product/runtime/auths-gateway/src/recipe/content.rs +++ b/product/runtime/auths-gateway/src/recipe/content.rs @@ -10,8 +10,15 @@ pub const CONTENT_READ_SCHEMA: &str = "auths.gateway-content-read/1"; /// Why retained provider evidence cannot produce the declared private content. /// These are response facts, never native authorization denials. -#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize, thiserror::Error)] +#[serde(rename_all = "kebab-case")] pub enum ContentProjectionError { + /// The response does not match required provider-version headers. + #[error("provider response version does not permit content projection")] + Version, + /// Compressed, duplicate or malformed content encoding. + #[error("provider response encoding does not permit content projection")] + Encoding, /// The response status differs from the declared successful status. #[error("provider response status does not permit content projection")] Status, @@ -37,6 +44,8 @@ impl ContentProjectionError { #[must_use] pub const fn code(self) -> &'static str { match self { + Self::Version => "gateway.content.response-version", + Self::Encoding => "gateway.content.response-encoding", Self::Status => "gateway.content.response-status", Self::MediaType => "gateway.content.response-media-type", Self::ResponseLimit => "gateway.content.response-too-large", @@ -206,11 +215,66 @@ impl ClosedContentRead { status: u16, media_type: &str, body: &[u8], + ) -> Result>, ContentProjectionError> { + ContentProjectionSpec { + projection: self.projection.clone(), + maximum_response_bytes: self.read.maximum_response_bytes(), + maximum_content_bytes: self.maximum_content_bytes, + } + .project(status, media_type, body) + } +} + +/// Pure interpretation of a compiler-owned private content contract. It has no +/// request, credential or execution method and is never caller-selected policy. +pub(crate) struct ContentProjectionSpec { + projection: ContentProjection, + maximum_response_bytes: usize, + maximum_content_bytes: usize, +} + +impl ContentProjectionSpec { + pub(crate) fn from_contract(value: &Value) -> Option { + let projection: ContentProjection = + serde_json::from_value(value["projection"].clone()).ok()?; + let maximum_response_bytes = + usize::try_from(value["request"]["maximum_response_bytes"].as_u64()?).ok()?; + let maximum_content_bytes = + usize::try_from(value["maximum_content_bytes"].as_u64()?).ok()?; + let spec = Self { + projection, + maximum_response_bytes, + maximum_content_bytes, + }; + if value["schema"] != CONTENT_READ_SCHEMA + || value["required_status"] != 200 + || value["required_media_type"] != spec.media_type() + || !(1..=65_536).contains(&maximum_response_bytes) + || !(1..=maximum_response_bytes).contains(&maximum_content_bytes) + || matches!(&spec.projection, ContentProjection::JsonString { pointer } if (!super::validate::valid_response_pointer(pointer) || !valid_escapes(pointer))) + { + return None; + } + Some(spec) + } + + const fn media_type(&self) -> &'static str { + match self.projection { + ContentProjection::Utf8 => "text/plain", + ContentProjection::JsonString { .. } => "application/json", + } + } + + pub(crate) fn project( + &self, + status: u16, + media_type: &str, + body: &[u8], ) -> Result>, ContentProjectionError> { if status != 200 { return Err(ContentProjectionError::Status); } - if body.len() > self.read.maximum_response_bytes() { + if body.len() > self.maximum_response_bytes { return Err(ContentProjectionError::ResponseLimit); } if media_type.len() > 128 || !self.accepts_media_type(media_type) { diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index db3393122..df4858dad 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/12"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/13"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/12", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/13", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 79e639b7f..218fa1fbd 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "c9a9f6193d4f4119d74bbd4914c981e459af8d7f3cf7450842209639cf8db5c2"; + "68ceff77de7f7fddd4d629519f7b8770a8f43d77670def4de2ee2bcc1458c19a"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 09e79e2c5..f68704b82 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/12`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/13`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/12"; +const SCHEMA: &str = "auths.gateway-attempt/13"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -710,8 +710,8 @@ mod acquisition; mod capacity; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, - GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, - ReservedAcquisition, + ContentProjectionStatus, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, + RecoverySourceFacts, ReservedAcquisition, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 5e246d8b8..44ab7c056 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -7,6 +7,9 @@ use crate::effect::{ AcquisitionCapacity, AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, }; +mod content; +pub use content::ContentProjectionStatus; +use content::ContentResult; mod candidate; pub use candidate::CandidatePublication; mod recovery; @@ -39,6 +42,10 @@ pub struct AcquisitionSnapshot { pub response_bytes: Option, /// Whether required response-version headers matched the installed recipe. pub response_version_ok: Option, + /// Native interpretation of a complete content response. No raw content, + /// hiding key or private correlation commitment appears here. + #[serde(skip_serializing_if = "Option::is_none")] + pub content_projection: Option, } /// Acquisition has no mutation-observed or disclosure-acknowledged state. @@ -81,6 +88,7 @@ enum AcquisitionPhase { ContentResponseRecorded { response: AcquisitionResponse, metadata: crate::transport::ContentResponseMetadata, + content: ContentResult, }, } @@ -147,9 +155,11 @@ impl JournalProtocol for AcquisitionState { refusal: matches!(record.state.phase, AcquisitionPhase::NotEntered { .. }), response: match &record.state.phase { AcquisitionPhase::ResponseRecorded { response } => canonical(response)?, - AcquisitionPhase::ContentResponseRecorded { response, metadata } => { - canonical(&(response, metadata))? - } + AcquisitionPhase::ContentResponseRecorded { + response, + metadata, + content, + } => canonical(&(response, metadata, content))?, _ => Vec::new(), }, pre_entry: Vec::new(), @@ -226,6 +236,17 @@ impl JournalProtocol for AcquisitionState { { return Err(GatewayAttemptError::Corrupt); } + if let AcquisitionPhase::ContentResponseRecorded { + response, + metadata, + content, + } = &record.state.phase + { + let AcquisitionPlan::Content(plan) = &record.state.plan else { + return Err(GatewayAttemptError::Corrupt); + }; + content.validate(&binding, plan, response, metadata)?; + } match &record.state.phase { AcquisitionPhase::NotEntered { code } if !valid_code(code) => { return Err(GatewayAttemptError::Corrupt); @@ -312,6 +333,10 @@ impl Record { .count() as u64, response_status, response_bytes, + content_projection: match &self.state.phase { + AcquisitionPhase::ContentResponseRecorded { content, .. } => Some(content.status()), + _ => None, + }, response_version_ok: match &self.state.phase { AcquisitionPhase::ResponseRecorded { response } | AcquisitionPhase::ContentResponseRecorded { response, .. } => { @@ -1052,18 +1077,26 @@ impl GrantedAcquisition { response: crate::transport::ContentProviderResponse, received_at: u64, ) -> Result { - if !matches!(self.attempt.record.state.plan, AcquisitionPlan::Content(_)) { + let AcquisitionPlan::Content(plan) = &self.attempt.record.state.plan else { return Err(GatewayAttemptError::InvalidTransition); - } + }; + let retained = AcquisitionResponse { + status: response.status, + version_ok: response.version_ok, + body_b64: Base64::encode_string(&response.body), + received_at, + }; + let content = ContentResult::create( + &self.attempt.record.validate_header()?, + plan, + &retained, + &response.metadata, + )?; let mut next = self.attempt.record.clone(); next.state.phase = AcquisitionPhase::ContentResponseRecorded { - response: AcquisitionResponse { - status: response.status, - version_ok: response.version_ok, - body_b64: Base64::encode_string(&response.body), - received_at, - }, + response: retained, metadata: response.metadata, + content, }; self.attempt.advance(next).await?.record.snapshot() } diff --git a/product/runtime/auths-gateway/src/store/acquisition/content.rs b/product/runtime/auths-gateway/src/store/acquisition/content.rs new file mode 100644 index 000000000..27a0149ba --- /dev/null +++ b/product/runtime/auths-gateway/src/store/acquisition/content.rs @@ -0,0 +1,147 @@ +//! Private deterministic projection and hiding commitment over retained content. +//! This module cannot obtain credentials, fetch bytes or grant disclosure. +use super::*; +use crate::recipe::ContentProjectionError; +use hmac::{Hmac, Mac as _}; +use zeroize::{Zeroize as _, Zeroizing}; + +type ContentMac = Hmac; +pub(crate) const PROTECTED_CONTENT_SCHEMA: &str = "auths.gateway-protected-content/1"; + +/// Public response interpretation without plaintext, key or correlation digest. +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] +pub enum ContentProjectionStatus { + /// Exact projected bytes are reconstructible from private retained evidence. + Ready { bytes: u64 }, + /// The complete response was retained, but cannot be disclosed as content. + Rejected { code: String }, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde( + tag = "kind", + content = "value", + rename_all = "kebab-case", + deny_unknown_fields +)] +pub(super) enum ContentResult { + Ready(ProtectedContent), + Rejected(ContentProjectionError), +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct ProtectedContent { + schema: String, + key: [u8; 32], + commitment: [u8; 32], + bytes: u64, +} + +impl Drop for ProtectedContent { + fn drop(&mut self) { + self.key.zeroize(); + } +} + +impl ContentResult { + pub(super) fn create( + binding: &EffectBinding, + plan: &crate::effect::ContentPlan, + response: &AcquisitionResponse, + metadata: &crate::transport::ContentResponseMetadata, + ) -> Result { + match project(plan, response, metadata)? { + Ok(bytes) => { + let mut key = Zeroizing::new([0; 32]); + getrandom::fill(key.as_mut()).map_err(|_| GatewayAttemptError::Unavailable)?; + let message = message(binding, plan, &bytes)?; + let mut mac = ContentMac::new_from_slice(key.as_ref()) + .map_err(|_| GatewayAttemptError::Corrupt)?; + mac.update(&message); + Ok(Self::Ready(ProtectedContent { + schema: PROTECTED_CONTENT_SCHEMA.to_owned(), + key: *key, + commitment: mac.finalize().into_bytes().into(), + bytes: bytes.len() as u64, + })) + } + Err(reason) => Ok(Self::Rejected(reason)), + } + } + + pub(super) fn validate( + &self, + binding: &EffectBinding, + plan: &crate::effect::ContentPlan, + response: &AcquisitionResponse, + metadata: &crate::transport::ContentResponseMetadata, + ) -> Result<(), GatewayAttemptError> { + match (self, project(plan, response, metadata)?) { + (Self::Rejected(expected), Err(actual)) if *expected == actual => Ok(()), + (Self::Ready(stored), Ok(bytes)) + if stored.schema == PROTECTED_CONTENT_SCHEMA + && stored.bytes == bytes.len() as u64 => + { + let mut mac = ContentMac::new_from_slice(&stored.key) + .map_err(|_| GatewayAttemptError::Corrupt)?; + mac.update(&message(binding, plan, &bytes)?); + mac.verify_slice(&stored.commitment) + .map_err(|_| GatewayAttemptError::Corrupt) + } + _ => Err(GatewayAttemptError::Corrupt), + } + } + + pub(super) fn status(&self) -> ContentProjectionStatus { + match self { + Self::Ready(value) => ContentProjectionStatus::Ready { bytes: value.bytes }, + Self::Rejected(reason) => ContentProjectionStatus::Rejected { + code: reason.code().to_owned(), + }, + } + } +} + +fn project( + plan: &crate::effect::ContentPlan, + response: &AcquisitionResponse, + metadata: &crate::transport::ContentResponseMetadata, +) -> Result>, ContentProjectionError>, GatewayAttemptError> { + let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; + let body = response.body(&capacity)?; + let projection = plan + .projection() + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !response.version_ok { + return Ok(Err(ContentProjectionError::Version)); + } + let media = match metadata.projection_media_type() { + Ok(media) => media, + Err(error) => return Ok(Err(error)), + }; + Ok(projection.project(response.status, media, &body)) +} + +/// The plain digest is private input to the keyed commitment and is never a +/// public content identifier. Fixed-size native canonical inputs also support +/// the full 65,536-byte content bound without JSON byte-array expansion. +fn message( + binding: &EffectBinding, + plan: &crate::effect::ContentPlan, + bytes: &[u8], +) -> Result<[u8; 32], GatewayAttemptError> { + let private_digest = auths_codec::domain_commitment("auths.gateway-content-bytes/1", bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let payload = Zeroizing::new(canonical(&( + binding.id().as_bytes(), + plan.projection_commitment() + .map_err(|_| GatewayAttemptError::Corrupt)?, + bytes.len() as u64, + private_digest.as_bytes(), + ))?); + auths_codec::domain_commitment(PROTECTED_CONTENT_SCHEMA, &payload) + .map(|digest| *digest.as_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt) +} diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index 90ca171f6..cca02e982 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -126,6 +126,20 @@ impl ContentResponseMetadata { pub(crate) fn valid(&self) -> bool { self.media_type.valid() && self.encoding.valid() } + pub(crate) fn projection_media_type( + &self, + ) -> Result<&str, crate::recipe::ContentProjectionError> { + use crate::recipe::ContentProjectionError; + if !matches!(self.encoding, ContentResponseHeader::Missing) + && !matches!(&self.encoding, ContentResponseHeader::Single(value) if value.eq_ignore_ascii_case("identity")) + { + return Err(ContentProjectionError::Encoding); + } + match &self.media_type { + ContentResponseHeader::Single(value) => Ok(value.as_str()), + _ => Err(ContentProjectionError::MediaType), + } + } } impl ProviderResponse { @@ -146,6 +160,7 @@ impl ProviderResponse { /// counting provider. No method may retry a write. pub(crate) trait ProviderPort { /// Shared sealed acquisition path, including counting test providers. + #[cfg(any(test, feature = "testkit-harness"))] async fn acquire( &self, permit: crate::store::AcquisitionEntryPermit, @@ -177,6 +192,7 @@ pub(crate) trait ProviderPort { /// Performs one bounded GET of an action read or observation and returns /// the complete response, or `None` after a transport failure or an /// oversized body. + #[cfg(any(test, feature = "testkit-harness"))] async fn action_read( &self, url: &str, @@ -185,6 +201,7 @@ pub(crate) trait ProviderPort { ) -> Option; /// Performs one credential read with the leased secret. + #[cfg(any(test, feature = "testkit-harness"))] async fn credential_read(&self, read: &ClosedCredentialRead) -> Option; } @@ -197,6 +214,7 @@ impl ProviderPort for &P { (**self).write(permit).await } + #[cfg(any(test, feature = "testkit-harness"))] async fn action_read( &self, url: &str, @@ -208,6 +226,7 @@ impl ProviderPort for &P { .await } + #[cfg(any(test, feature = "testkit-harness"))] async fn credential_read(&self, read: &ClosedCredentialRead) -> Option { (**self).credential_read(read).await } @@ -227,6 +246,7 @@ impl ProviderPort for LeasedTransport<'_> { self.transport.write(permit, self.lease).await } + #[cfg(any(test, feature = "testkit-harness"))] async fn action_read( &self, url: &str, @@ -245,6 +265,7 @@ impl ProviderPort for LeasedTransport<'_> { .await } + #[cfg(any(test, feature = "testkit-harness"))] async fn credential_read(&self, read: &ClosedCredentialRead) -> Option { let secret = self.lease.expose(Instant::now()).ok()?; self.transport.credential_read(read, secret).await From 622a58feb9847484537342684a914fd45ec17ecf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 28 Oct 2026 21:21:14 +0000 Subject: [PATCH 050/136] chore(formal): regenerate qualification artifacts Source-SHA: 10a548eec0c42bd97d93c149f1d113b37fc09532 Workflow-Run: 40770782471 --- formal/qualification/aeneas/source-closure.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 6ca74b7d3..25b92f4e9 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "3b23be9569e958891b44f48aa891d691c61603bdcceb08d47a358ea6f32803dd", + "digest": "38f42e4b20b5f2c3312654eac384932091c1085677bf073cbe79695ca08048eb", "files": [ { "path": ".cargo/config.toml", @@ -8,7 +8,7 @@ }, { "path": "Cargo.lock", - "sha256": "f84825e2ac0d4af57a406ab4b49ae5ce4e9360caf0a23e092906257743509b04", + "sha256": "9a7d4631685c172dc81e588d86603642563555b90785b6722d5657b4649df523", "normalization": "translated-cargo-closure-v1" }, { From 93f4915c0742031652d5fa21580f4091030e122d Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 21:29:14 +0000 Subject: [PATCH 051/136] feat(gateway): compile separately authorized retained-content disclosures --- bindings/fixtures/gateway/codes.json | 16 + .../fixtures/gateway/content-journal.json | 40 +- compliance.toml | 5 +- ...017-bound-effect-and-recovery-ownership.md | 25 ++ docs/plans/0074-implementation-status.md | 28 ++ .../0009-bound-effect-and-recovery.md | 18 + ...ound-effects-and-recovery-state-machine.md | 35 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/bounds.rs | 62 +++- product/runtime/auths-gateway/src/effect.rs | 44 ++- .../auths-gateway/src/effect/content.rs | 4 + .../auths-gateway/src/effect/prerequisite.rs | 5 + .../auths-gateway/src/effect/release.rs | 274 ++++++++++++++ .../auths-gateway/src/effect_content_tests.rs | 344 +++++++++++++++++- .../src/effect_read_budget_tests.rs | 2 +- product/runtime/auths-gateway/src/lib.rs | 2 +- .../src/pending_vectors/codes.rs | 3 + product/runtime/auths-gateway/src/recipe.rs | 1 + .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 2 +- .../auths-gateway/src/store/acquisition.rs | 2 +- .../src/store/acquisition/content.rs | 69 ++++ 22 files changed, 951 insertions(+), 34 deletions(-) create mode 100644 product/runtime/auths-gateway/src/effect/release.rs diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 2d58d66d6..f103b1332 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -370,6 +370,22 @@ "epic": 3, "case": null }, + { + "code": "gateway.disclosure.binding", + "owner": "effect", + "stage": "compile", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.unsupported-bounds", + "owner": "effect", + "stage": "compile", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.echo-verify.absent", "owner": "echo-verify", diff --git a/bindings/fixtures/gateway/content-journal.json b/bindings/fixtures/gateway/content-journal.json index d39e249c2..4fa18b7ca 100644 --- a/bindings/fixtures/gateway/content-journal.json +++ b/bindings/fixtures/gateway/content-journal.json @@ -1,5 +1,5 @@ { - "schema": "auths.gateway-content-journal-fixture/2", + "schema": "auths.gateway-content-journal-fixture/3", "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", "permanent_source_attempts": 16, "real_http_requests": 15, @@ -427,5 +427,43 @@ "response_version_ok": null } } + ], + "disclosure_compilation": [ + { + "bytes": 25, + "native_release_compiled": true, + "read_authority_refused": true, + "no_provider_prerequisites": true, + "managed_disclosure_count_and_bytes": true, + "acquisition_budget_argument_refused": true, + "substitutions_refused": [ + "channel", + "instance", + "recipient" + ], + "different_partition_refused": true, + "new_operation_retains_capacity_keys": true, + "old_approval_refused": true, + "exact_ack_validates": true, + "scope": "compilation and evidence only; no delivery grant or transport" + }, + { + "bytes": 0, + "native_release_compiled": true, + "read_authority_refused": true, + "no_provider_prerequisites": true, + "managed_disclosure_count_and_bytes": true, + "acquisition_budget_argument_refused": true, + "substitutions_refused": [ + "channel", + "instance", + "recipient" + ], + "different_partition_refused": true, + "new_operation_retains_capacity_keys": true, + "old_approval_refused": true, + "exact_ack_validates": true, + "scope": "compilation and evidence only; no delivery grant or transport" + } ] } \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 98f6b616c..fdc2c1644 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1604,7 +1604,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/13", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/13", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1615,6 +1615,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +disclosure-compilation-contract = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", +] protected-content-retention = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index d0dcf09a3..ee3b846a1 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -886,3 +886,28 @@ fields and substitution from another valid acquisition with identical content. The same pure projection leaf serves compiler-only and durable response paths. Disclosure still needs separate native authority, approval, accounting, recipient channel authentication and the shared final-entry fence. + +## Sealed source and separately authorized disclosure compilation + +`GatewayAttempts::retained_content` reconstructs only private provenance after +normal journal decoding, response projection and constant-time MAC validation. +No public plaintext accessor, provider read or delivery authority is exposed. +`DisclosureTarget` fixes recipient raw-key identity, channel and instance over +that source. Fresh native authorization uses a reserved release tool; exact +approval and entry-time re-verification use the existing bound-effect owner. +The old source proof is history, never a release permission. + +Count and byte units are explicitly disjoint from acquisition and mutation. +Sixteen source-lifetime deliveries share capacity regardless of changed operation +ID, recipient or channel. Empty content remains an actual zero-byte delivery +with one count. Managed policy bounds use the same arithmetic leaf with closed +protocol domains; no provider semantic dispatch or new lifecycle is introduced. +This source/compilation slice does not create a transport or journal grant. +The shared store must next fence retained source facts, current release authority, +recipient authentication and these reservations at the unique delivery grant. + +The content journal fixture constructs both empty and nonempty sources using +real local HTTP, then exercises native release compilation, review, fresh exact +approval, full recompile, managed count/byte declarations, ACK binding and changed +recipient/channel/instance/partition/operation refusals. It establishes no actual +delivery, persistent ACK, isolated-agent or PostgreSQL claim. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index e1cf92f14..e51dfcda8 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1211,6 +1211,34 @@ closure regeneration passed after that correction (one artifact-generation test) engine/CLI/UI/binding journey and P4 adapter/fault/differential/formal/performance evidence remain required. No A01–A22 case closes at this checkpoint. +## Sealed source and disclosure compiler checkpoint + +- Based on `10a548ee`, added journal-only `RetainedContent` provenance with no + public plaintext accessor/deserializer. It requires validated ready content; + rejected/unknown responses remain ineligible and no source read is repeated. +- Native `auths_gateway_disclosure_v1` compilation binds exact source/commitment, + projection/length, raw-key recipient, channel and delivery instance. It verifies + a separate native proof, uses existing complete private review/exact approval + and full fresh recompile, and has no provider credential prerequisites. +- Added disjoint disclosure count/byte declarations, sixteen lifetime deliveries + per source, and existing managed policy arithmetic on the release byte argument. + Changing operation/recipient/channel does not create a new lifetime allowance. + These remain obligations until disclosure journal admission is implemented. +- Required artifact construction executed two exact generators: content journal + and code inventory. Both passed (3.03 seconds execution after compilation). + The journal fixture still performs fifteen real local HTTP reads and adds + separate native release/approval/ACK cases for empty and nonempty content. + Cases cover managed budgets, wrong budget arguments, old read authority, + changed recipient/channel/instance/partition, reused approval, full recompile + and expired approval. No content or private correlations enter the artifact. +- Final content-journal and semantic-closure artifact generators passed together + (two tests, 3.06 seconds). Review includes the source resource arguments and + projection contract, not just opaque commitments. Preserved upstream generated + formal closure commit `622a58fe` by fast-forward before this commit. +- Disclosure entry, authenticated delivery, persistent ACKs and the full P3/P4 + cutover remain incomplete. No acceptance case is closed by compilation. + No broad local gate, formal execution or hosted CI observation was run. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 25f0aa934..5a0796419 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -604,3 +604,21 @@ foreign-source material, old-schema refusal and unchanged replay. Random keys and tags are never emitted into the canonical fixture; only checked facts and public redacted statuses are stored. This is still narrow file-adapter evidence, not PostgreSQL, independent-process or AP070 differential qualification. + +### Retained source to release compiler + +The native disclosure compiler now consumes sealed content provenance loaded +from the acquisition journal. Unlike provider acquisition, it has no credential +prerequisite or provider request. Unlike a mutation, it binds an exact retained +projection to a recipient/channel/instance and uses disclosure count/byte units. +The identical mechanisms remain native verification, selected dependencies, +canonical binding, complete review, exact approval and full recompilation. +Managed policy arithmetic is reused under closed, disjoint protocol domains. + +The source lifetime is the retained acquisition, with sixteen delivery counts +across recipient/channel/operation changes and exact-length byte declarations. +This is a bounded implementation contract, not an inferred provider semantic. +The content journal corpus provides actual source transport plus separate +release compilation/ACK comparisons for empty and nonempty content. Runtime +entry, capacity enforcement and recipient-channel behavior remain unqualified; +no generic workflow/callback or new ledger is introduced by this extraction. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 3d4689d49..f4a5a1e98 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -444,8 +444,39 @@ or new provider permit. Unknown/oversized responses retain their full charges. The public acquisition projection reports only `ready { bytes }` or `rejected { code }`, never the private key, content digest, hiding commitment or plaintext. A ready result grants no disclosure authority. Standalone read-only -installation, AP070 metadata predicates, native disclosure compilation/entry/ -transport and installed CLI/binding journeys remain required for the cutover. +installation, AP070 metadata predicates, disclosure entry/transport and installed +CLI/binding journeys remain required for the cutover. + +The journal's sealed `RetainedContent` is private provenance, with no public +plaintext accessor or deserializer. Loading requires the exact namespace, +operation and partition and revalidates the content response and MAC. It refuses +unknown, absent, projection-rejected, foreign-protocol or corrupt source state. +This historical load does not reuse the source proof or approval as release +authority, and never refetches content. + +The reserved native `auths_gateway_disclosure_v1` action compiles a separate +`auths.gateway-disclosure/1` contract over that provenance. It binds the source, +protected commitment, exact projection/length, raw-key Ed25519 recipient, +channel and delivery instance. The byte ceiling is the exact projected length; +there is no caller plaintext or truncation override. Recipient/channel values +are proposed data until independently authenticated at entry. The full original +connection, recipe, partition and epoch must still match; credential replacement +is not implicitly accepted. Compilation verifies fresh native release authority, +selected dependencies and observer separation; native review, exact approval and +full entry-time recompilation are the existing shared owners. Disclosure has no +provider credential prerequisites and cannot enter acquisition/mutation APIs. + +Disclosure adds the typed `disclosure-count` unit alongside `disclosure-bytes`. +The fixed source allowance is sixteen deliveries, shared across operation IDs, +recipients, channels and instances for the retained acquisition. Each declaration +charges one count and the exact content length; the byte ceiling is sixteen times +that length (one is used only for the nonzero ceiling representation of empty +content). Empty delivery charges zero bytes and one count. Selected native policy +bounds use `maximum_disclosure_bytes`, disjoint disclosure count/byte counter +domains and the existing bounded tightening/window arithmetic. The thirty-four +reservation bound is unchanged. These are compiler obligations, not a claim that +disclosure admission or delivery is already wired. The journal must enforce them +atomically before issuing any one-use delivery capability. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 79d1b2a50..abea07a06 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"84b4568b9770895a308ba7229d530cd1c7034b931691fc9921cfc70e547d0422"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"3c5e1b290d8510625745c7f213663eb7ad69031a3bcdf356e018b7c53f5a2ab9"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"09fa22147093afbfc92cf242981e47c745adf4c380bb5eac028974381c706e2d"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"4f2d7b362d4af22defa7c6943d6e5fdca855519e2c0651732810784bedd30906"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"727ebf1d5a0d3c38f657f306822d4358728cc2f162c2fadcf161570fe62d5289"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"9f2e494a411c02c6cdac6545a2b7cd57300af000c5c7a1ac5f9ebc3b953eaf81"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"cb62117b61ad85a4fef257ce19438c3f6ec5d88830c6dd6d9ea8d226504b2897"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b1b4190a96eacf823fb4dce56fa1125cfcb6c7cea3dc7ce3ca5a34dd0565f161"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"fb5592bd7a45d561ba9431ade8c0b33eac63284f845be43f27646241a8500387"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"da128cacea0fcb8d53e4b70a3756245c66b55564d1a754f630c5522b2abd9108"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"cfe2145ba822adab1e2cd30643ef4762ab8749af3f2d8fc74f359e0646f501b0"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"4e7b4edb55d284d83e9e79282b985bd73f20a3a4d08022c80fdfd82eae09ad52"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"5bd9f47e530918b2df56be8e78082f9ac4f2e25994412b10cbdbecea586be1df"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"4a2a8593fbcfae99c7ba5cd393d4158735046fc8146929bc52bb09e5a982dec9"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"30b7b139b60678da9a3e46343bebbc9d2ef95879079cb1eb830045f11aeb83f7"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"e7f40d8c13210dda9e8a385584e6a055824cdd18a0a459c7eb4d801b79a65e27"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"878ed4b99e743675ee2840233d1df37fd95d5508fd00b290145d499547d7c244"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"639e3cbbd544469aa8851b3a28eb68190c9c8c57cfeef27ede7abc859b7dfe77"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"b3fe20f49b4c5f4183b8fb58125dae144a574bcba658d162cabda6f920294b78"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b681eba832068ba745341f5adfefbfd593f664e3e51b75f666b503854f7a44f2"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"67405e0a730bb6c5cc4687b1c2f50563eeb8aba16f8021bb1f2319c0304216d0"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"6497a4e413d63ceb7cea1ff74788a19af253d03d058ac928f0214865dc42356a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"9f2e494a411c02c6cdac6545a2b7cd57300af000c5c7a1ac5f9ebc3b953eaf81"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"566afcf60efec166f8d0c0558797bd81ba8fbbe242e369a5f3b2701385cc104f"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"fb5592bd7a45d561ba9431ade8c0b33eac63284f845be43f27646241a8500387"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"17193792e50e7daf02e7abde269b618201fdb7e8d30ec843426c174013d955a8"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"cfe2145ba822adab1e2cd30643ef4762ab8749af3f2d8fc74f359e0646f501b0"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"4e7b4edb55d284d83e9e79282b985bd73f20a3a4d08022c80fdfd82eae09ad52"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"4a2a8593fbcfae99c7ba5cd393d4158735046fc8146929bc52bb09e5a982dec9"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"55122c5e16a82cf1fe26c3fc3bc8e1c1289018b8d5edcf4a8cc39ccd64039df7"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"364775ba84918cfc13618e79d347aff6cb591b01ef86e14b986a42d876cdee4b"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"a57e9c323077cc4fd9726a97dd2f2c0c478290e713825a62b990a4358e8e3cd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bounds.rs b/product/runtime/auths-gateway/src/bounds.rs index 8b3b638ab..71c4e5c1b 100644 --- a/product/runtime/auths-gateway/src/bounds.rs +++ b/product/runtime/auths-gateway/src/bounds.rs @@ -702,12 +702,60 @@ pub(crate) fn admit_acquisition_bounds( namespace: &OperatorNamespace, now: u64, ) -> Result, GatewaySubmitResult> { + admit_information_bounds( + proof_cbor, + verified, + namespace, + now, + InformationBudget::Acquisition, + ) +} + +/// Disclosure policy has its own count/byte identities and ceiling argument. +pub(crate) fn admit_disclosure_bounds( + proof_cbor: &[u8], + verified: &VerifiedAction, + namespace: &OperatorNamespace, + now: u64, +) -> Result, GatewaySubmitResult> { + admit_information_bounds( + proof_cbor, + verified, + namespace, + now, + InformationBudget::Disclosure, + ) +} + +enum InformationBudget { + Acquisition, + Disclosure, +} + +fn admit_information_bounds( + proof_cbor: &[u8], + verified: &VerifiedAction, + namespace: &OperatorNamespace, + now: u64, + protocol: InformationBudget, +) -> Result, GatewaySubmitResult> { + let (argument, count_domain, bytes_domain, refusal) = match protocol { + InformationBudget::Disclosure => ( + "maximum_disclosure_bytes", + b"auths.gateway-disclosure-policy-count/1\0".as_slice(), + b"auths.gateway-disclosure-policy-bytes/1\0".as_slice(), + "gateway.disclosure.unsupported-bounds", + ), + InformationBudget::Acquisition => ( + "maximum_response_bytes", + b"auths.gateway-read-policy-count/1\0".as_slice(), + b"auths.gateway-read-policy-bytes/1\0".as_slice(), + "gateway.acquisition.unsupported-bounds", + ), + }; let links = selected_bound_links(proof_cbor, verified)?; - if links - .iter() - .any(|link| link.policy.argument() != "maximum_response_bytes") - { - return Err(not_entered("gateway.acquisition.unsupported-bounds")); + if links.iter().any(|link| link.policy.argument() != argument) { + return Err(not_entered(refusal)); } let mut bound = admit_policy_links(links, verified.canonical_action(), namespace, None, now) .map_err(not_entered)?; @@ -721,10 +769,10 @@ pub(crate) fn admit_acquisition_bounds( hash.finalize().into() }; for counter in &mut bound.counts { - counter.key = rekey(b"auths.gateway-read-policy-count/1\0", &counter.key); + counter.key = rekey(count_domain, &counter.key); } for counter in &mut bound.sums { - counter.key = rekey(b"auths.gateway-read-policy-bytes/1\0", &counter.key); + counter.key = rekey(bytes_domain, &counter.key); } bound.counts.sort_by_key(|counter| counter.key); bound.sums.sort_by_key(|counter| counter.key); diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 8dfcd4787..8c816305f 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -23,6 +23,8 @@ mod candidate; mod content; pub(crate) use content::ContentPlan; pub use content::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; +mod release; +pub use release::{DISCLOSURE_TOOL, DisclosureTarget, compile_disclosure}; mod disclosure; pub use disclosure::{ AuthenticatedDisclosureAcknowledgement, DISCLOSURE_ACK_SCHEMA, DisclosureAcknowledgement, @@ -414,6 +416,7 @@ enum Unit { MutationSum, AcquisitionCount, ResponseBytes, + DisclosureCount, DisclosureBytes, } @@ -663,12 +666,15 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { reservation.unit, Unit::AcquisitionCount | Unit::ResponseBytes ), - Protocol::Disclosure { .. } => reservation.unit == Unit::DisclosureBytes, + Protocol::Disclosure { .. } => matches!( + reservation.unit, + Unit::DisclosureCount | Unit::DisclosureBytes + ), }; if !unit_allowed || (matches!( reservation.unit, - Unit::MutationCount | Unit::AcquisitionCount + Unit::MutationCount | Unit::AcquisitionCount | Unit::DisclosureCount ) && reservation.amount != 1) { return Err(EffectBindingError::Invalid); @@ -698,11 +704,12 @@ fn validate(wire: &BindingWire) -> Result<(), EffectBindingError> { Ok(()) } -/// Closed protocol-specific compiler output. Neither alternative is transport +/// Closed protocol-specific compiler output. None of these alternatives is transport /// authority, and a mutation-only admission path must refuse an acquisition. enum CompiledEffect { Mutation(Box), Acquisition(Box), + Disclosure(Box), } struct VerifiedMutation { @@ -809,13 +816,13 @@ impl BoundEffect { } /// Returns the exact noncredential mutation request for private review, - /// or `None` for acquisition. This may contain private content; do not log it. - /// Use the shared private review to render either protocol completely. + /// or `None` for acquisition/disclosure. This may contain private content; do not log it. + /// Use the shared private review to render every protocol completely. #[must_use] pub fn private_request(&self) -> Option<&ClosedProviderRequest> { match &self.command { CompiledEffect::Mutation(mutation) => Some(&mutation.command.request), - CompiledEffect::Acquisition(_) => None, + CompiledEffect::Acquisition(_) | CompiledEffect::Disclosure(_) => None, } } @@ -845,6 +852,7 @@ impl BoundEffect { "connection_contract": self.connection.contract().as_str(), }), semantic: match &self.command { + CompiledEffect::Disclosure(_) => self.review.clone(), CompiledEffect::Mutation(mutation) => { let mut review = self.review.clone(); review["prerequisite_acquisitions"] = @@ -863,6 +871,7 @@ impl BoundEffect { effect_id_hex: hex::encode(self.binding.id().as_bytes()), binding_canonical, native: match &self.command { + CompiledEffect::Disclosure(command) => command.private_review(), CompiledEffect::Mutation(mutation) => { serde_json::to_value(crate::engine::review_command(&mutation.command)?) .map_err(|_| not_entered("gateway.effect.invalid-binding"))? @@ -1097,7 +1106,7 @@ impl ApprovedEffect { pub(crate) fn command(&self) -> Option<&VerifiedCommand> { match &self.effect.command { CompiledEffect::Mutation(mutation) => Some(&mutation.command), - CompiledEffect::Acquisition(_) => None, + CompiledEffect::Acquisition(_) | CompiledEffect::Disclosure(_) => None, } } @@ -1107,7 +1116,7 @@ impl ApprovedEffect { acquisition::AcquisitionTarget::Content(target) => Some(target), _ => None, }, - CompiledEffect::Mutation(_) => None, + CompiledEffect::Mutation(_) | CompiledEffect::Disclosure(_) => None, } } @@ -1124,7 +1133,7 @@ impl ApprovedEffect { acquisition::AcquisitionTarget::Recovery(_) | acquisition::AcquisitionTarget::Content(_) => None, }, - CompiledEffect::Mutation(_) => None, + CompiledEffect::Mutation(_) | CompiledEffect::Disclosure(_) => None, } } @@ -1136,7 +1145,7 @@ impl ApprovedEffect { pub(crate) fn recovery_target(&self) -> Option<&RecoveryReadTarget> { match &self.effect.command { - CompiledEffect::Mutation(_) => None, + CompiledEffect::Mutation(_) | CompiledEffect::Disclosure(_) => None, CompiledEffect::Acquisition(command) => match &command.target { acquisition::AcquisitionTarget::Recovery(target) => Some(target), acquisition::AcquisitionTarget::Candidate(_) @@ -1147,7 +1156,7 @@ impl ApprovedEffect { pub(crate) fn acquisition_bound(&self) -> Option<&crate::bounds::BoundAdmission> { match &self.effect.command { - CompiledEffect::Mutation(_) => None, + CompiledEffect::Mutation(_) | CompiledEffect::Disclosure(_) => None, CompiledEffect::Acquisition(command) => command.bound.as_ref(), } } @@ -1155,7 +1164,9 @@ impl ApprovedEffect { pub(crate) fn recovery_plan(&self) -> Result { match &self.effect.command { CompiledEffect::Acquisition(command) => command.journal_plan(), - CompiledEffect::Mutation(_) => Err(EffectBindingError::Invalid), + CompiledEffect::Mutation(_) | CompiledEffect::Disclosure(_) => { + Err(EffectBindingError::Invalid) + } } } @@ -1163,6 +1174,7 @@ impl ApprovedEffect { match &self.effect.command { CompiledEffect::Mutation(command) => &command.prerequisites, CompiledEffect::Acquisition(command) => &command.prerequisites, + CompiledEffect::Disclosure(command) => &command.prerequisites, } } @@ -1183,6 +1195,7 @@ impl ApprovedEffect { request_bytes(&mutation.command.request, &mutation.prerequisites)? } CompiledEffect::Acquisition(command) => command.request_bytes()?, + CompiledEffect::Disclosure(_) => return Err(EffectBindingError::Invalid), }; let plan = PrerequisitePlan::new(self.effect.binding(), index, transport)?; Ok((plan, read.clone())) @@ -1228,6 +1241,13 @@ impl ApprovedEffect { self.validate_approval(&installed.approver, now) .map_err(|_| not_entered("gateway.effect.approval"))?; let fresh = match &self.effect.command { + CompiledEffect::Disclosure(command) => compile_disclosure( + installed, + &command.target, + now, + &self.effect.proof, + &self.effect.action, + )?, CompiledEffect::Mutation(_) => { compile_mutation_effect(installed, now, &self.effect.proof, &self.effect.action)? } diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index d28713024..135d4f45a 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -317,6 +317,10 @@ impl ContentPlan { Ok(contract) } + pub(crate) fn private_review(&self) -> Result { + self.witness() + } + pub(crate) fn projection( &self, ) -> Result { diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index a6a9925c7..c1645dee4 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -107,6 +107,11 @@ impl Serialize for ClosedPrerequisiteRead { } impl Prerequisites { + /// Disclosure reads only retained evidence and never leases a credential. + pub(super) const fn disclosure() -> Self { + Self(Vec::new()) + } + pub(super) fn kinds(&self) -> impl Iterator + '_ { self.0.iter().map(|declaration| declaration.purpose.kind()) } diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs new file mode 100644 index 000000000..97e03fee3 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -0,0 +1,274 @@ +//! Separately verified disclosure compilation over sealed retained provenance. +//! No constructor in this module releases bytes or authenticates a live channel. +use super::*; +use auths_profile_api::ActionProfile as _; +use auths_profile_mcp::{McpProfile, McpToolCall}; +use auths_raw_key::{RawKeyDescriptor, RawKeyType}; +use serde_json::{Value, json}; + +/// Reserved release action; it cannot name a recipe's provider mutation. +pub const DISCLOSURE_TOOL: &str = "auths_gateway_disclosure_v1"; +const CONTRACT: &str = "auths.gateway-disclosure/1"; +const MAX_DELIVERIES: u64 = 16; + +/// Exact private delivery description derived from validated journal content. +/// A recipient key and channel commitment are proposed data, not proof that a +/// peer is authenticated. Live authentication belongs at the entry boundary. +#[derive(Clone)] +pub struct DisclosureTarget { + content: crate::RetainedContent, + recipient: String, + recipient_key: [u8; 32], + channel: [u8; 32], + instance: [u8; 32], +} + +impl fmt::Debug for DisclosureTarget { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("DisclosureTarget { private: [redacted] }") + } +} + +impl DisclosureTarget { + /// Proposes delivery of the exact retained projection, with no truncation or + /// caller-supplied bytes. The byte ceiling is its actual retained length. + /// This neither authenticates a recipient nor reuses source read authority. + /// + /// # Errors + /// Refuses a weak/invalid recipient key or unsupported source scope. + pub fn new( + content: crate::RetainedContent, + recipient_key: [u8; 32], + channel: [u8; 32], + delivery_instance: [u8; 32], + ) -> Result { + let key = + VerifyingKey::from_bytes(&recipient_key).map_err(|_| EffectBindingError::Invalid)?; + if key.is_weak() || content.bytes > 65_536 || content.source.wire.scope != Scope::Unscoped { + return Err(EffectBindingError::Invalid); + } + let recipient = RawKeyDescriptor::new(RawKeyType::Ed25519, recipient_key.to_vec()) + .map_err(|_| EffectBindingError::Invalid)? + .principal() + .map_err(|_| EffectBindingError::Invalid)? + .as_str() + .to_owned(); + Ok(Self { + content, + recipient, + recipient_key, + channel, + instance: delivery_instance, + }) + } + + fn contract(&self) -> Value { + json!({"schema": CONTRACT, + "source_effect": hex::encode(self.content.source.id().as_bytes()), + "source_operation": self.content.source.wire.operation, + "source_contract": self.content.review, + "protected_content": hex::encode(self.content.commitment), + "projection": hex::encode(self.content.projection), + "recipient": self.recipient, "recipient_key": hex::encode(self.recipient_key), + "channel": hex::encode(self.channel), "delivery_instance": hex::encode(self.instance), + "maximum_disclosure_bytes": self.content.bytes, + "maximum_source_deliveries": MAX_DELIVERIES, + "acknowledgement": DISCLOSURE_ACK_SCHEMA}) + } + + /// Authors the exact native release call on a private authoring channel. + /// A fresh proof and exact approval must authorize this entire description. + /// + /// # Errors + /// Refuses another recipe/namespace, the source operation ID or encoding. + pub fn authorization_call( + &self, + recipe: &CompiledRecipe, + operation: &LogicalOperationId, + ) -> Result { + let source = &self.content.source.wire; + if source.recipe != *recipe.digest() + || source.namespace != recipe.namespace().as_str() + || source.operation == operation.as_str() + { + return Err(EffectBindingError::Invalid); + } + let arguments = json!({"operation_id": operation.as_str(), + "operator_namespace": recipe.namespace().as_str(), "recipe_digest": recipe.digest_hex(), + "disclosure_contract": hex::encode(commitment(CONTRACT, &canonical(&self.contract())?)?), + "source_effect": hex::encode(self.content.source.id().as_bytes()), + "source_operation": source.operation, "recipient": self.recipient, + "channel": hex::encode(self.channel), "delivery_instance": hex::encode(self.instance), + "maximum_disclosure_bytes": self.content.bytes}) + .as_object().cloned().ok_or(EffectBindingError::Invalid)?; + McpToolCall::new(recipe.service(), DISCLOSURE_TOOL, arguments) + .map_err(|_| EffectBindingError::Invalid) + } + + fn validate_installation( + &self, + installed: &EffectInstallation<'_>, + ) -> Result<(), EffectBindingError> { + GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) + .map_err(|_| EffectBindingError::Invalid)?; + let source = &self.content.source.wire; + let connection = Zeroizing::new( + installed + .connection + .to_canonical_cbor() + .map_err(|_| EffectBindingError::Invalid)?, + ); + if source.partition != installed.partition + || source.epoch != installed.epoch + || source.recipe != *installed.recipe.digest() + || source.namespace != installed.recipe.namespace().as_str() + || source.connection != commitment("auths.effect-installation/1", &connection)? + || source.credential_generation != installed.connection.credential_generation().get() + { + return Err(EffectBindingError::Invalid); + } + Ok(()) + } + + fn protocol(&self) -> Protocol { + Protocol::Disclosure { + source_effect: *self.content.source.id().as_bytes(), + protected_content: self.content.commitment, + recipient: self.recipient.clone(), + channel: self.channel, + delivery_instance: self.instance, + projection: self.content.projection, + maximum_bytes: self.content.bytes, + } + } + + fn reservations(&self) -> Result, EffectBindingError> { + let source = self.content.source.id(); + let mut reservations = vec![ + Reservation { + key: commitment("auths.disclosure-source-count/1", source.as_bytes())?, + unit: Unit::DisclosureCount, + amount: 1, + ceiling: MAX_DELIVERIES, + window: ReservationWindow::SourceLifetime, + }, + Reservation { + key: commitment("auths.disclosure-source-bytes/1", source.as_bytes())?, + unit: Unit::DisclosureBytes, + amount: self.content.bytes, + // Empty delivery still spends one invocation; its byte amount is zero. + ceiling: MAX_DELIVERIES * self.content.bytes.max(1), + window: ReservationWindow::SourceLifetime, + }, + ]; + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + Ok(reservations) + } +} + +pub(super) struct VerifiedDisclosure { + pub(super) target: DisclosureTarget, + pub(super) prerequisites: Prerequisites, + #[cfg(unix)] + actors: Vec, + #[cfg(unix)] + action_commitment: [u8; 32], + #[cfg(unix)] + arguments: serde_json::Map, +} + +impl VerifiedDisclosure { + #[cfg(unix)] + pub(super) fn private_review(&self) -> Value { + json!({"actors": self.actors.iter().map(auths_model::PrincipalId::as_str).collect::>(), "action_commitment": hex::encode(self.action_commitment), + "arguments": self.arguments, "disclosure": self.target.contract()}) + } +} + +/// Compiles separately verified release authority over retained content using +/// the common binding, native review and exact approval model. Performs no +/// credential access, provider read, byte release or live peer authentication. +/// +/// # Errors +/// Refuses invalid native authority, a changed source/installation, unsupported +/// policy arguments, observer overlap or any substituted delivery dimension. +pub fn compile_disclosure( + installed: &EffectInstallation<'_>, + target: &DisclosureTarget, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + let invalid = || not_entered("gateway.disclosure.binding"); + target + .validate_installation(installed) + .map_err(|_| invalid())?; + let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; + let verified = sealed.action().ok_or_else(invalid)?; + let command = McpProfile + .decode_verified(verified) + .map_err(|_| invalid())?; + let operation = command + .arguments() + .get("operation_id") + .and_then(Value::as_str) + .and_then(|value| LogicalOperationId::parse(value).ok()) + .ok_or_else(invalid)?; + if command.call() + != &target + .authorization_call(installed.recipe, &operation) + .map_err(|_| invalid())? + { + return Err(invalid()); + } + let bound = + crate::bounds::admit_disclosure_bounds(proof, verified, installed.recipe.namespace(), now)?; + crate::separation::check_proof_observers(proof, verified).map_err(not_entered)?; + #[cfg(unix)] + let branches = crate::bounds::authorized_branches(proof, verified).map_err(not_entered)?; + let canonical_action = + auths_codec::encode_canonical_action(verified.canonical_action()).map_err(|_| invalid())?; + let action_commitment = + commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; + let authority = + native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?; + let mut reservations = target.reservations().map_err(|_| invalid())?; + reservations.extend(managed_reservations( + bound.as_ref(), + Unit::DisclosureCount, + Unit::DisclosureBytes, + )); + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + let binding = acquisition::build_binding( + installed, + &operation, + action_commitment, + authority, + target.protocol(), + reservations, + )?; + let effect = BoundEffect { + review: json!({"contract": CONTRACT, "disclosure": target.contract(), + "consequences": "Release the exact retained projection to this recipient and channel once. A grant makes delivery possible; only an exact authenticated ACK records the recipient assertion. Lost delivery or ACK never authorizes redelivery or refund."}), + binding, + command: CompiledEffect::Disclosure(Box::new(VerifiedDisclosure { + target: target.clone(), + prerequisites: Prerequisites::disclosure(), + #[cfg(unix)] + actors: branches.actors, + #[cfg(unix)] + action_commitment, + #[cfg(unix)] + arguments: command.arguments().clone(), + })), + connection: installed.connection.clone(), + proof: Zeroizing::new(proof.to_vec()), + action: Zeroizing::new(action.to_vec()), + }; + #[cfg(unix)] + effect + .private_review()? + .to_private_bytes() + .map_err(|_| invalid())?; + Ok(effect) +} diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index a89db7f6c..f18f6edbb 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -457,8 +457,8 @@ async fn native_content_journal_fixture_is_current() { let root = signer(h::ROOT_SEED); let reader = signer(0x33); let observer = signer(h::OBSERVER_SEED); - let key = SigningKey::from_bytes(&[29; 32]); - let public = key.verifying_key().to_bytes(); + let approval_key = SigningKey::from_bytes(&[29; 32]); + let public = approval_key.verifying_key().to_bytes(); let policy = EffectPolicy::new("synthetic-content-journal".to_owned(), 1, public).expect("policy"); let (source, lock) = h::recipe_sources(&json!({}), &Value::Null).expect("source"); @@ -532,7 +532,7 @@ async fn native_content_journal_fixture_is_current() { compile_content_acquisition(&installed, &target, NOW, &signed.proof, &signed.action) .expect("effect"); let request = effect.approval_request(NOW, NOW + 60).expect("request"); - let signature = key + let signature = approval_key .sign(&request.signing_message().expect("message")) .to_bytes(); Arc::new( @@ -622,6 +622,7 @@ async fn native_content_journal_fixture_is_current() { .expect("lease"); let mut histories = vec![]; let mut first_protected = Value::Null; + let mut disclosures = Vec::new(); for index in 0..17 { let approved = approve(&format!("content-journal-{index}")); let claim = attempts @@ -810,6 +811,27 @@ async fn native_content_journal_fixture_is_current() { _ => unreachable!(), }; assert_eq!(projection, expected_projection); + let retained_source = attempts + .retained_content( + recipe.namespace(), + &LogicalOperationId::parse(&format!("content-journal-{index}")).expect("operation"), + ) + .await; + if matches!(index, 0 | 8 | 9 | 10 | 13) { + let retained_source = retained_source.expect("validated source"); + assert_eq!(retained_source.bytes, expected_body.len() as u64); + if matches!(index, 0 | 9) { + disclosures.push(disclosure_compilation_cases( + retained_source, + &recipe, + &record, + &policy, + &approval_key, + )); + } + } else { + assert!(retained_source.is_err(), "rejected/unknown source {index}"); + } if index == 0 { first_protected = phase["content"].clone(); for pointer in [ @@ -914,11 +936,11 @@ async fn native_content_journal_fixture_is_current() { .expect("source match") .0 ); - let fixture = json!({"schema": "auths.gateway-content-journal-fixture/2", + let fixture = json!({"schema": "auths.gateway-content-journal-fixture/3", "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", "permanent_source_attempts": 16, "real_http_requests": 15, "protected_content_mutations_refused": true, "same_content_foreign_source_refused": true, - "history": histories}); + "history": histories, "disclosure_compilation": disclosures}); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/content-journal.json"); let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); @@ -927,3 +949,315 @@ async fn native_content_journal_fixture_is_current() { } assert_eq!(std::fs::read(&path).expect("fixture"), bytes); } + +/// The source was loaded from a validated, real-HTTP content journal above. +/// All values written to the fixture are public case results, never private +/// content, MACs, source correlations, signed proof bytes or review material. +#[allow( + clippy::too_many_lines, + reason = "one native disclosure compilation corpus over validated retained content" +)] +fn disclosure_compilation_cases( + retained: crate::RetainedContent, + recipe: &CompiledRecipe, + connection: &ConnectionRecord, + policy: &EffectPolicy, + approval_key: &SigningKey, +) -> Value { + use crate::effect::{DisclosureTarget, compile_disclosure}; + let root = signer(h::ROOT_SEED); + let observer = signer(h::OBSERVER_SEED); + let releaser = signer(0x44); + let recipient = SigningKey::from_bytes(&[51; 32]); + let recipient_key = recipient.verifying_key().to_bytes(); + let target = DisclosureTarget::new(retained.clone(), recipient_key, [20; 32], [21; 32]) + .expect("delivery target"); + assert_eq!( + format!("{retained:?}"), + "RetainedContent { private: [redacted] }" + ); + assert_eq!( + format!("{target:?}"), + "DisclosureTarget { private: [redacted] }" + ); + let operation = LogicalOperationId::parse("disclosure-1").expect("operation"); + let call = target + .authorization_call(recipe, &operation) + .expect("release call"); + let trust = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("release trust"); + let grant = h::grant_for_tool( + &root, + &releaser.principal, + None, + window(NOW - 3600, NOW + 3600), + &call, + ) + .expect("release grant"); + let signed = submission_for_call(&root, &releaser, &grant, &call, &[]); + let installed = policy.installation( + recipe, + &trust, + connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let limit = retained.bytes.max(1); + let budget = crate::ArgumentCeilingPolicy::new("maximum_disclosure_bytes", limit, 3600, 2) + .expect("budget") + .with_sum(limit * 2, None) + .expect("byte budget"); + let budget_grant = super::read_budget_tests::read_grant(&root, &releaser, &call, &budget); + let budget_signed = submission_for_call(&root, &releaser, &budget_grant, &call, &[]); + let budget_effect = compile_disclosure( + &installed, + &target, + NOW, + &budget_signed.proof, + &budget_signed.action, + ) + .expect("budget effect"); + let budget_wire: Value = serde_json::from_slice( + &budget_effect + .binding() + .to_private_bytes() + .expect("budget bytes"), + ) + .expect("budget JSON"); + let fixed: Vec<_> = budget_wire["reservations"] + .as_array() + .expect("reservations") + .iter() + .filter(|r| r["window"]["kind"] == "fixed") + .collect(); + assert_eq!(fixed.len(), 2); + assert!( + fixed + .iter() + .any(|r| r["unit"] == "disclosure-count" && r["amount"] == 1 && r["ceiling"] == 2) + ); + assert!(fixed.iter().any(|r| r["unit"] == "disclosure-bytes" + && r["amount"] == retained.bytes + && r["ceiling"] == limit * 2)); + let wrong_budget = crate::ArgumentCeilingPolicy::new("maximum_response_bytes", limit, 3600, 2) + .expect("wrong budget"); + let wrong_grant = super::read_budget_tests::read_grant(&root, &releaser, &call, &wrong_budget); + let wrong_signed = submission_for_call(&root, &releaser, &wrong_grant, &call, &[]); + assert!( + compile_disclosure( + &installed, + &target, + NOW, + &wrong_signed.proof, + &wrong_signed.action + ) + .is_err() + ); + let bound = compile_disclosure(&installed, &target, NOW, &signed.proof, &signed.action) + .expect("native release"); + assert!(bound.private_request().is_none()); + let bytes = bound.binding().to_private_bytes().expect("binding"); + let binding: Value = serde_json::from_slice(&bytes).expect("binding JSON"); + assert_eq!(binding["protocol"]["maximum_bytes"], retained.bytes); + assert_eq!( + binding["protocol"]["source_effect"], + json!(retained.source.id().as_bytes()) + ); + let reservations = binding["reservations"].as_array().expect("reservations"); + assert_eq!(reservations.len(), 2); + assert!( + reservations + .iter() + .any(|r| r["unit"] == "disclosure-count" && r["amount"] == 1 && r["ceiling"] == 16) + ); + assert!( + reservations + .iter() + .any(|r| r["unit"] == "disclosure-bytes" && r["amount"] == retained.bytes) + ); + let review = bound + .private_review() + .expect("review") + .render_literal(crate::effect::LITERAL_REVIEW_RENDERER) + .expect("render"); + + assert!(review.contains("maximum_disclosure_bytes")); + assert!(review.contains("delivery_instance")); + assert!(review.contains("resource_arguments")); + assert!(review.contains(RECORD)); + assert!(review.contains("projection")); + assert!(!review.contains("PRIVATE-SYNTHETIC-CONTENT")); + let request = bound + .approval_request(NOW, NOW + 60) + .expect("approval request"); + let approval = request.clone().with_signature( + approval_key + .sign(&request.signing_message().expect("message")) + .to_bytes(), + ); + let approved = bound + .approve( + approval.clone(), + &approval_key.verifying_key().to_bytes(), + NOW, + ) + .expect("exact approval"); + approved + .validate_for_entry(&installed, NOW) + .expect("fresh full recompile"); + assert!(approved.validate_for_entry(&installed, NOW + 61).is_err()); + assert!(approved.command().is_none()); + assert!(approved.content_target().is_none()); + assert!(approved.recovery_target().is_none()); + assert!(approved.prerequisite_plans().expect("no reads").is_empty()); + assert!(approved.content_plan().is_err()); + assert!(approved.recovery_plan().is_err()); + let ack_request = crate::effect::DisclosureAcknowledgementRequest::for_delivery( + approved.effect().binding(), + retained.bytes, + recipient_key, + ) + .expect("ACK statement"); + let ack = ack_request.clone().with_signature( + recipient + .sign(&ack_request.signing_message().expect("message")) + .to_bytes(), + ); + assert!( + ack.verify(approved.effect().binding(), retained.bytes) + .is_ok() + ); + assert!( + ack.verify(approved.effect().binding(), retained.bytes + 1) + .is_err() + ); + let mut refused = Vec::new(); + for (name, changed) in [ + ( + "channel", + DisclosureTarget::new(retained.clone(), recipient_key, [22; 32], [21; 32]) + .expect("target"), + ), + ( + "instance", + DisclosureTarget::new(retained.clone(), recipient_key, [20; 32], [22; 32]) + .expect("target"), + ), + ( + "recipient", + DisclosureTarget::new( + retained.clone(), + SigningKey::from_bytes(&[52; 32]).verifying_key().to_bytes(), + [20; 32], + [21; 32], + ) + .expect("target"), + ), + ] { + assert!( + compile_disclosure(&installed, &changed, NOW, &signed.proof, &signed.action).is_err() + ); + let changed_call = changed + .authorization_call(recipe, &operation) + .expect("call"); + let changed_signed = submission_for_call(&root, &releaser, &grant, &changed_call, &[]); + let changed_bound = compile_disclosure( + &installed, + &changed, + NOW, + &changed_signed.proof, + &changed_signed.action, + ) + .expect("new native action"); + assert_ne!( + changed_bound.binding().id(), + approved.effect().binding().id() + ); + assert!(ack.verify(changed_bound.binding(), retained.bytes).is_err()); + assert!( + changed_bound + .approve( + approval.clone(), + &approval_key.verifying_key().to_bytes(), + NOW + ) + .is_err() + ); + refused.push(name); + } + let new_call = target + .authorization_call( + recipe, + &LogicalOperationId::parse("disclosure-2").expect("operation"), + ) + .expect("call"); + let new_signed = submission_for_call(&root, &releaser, &grant, &new_call, &[]); + let new_bound = compile_disclosure( + &installed, + &target, + NOW, + &new_signed.proof, + &new_signed.action, + ) + .expect("new effect"); + let new_bytes = new_bound.binding().to_private_bytes().expect("binding"); + let new_binding: Value = serde_json::from_slice(&new_bytes).expect("JSON"); + assert_eq!(new_binding["reservations"], binding["reservations"]); + assert!( + new_bound + .approve(approval, &approval_key.verifying_key().to_bytes(), NOW) + .is_err() + ); + let wrong_partition = EffectPolicy::new( + "different-partition".to_owned(), + 1, + approval_key.verifying_key().to_bytes(), + ) + .expect("policy"); + let wrong_install = wrong_partition.installation( + recipe, + &trust, + connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + assert!( + compile_disclosure(&wrong_install, &target, NOW, &signed.proof, &signed.action).is_err() + ); + let read = ContentReadTarget::new( + recipe, + connection, + json!({"record_id": RECORD}) + .as_object() + .expect("args") + .clone(), + ) + .expect("read"); + let read_call = read + .authorization_call(recipe, &operation) + .expect("read call"); + let read_grant = h::grant_for_tool( + &root, + &releaser.principal, + None, + window(NOW - 3600, NOW + 3600), + &read_call, + ) + .expect("read grant"); + let read_signed = submission_for_call(&root, &releaser, &read_grant, &read_call, &[]); + assert!( + compile_disclosure( + &installed, + &target, + NOW, + &read_signed.proof, + &read_signed.action + ) + .is_err() + ); + json!({"bytes": retained.bytes, "native_release_compiled": true, + "read_authority_refused": true, "no_provider_prerequisites": true, + "managed_disclosure_count_and_bytes": true, "acquisition_budget_argument_refused": true, + "substitutions_refused": refused, "different_partition_refused": true, + "new_operation_retains_capacity_keys": true, "old_approval_refused": true, + "exact_ack_validates": true, "scope": "compilation and evidence only; no delivery grant or transport"}) +} diff --git a/product/runtime/auths-gateway/src/effect_read_budget_tests.rs b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs index 3853441a0..dfdb8c91e 100644 --- a/product/runtime/auths-gateway/src/effect_read_budget_tests.rs +++ b/product/runtime/auths-gateway/src/effect_read_budget_tests.rs @@ -8,7 +8,7 @@ use crate::{ArgumentCeilingPolicy, GatewayAttemptStore}; use base64ct::Base64; use std::sync::Arc; -fn read_grant( +pub(super) fn read_grant( root: &Signer, reader: &Signer, call: &McpToolCall, diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index c6a456861..273520b21 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -143,7 +143,7 @@ pub use store::{ GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, - RecoverySourceFacts, ReservedAcquisition, check_private_directory, + RecoverySourceFacts, ReservedAcquisition, RetainedContent, check_private_directory, check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 92887e4b4..bc6b346bc 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,8 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.disclosure.binding effect compile new 74 -", + "gateway.disclosure.unsupported-bounds effect compile new 74 -", "gateway.content.response-version ContentProjectionError response new 74 -", "gateway.content.response-encoding ContentProjectionError response new 74 -", "gateway.content.response-status ContentProjectionError projection new 74 -", @@ -182,6 +184,7 @@ fn expected_codes(value: &Value, found: &mut BTreeSet) { /// Code families the revision introduced whole: every code under one of /// these prefixes that the crate defines must be in the inventory. const REVISION_FAMILIES: &[&str] = &[ + "gateway.disclosure.", "gateway.acquisition.", "gateway.account-scope.", "gateway.echo-verify.", diff --git a/product/runtime/auths-gateway/src/recipe.rs b/product/runtime/auths-gateway/src/recipe.rs index b3d50359d..8cc7c2084 100644 --- a/product/runtime/auths-gateway/src/recipe.rs +++ b/product/runtime/auths-gateway/src/recipe.rs @@ -545,6 +545,7 @@ impl CompiledRecipe { crate::effect::RECOVERY_READ_TOOL | crate::effect::CANDIDATE_CHECK_TOOL | crate::effect::CONTENT_READ_TOOL + | crate::effect::DISCLOSURE_TOOL ) { return Err(GatewayRecipeError::InvalidSource); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 218fa1fbd..5b5e00048 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "68ceff77de7f7fddd4d629519f7b8770a8f43d77670def4de2ee2bcc1458c19a"; + "044f0ca02024273f4a6b8c897a3e9787c2f567e48a2cc3080413b15c9523fc4e"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index f68704b82..a8436d0b9 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -711,7 +711,7 @@ mod capacity; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, ContentProjectionStatus, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, - RecoverySourceFacts, ReservedAcquisition, + RecoverySourceFacts, ReservedAcquisition, RetainedContent, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 44ab7c056..db0da7f8c 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -8,8 +8,8 @@ use crate::effect::{ }; mod content; -pub use content::ContentProjectionStatus; use content::ContentResult; +pub use content::{ContentProjectionStatus, RetainedContent}; mod candidate; pub use candidate::CandidatePublication; mod recovery; diff --git a/product/runtime/auths-gateway/src/store/acquisition/content.rs b/product/runtime/auths-gateway/src/store/acquisition/content.rs index 27a0149ba..3b915178b 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/content.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/content.rs @@ -18,6 +18,75 @@ pub enum ContentProjectionStatus { Rejected { code: String }, } +/// Validated private acquisition provenance. Only the journal can construct +/// this value. It carries no plaintext accessor, native release authority, +/// approval or delivery capability, and cannot be deserialized. +#[derive(Clone)] +pub struct RetainedContent { + pub(crate) source: EffectBinding, + pub(crate) commitment: [u8; 32], + pub(crate) projection: [u8; 32], + pub(crate) bytes: u64, + pub(crate) review: serde_json::Value, +} + +impl std::fmt::Debug for RetainedContent { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("RetainedContent { private: [redacted] }") + } +} + +impl GatewayAttempts { + /// Loads protected content provenance from this partition's authoritative + /// acquisition journal. Historical source authority is not re-used as + /// current release authority. This does not fetch or disclose any bytes. + /// + /// # Errors + /// Refuses absent, incomplete, rejected or corrupt content, other protocols + /// and partition mismatches. All retained projection and MAC checks apply. + pub async fn retained_content( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + ) -> Result { + let key = self.key(namespace, operation)?; + let store = Arc::clone(&self.store); + let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let bytes = Zeroizing::new(bytes); + let record: Record = decode_as(&bytes)?; + let source = record.validate_header()?; + if !self.policy.contains(&source) + || source.journal_identity().0 != namespace.as_str() + || source.journal_identity().1 != operation.as_str() + { + return Err(GatewayAttemptError::BindingConflict); + } + let AcquisitionPlan::Content(plan) = &record.state.plan else { + return Err(GatewayAttemptError::InvalidTransition); + }; + let AcquisitionPhase::ContentResponseRecorded { + content: ContentResult::Ready(content), + .. + } = &record.state.phase + else { + return Err(GatewayAttemptError::InvalidTransition); + }; + Ok(RetainedContent { + source, + commitment: content.commitment, + projection: plan + .projection_commitment() + .map_err(|_| GatewayAttemptError::Corrupt)?, + bytes: content.bytes, + review: plan + .private_review() + .map_err(|_| GatewayAttemptError::Corrupt)?, + }) + } +} + #[derive(Clone, Deserialize, Serialize)] #[serde( tag = "kind", From 15d0bb8d47ab38d6a8be94dcb3901eac3d199a19 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 21:35:30 +0000 Subject: [PATCH 052/136] refactor(gateway): share bounded source allocation mechanics --- ...017-bound-effect-and-recovery-ownership.md | 12 +++ docs/plans/0074-implementation-status.md | 17 ++++ .../0009-bound-effect-and-recovery.md | 7 ++ .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 5 +- .../auths-gateway/src/effect/acquisition.rs | 44 ++------- .../auths-gateway/src/effect/candidate.rs | 12 +-- .../auths-gateway/src/effect/capacity.rs | 33 +++++++ .../auths-gateway/src/effect/content.rs | 10 +- .../auths-gateway/src/effect/prerequisite.rs | 6 +- .../auths-gateway/src/effect/release.rs | 33 +++---- .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/src/store/acquisition.rs | 94 +++++-------------- .../src/store/acquisition/candidate.rs | 6 +- .../src/store/acquisition/recovery.rs | 5 +- .../auths-gateway/src/store/capacity.rs | 67 +++++++++++++ 16 files changed, 203 insertions(+), 152 deletions(-) create mode 100644 product/runtime/auths-gateway/src/effect/capacity.rs diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index ee3b846a1..8e5a1dc60 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -911,3 +911,15 @@ real local HTTP, then exercises native release compilation, review, fresh exact approval, full recompile, managed count/byte declarations, ACK binding and changed recipient/channel/instance/partition/operation refusals. It establishes no actual delivery, persistent ACK, isolated-agent or PostgreSQL claim. + +### Shared source allocation leaf + +`effect/capacity.rs` now owns the fixed source count/byte declaration arithmetic, +with the protocol supplying its typed units. `store/capacity.rs` owns the existing +canonical append-only allocation record, key and occupied-slot validation. The +acquisition protocol continues to derive source eligibility, source identities, +limits and transitions; disclosure supplies its distinct units and source keys. +No schema, journal authority, admission decision or refund rule changes. The +empty-disclosure ceiling convention does not alter nonempty acquisition bytes. +This extracts the identical bounded record mechanism rather than copying the +acquisition allocator into a second disclosure ledger. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index e51dfcda8..42dbb566b 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1239,6 +1239,23 @@ closure regeneration passed after that correction (one artifact-generation test) cutover remain incomplete. No acceptance case is closed by compilation. No broad local gate, formal execution or hosted CI observation was run. +## Shared source-allocation checkpoint + +- Based on pushed disclosure compiler commit `93f4915c`. +- Extracted the existing source count/byte declaration leaf and canonical + append-only allocation row/key/occupied-slot validation into the existing + effect/capacity and store/capacity owners. Acquisition source eligibility, + lifecycle, schema and charges are unchanged; disclosure declarations now use + the same arithmetic with their own units and source keys. +- Required content-journal and recovery-acquisition artifact generators both + passed (two tests, 3.64 seconds); their fixtures remained byte-for-byte current. + No new provider calls, admission authority, retry or refund rule is introduced. +- Candidate, prerequisite and semantic-closure artifact generators also passed + (three tests, 37.73 seconds). Behavioral fixture bytes stayed unchanged; only + the native semantic closure changed with the source extraction. +- This reduces duplication needed by disclosure admission; it does not yet + implement that admission or a delivery grant. P3/P4 and A01–A22 remain open. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 5a0796419..a281a5891 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -622,3 +622,10 @@ The content journal corpus provides actual source transport plus separate release compilation/ACK comparisons for empty and nonempty content. Runtime entry, capacity enforcement and recipient-channel behavior remain unqualified; no generic workflow/callback or new ledger is introduced by this extraction. + +The source allocation leaf is now physically shared: protocol owners supply +count/byte units and source commitments; the existing capacity module owns the +append-only row encoding/key and occupied-row equality check. No policy or +source-eligibility callback is introduced. Required content/recovery native +artifacts regenerate byte-for-byte unchanged after this extraction; disclosure +compilation uses the same bounded reservation arithmetic with disjoint units. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index abea07a06..5ab636c70 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"639e3cbbd544469aa8851b3a28eb68190c9c8c57cfeef27ede7abc859b7dfe77"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"f4c33e7d25e9d7b6fd62fb9b14ac2d560e63eae12edec051b4374a79c7d7acda"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"115d34c55c0053b11a9ebf3859d92d31f011019c609f0f1901e38ec78529bafe"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"b3fe20f49b4c5f4183b8fb58125dae144a574bcba658d162cabda6f920294b78"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b681eba832068ba745341f5adfefbfd593f664e3e51b75f666b503854f7a44f2"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"67405e0a730bb6c5cc4687b1c2f50563eeb8aba16f8021bb1f2319c0304216d0"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"6497a4e413d63ceb7cea1ff74788a19af253d03d058ac928f0214865dc42356a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"9f2e494a411c02c6cdac6545a2b7cd57300af000c5c7a1ac5f9ebc3b953eaf81"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"566afcf60efec166f8d0c0558797bd81ba8fbbe242e369a5f3b2701385cc104f"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"fb5592bd7a45d561ba9431ade8c0b33eac63284f845be43f27646241a8500387"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"17193792e50e7daf02e7abde269b618201fdb7e8d30ec843426c174013d955a8"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"cfe2145ba822adab1e2cd30643ef4762ab8749af3f2d8fc74f359e0646f501b0"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"4e7b4edb55d284d83e9e79282b985bd73f20a3a4d08022c80fdfd82eae09ad52"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"4a2a8593fbcfae99c7ba5cd393d4158735046fc8146929bc52bb09e5a982dec9"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"55122c5e16a82cf1fe26c3fc3bc8e1c1289018b8d5edcf4a8cc39ccd64039df7"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"364775ba84918cfc13618e79d347aff6cb591b01ef86e14b986a42d876cdee4b"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"67cbae21e74097755753c9bccb74e84bb2b9b19ab41905b924fa8360b8cb3ea8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"a57e9c323077cc4fd9726a97dd2f2c0c478290e713825a62b990a4358e8e3cd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"ad01d22c2e520315a03a955ffb7795cd6ec8d62fbea73f071fc5ab35b3bdc73f"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"cd2ebe7de7c01ec1c4781056bc1b798b09db1e71b7b77d77f55997d1f6629121"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"5306f441de5ec42e43910bce3050f33a2a7941f7a37160cae79e03a0ab854c2e"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"ce872269471201db44507e5f120ec341840b6a4dd20c29b6bae1abe352650cdf"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"349ca7c7e95ec93873e6898e970fe59163198bee0623551218ebe65fce6487a9"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"a88ff20bab8aff12b0a2ec2f48c3bf575214926bcd92339811cce3b7bc94a109"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"6497a4e413d63ceb7cea1ff74788a19af253d03d058ac928f0214865dc42356a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"3e0207570a1f18289c043b20766b6616bb045edf3bdb966ad014d439a8065694"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"9f2e494a411c02c6cdac6545a2b7cd57300af000c5c7a1ac5f9ebc3b953eaf81"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"3c1c13e354e161044aca59921deec32dfbcbd20d79c9b10dc6497c50ebbc4891"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"566afcf60efec166f8d0c0558797bd81ba8fbbe242e369a5f3b2701385cc104f"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"fb5592bd7a45d561ba9431ade8c0b33eac63284f845be43f27646241a8500387"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"17193792e50e7daf02e7abde269b618201fdb7e8d30ec843426c174013d955a8"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"cfe2145ba822adab1e2cd30643ef4762ab8749af3f2d8fc74f359e0646f501b0"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"4e7b4edb55d284d83e9e79282b985bd73f20a3a4d08022c80fdfd82eae09ad52"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"4a2a8593fbcfae99c7ba5cd393d4158735046fc8146929bc52bb09e5a982dec9"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"55122c5e16a82cf1fe26c3fc3bc8e1c1289018b8d5edcf4a8cc39ccd64039df7"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"28c1473e99e2a3444080d27585c7afd2fd0e343280b4c6220409d9e88d1811f5"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"a57e9c323077cc4fd9726a97dd2f2c0c478290e713825a62b990a4358e8e3cd2"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"19fc5214c52d3ccbeb4223944a20a6ac56a574541dcedb368302e0b8799ee1cc"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 8c816305f..91ee03b6b 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -19,6 +19,8 @@ use std::fmt; use zeroize::Zeroizing; mod acquisition; +mod capacity; +pub(crate) use capacity::SourceCapacity; mod candidate; mod content; pub(crate) use content::ContentPlan; @@ -39,8 +41,7 @@ pub use candidate::{ }; mod prerequisite; pub(crate) use acquisition::{ - AcquisitionCapacity, AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, - RecoveryPlan, + AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, RecoveryPlan, }; pub use acquisition::{RecoveryReadTarget, compile_recovery_acquisition}; use prerequisite::Prerequisites; diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index c860fb272..3d861bd99 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -140,7 +140,7 @@ impl RecoveryReadTarget { } let plan = self.journal_plan(prerequisites).map_err(|_| invalid())?; let capacity = plan.capacity().map_err(|_| invalid())?; - let mut reservations = capacity.reservations(); + let mut reservations = capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes); reservations.extend(managed_reservations( bound, Unit::AcquisitionCount, @@ -284,7 +284,7 @@ impl AcquisitionPlan { Self::Prerequisite(plan) => plan.source(), } } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { match self { Self::Recovery(plan) => plan.capacity(), Self::Candidate(plan) => plan.capacity(), @@ -295,7 +295,7 @@ impl AcquisitionPlan { pub(crate) fn validate( &self, binding: &EffectBinding, - ) -> Result { + ) -> Result { match self { Self::Recovery(plan) => plan.validate(binding), Self::Candidate(plan) => plan.validate(binding), @@ -305,13 +305,6 @@ impl AcquisitionPlan { } } -pub(crate) struct AcquisitionCapacity { - pub(crate) count_key: [u8; 32], - pub(crate) bytes_key: [u8; 32], - pub(crate) maximum_bytes: u64, - pub(crate) attempts: u64, -} - impl RecoveryPlan { pub(crate) fn matches_target( &self, @@ -333,7 +326,7 @@ impl RecoveryPlan { EffectBinding::from_private_bytes(self.source_binding.as_bytes()) } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { let source = self.source()?; if !(1..=65_536).contains(&self.maximum_response_bytes) || !matches!(source.wire.protocol, Protocol::Mutation { .. }) @@ -346,7 +339,7 @@ impl RecoveryPlan { &canonical(&(source.id().as_bytes(), unit))?, ) }; - Ok(AcquisitionCapacity { + Ok(SourceCapacity { count_key: key(Unit::AcquisitionCount)?, bytes_key: key(Unit::ResponseBytes)?, maximum_bytes: self.maximum_response_bytes, @@ -357,7 +350,7 @@ impl RecoveryPlan { pub(crate) fn validate( &self, effect: &EffectBinding, - ) -> Result { + ) -> Result { let source = self.source()?; let capacity = self.capacity()?; let transport = self.transport_canonical.as_bytes(); @@ -392,7 +385,7 @@ impl RecoveryPlan { .filter(|entry| entry.window == ReservationWindow::SourceLifetime) .cloned() .collect::>() - != capacity.reservations() + != capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes) || effect.wire.reservations.iter().any(|entry| { matches!(entry.window, ReservationWindow::Fixed { .. }) && match entry.unit { @@ -408,29 +401,6 @@ impl RecoveryPlan { } } -impl AcquisitionCapacity { - pub(super) fn reservations(&self) -> Vec { - let mut reservations = vec![ - Reservation { - key: self.count_key, - unit: Unit::AcquisitionCount, - amount: 1, - ceiling: self.attempts, - window: ReservationWindow::SourceLifetime, - }, - Reservation { - key: self.bytes_key, - unit: Unit::ResponseBytes, - amount: self.maximum_bytes, - ceiling: self.attempts * self.maximum_bytes, - window: ReservationWindow::SourceLifetime, - }, - ]; - reservations.sort_by_key(|entry| (entry.key, entry.unit)); - reservations - } -} - #[derive(Clone)] pub(super) enum AcquisitionTarget { Recovery(Box), diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs index aa3a13e69..55b413f6b 100644 --- a/product/runtime/auths-gateway/src/effect/candidate.rs +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -230,7 +230,7 @@ impl CandidateCredentialTarget { let invalid = || not_entered("gateway.acquisition.binding"); let capacity = candidate_capacity(&self.candidate, self.maximum_response_bytes()) .map_err(|_| invalid())?; - let mut reservations = capacity.reservations(); + let mut reservations = capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes); reservations.extend(managed_reservations( bound, Unit::AcquisitionCount, @@ -287,7 +287,7 @@ pub fn compile_candidate_credential( fn candidate_capacity( candidate: &ConnectionRecord, maximum_bytes: u64, -) -> Result { +) -> Result { if !(1..=65_536).contains(&maximum_bytes) { return Err(EffectBindingError::Invalid); } @@ -302,7 +302,7 @@ fn candidate_capacity( ))?, ) }; - Ok(AcquisitionCapacity { + Ok(SourceCapacity { count_key: key(Unit::AcquisitionCount)?, bytes_key: key(Unit::ResponseBytes)?, maximum_bytes, @@ -387,7 +387,7 @@ impl CandidatePlan { Ok(contract) } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { let contract = self.witness()?; candidate_capacity( &self.connection()?, @@ -400,7 +400,7 @@ impl CandidatePlan { pub(crate) fn validate( &self, binding: &EffectBinding, - ) -> Result { + ) -> Result { let capacity = self.capacity()?; let candidate = self.connection()?; let previous = self @@ -466,7 +466,7 @@ impl CandidatePlan { .filter(|r| r.window == ReservationWindow::SourceLifetime) .cloned() .collect::>() - != capacity.reservations() + != capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes) || binding.wire.reservations.iter().any(|r| { matches!(r.window, ReservationWindow::Fixed { .. }) && match r.unit { diff --git a/product/runtime/auths-gateway/src/effect/capacity.rs b/product/runtime/auths-gateway/src/effect/capacity.rs new file mode 100644 index 000000000..fcc79092b --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/capacity.rs @@ -0,0 +1,33 @@ +//! Shared fixed-size source allocation declarations, without admission or I/O. +use super::{Reservation, ReservationWindow, Unit}; + +/// Bounded append-only source allowance; protocol owners supply distinct units. +pub(crate) struct SourceCapacity { + pub(crate) count_key: [u8; 32], + pub(crate) bytes_key: [u8; 32], + pub(crate) maximum_bytes: u64, + pub(crate) attempts: u64, +} + +impl SourceCapacity { + pub(super) fn reservations(&self, count: Unit, bytes: Unit) -> Vec { + let mut reservations = vec![ + Reservation { + key: self.count_key, + unit: count, + amount: 1, + ceiling: self.attempts, + window: ReservationWindow::SourceLifetime, + }, + Reservation { + key: self.bytes_key, + unit: bytes, + amount: self.maximum_bytes, + ceiling: self.attempts * self.maximum_bytes.max(1), + window: ReservationWindow::SourceLifetime, + }, + ]; + reservations.sort_by_key(|entry| (entry.key, entry.unit)); + reservations + } +} diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index 135d4f45a..8bcd32798 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -183,7 +183,7 @@ impl ContentReadTarget { .and_then(|plan| plan.capacity()) .map_err(|_| invalid())?; let maximum_bytes = capacity.maximum_bytes; - let mut reservations = capacity.reservations(); + let mut reservations = capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes); reservations.extend(managed_reservations( bound, Unit::AcquisitionCount, @@ -332,7 +332,7 @@ impl ContentPlan { commitment(CONTRACT, self.contract.as_bytes()) } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { let contract = self.witness()?; let maximum_bytes = contract["content"]["request"]["maximum_response_bytes"] .as_u64() @@ -354,7 +354,7 @@ impl ContentPlan { ))?, ) }; - Ok(AcquisitionCapacity { + Ok(SourceCapacity { count_key: key(Unit::AcquisitionCount)?, bytes_key: key(Unit::ResponseBytes)?, maximum_bytes, @@ -365,7 +365,7 @@ impl ContentPlan { pub(crate) fn validate( &self, binding: &EffectBinding, - ) -> Result { + ) -> Result { let capacity = self.capacity()?; self.projection()?; let connection = self.connection()?; @@ -393,7 +393,7 @@ impl ContentPlan { .filter(|r| r.window == ReservationWindow::SourceLifetime) .cloned() .collect::>() - != capacity.reservations() + != capacity.reservations(Unit::AcquisitionCount, Unit::ResponseBytes) || binding.wire.reservations.iter().any(|r| { matches!(r.window, ReservationWindow::Fixed { .. }) && match r.unit { diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index c1645dee4..b24d61437 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -419,7 +419,7 @@ impl PrerequisitePlan { Ok(self.declaration()?.purpose.kind()) } - pub(crate) fn capacity(&self) -> Result { + pub(crate) fn capacity(&self) -> Result { let source = self.source()?; let declaration = self.declaration()?; let key = |unit| { @@ -428,7 +428,7 @@ impl PrerequisitePlan { &canonical(&(source.id().as_bytes(), self.index, unit))?, ) }; - Ok(super::AcquisitionCapacity { + Ok(super::SourceCapacity { count_key: key(super::Unit::AcquisitionCount)?, bytes_key: key(super::Unit::ResponseBytes)?, maximum_bytes: declaration.request.maximum_response_bytes, @@ -439,7 +439,7 @@ impl PrerequisitePlan { pub(crate) fn validate( &self, effect: &super::EffectBinding, - ) -> Result { + ) -> Result { if self.source()? != *effect { return Err(EffectBindingError::Invalid); } diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs index 97e03fee3..4c681e682 100644 --- a/product/runtime/auths-gateway/src/effect/release.rs +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -142,27 +142,20 @@ impl DisclosureTarget { } } - fn reservations(&self) -> Result, EffectBindingError> { + fn capacity(&self) -> Result { let source = self.content.source.id(); - let mut reservations = vec![ - Reservation { - key: commitment("auths.disclosure-source-count/1", source.as_bytes())?, - unit: Unit::DisclosureCount, - amount: 1, - ceiling: MAX_DELIVERIES, - window: ReservationWindow::SourceLifetime, - }, - Reservation { - key: commitment("auths.disclosure-source-bytes/1", source.as_bytes())?, - unit: Unit::DisclosureBytes, - amount: self.content.bytes, - // Empty delivery still spends one invocation; its byte amount is zero. - ceiling: MAX_DELIVERIES * self.content.bytes.max(1), - window: ReservationWindow::SourceLifetime, - }, - ]; - reservations.sort_by_key(|entry| (entry.key, entry.unit)); - Ok(reservations) + Ok(SourceCapacity { + count_key: commitment("auths.disclosure-source-count/1", source.as_bytes())?, + bytes_key: commitment("auths.disclosure-source-bytes/1", source.as_bytes())?, + maximum_bytes: self.content.bytes, + attempts: MAX_DELIVERIES, + }) + } + + fn reservations(&self) -> Result, EffectBindingError> { + Ok(self + .capacity()? + .reservations(Unit::DisclosureCount, Unit::DisclosureBytes)) } } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 5b5e00048..18e3bb859 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "044f0ca02024273f4a6b8c897a3e9787c2f567e48a2cc3080413b15c9523fc4e"; + "75d590f9ffbc5d53bb7fb52719fdba4f8c496929cafb632f48fe3eb86291e438"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index db0da7f8c..f799a7eeb 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -3,9 +3,7 @@ //! the same adapter fence. No stored grant can recreate a read permit. use super::*; -use crate::effect::{ - AcquisitionCapacity, AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, -}; +use crate::effect::{AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, SourceCapacity}; mod content; use content::ContentResult; @@ -18,8 +16,6 @@ pub use recovery::{ GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, }; -const ALLOCATION_SCHEMA: &str = "auths.effect-allocation/1"; - /// Public facts about a bounded acquisition, with no content or private digest. #[derive(Clone, Debug, Eq, PartialEq, Serialize)] pub struct AcquisitionSnapshot { @@ -272,7 +268,7 @@ impl JournalProtocol for AcquisitionState { impl AcquisitionResponse { fn body( &self, - capacity: &AcquisitionCapacity, + capacity: &SourceCapacity, ) -> Result>, GatewayAttemptError> { if self.body_b64.len() > MAX_EVIDENCE_BYTES.div_ceil(3) * 4 { return Err(GatewayAttemptError::Corrupt); @@ -348,48 +344,17 @@ impl Record { } } -/// One immutable slot charges both distinct units at the same atomic admission. -/// Every read of this source has the same native maximum, so slot i holds one -/// call and that maximum, and cumulative bytes are (i + 1) * maximum. No expiry. -#[derive(Deserialize, Serialize)] -#[serde(deny_unknown_fields)] -struct Allocation { - schema: String, - claim: String, - source: String, - count_key: String, - bytes_key: String, +fn allocation( + plan: &AcquisitionPlan, + key: GatewayAttemptKey, slot: u64, - calls: u64, - bytes: u64, -} - -impl Allocation { - fn new( - plan: &AcquisitionPlan, - key: GatewayAttemptKey, - slot: u64, - ) -> Result { - let source = plan.source_id().map_err(|_| GatewayAttemptError::Corrupt)?; - let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; - if slot >= capacity.attempts { - return Err(GatewayAttemptError::InvalidTransition); - } - Ok(Self { - schema: ALLOCATION_SCHEMA.to_owned(), - claim: hex::encode(key.as_bytes()), - source: hex::encode(source), - count_key: hex::encode(capacity.count_key), - bytes_key: hex::encode(capacity.bytes_key), - slot, - calls: 1, - bytes: capacity.maximum_bytes, - }) - } -} - -fn allocation_key(capacity: &AcquisitionCapacity, slot: u64) -> GatewayAttemptKey { - GatewayAttemptKey(crate::bounds::count_slot_key(&capacity.count_key, slot)) +) -> Result { + capacity::SourceAllocation::new( + plan.source_id().map_err(|_| GatewayAttemptError::Corrupt)?, + &plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?, + key, + slot, + ) } /// Admission reserves capacity but grants no provider capability. @@ -727,8 +692,8 @@ impl GatewayAttempts { if refusal.is_none() { entries.push(GatewayRecordEntry { kind: GatewayRecordKind::EffectAllocation, - key: allocation_key(&capacity, slot), - record: canonical(&Allocation::new(&record.state.plan, key, slot)?)?, + key: capacity::allocation_key(&capacity, slot), + record: canonical(&allocation(&record.state.plan, key, slot)?)?, expires_at: None, }); entries.extend(slots); @@ -760,24 +725,14 @@ impl GatewayAttempts { let bytes = store .load( GatewayRecordKind::EffectAllocation, - &allocation_key(&capacity, slot), + &capacity::allocation_key(&capacity, slot), )? .ok_or(GatewayAttemptError::Corrupt)?; - let occupied: Allocation = serde_json::from_slice(&bytes) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let expected = Allocation::new(&record.state.plan, key, slot)?; - if canonical(&occupied)? != bytes - || digest_bytes(&occupied.claim).is_err() - || occupied.schema != expected.schema - || occupied.source != expected.source - || occupied.count_key != expected.count_key - || occupied.bytes_key != expected.bytes_key - || occupied.slot != slot - || occupied.calls != 1 - || occupied.bytes != expected.bytes - { - return Err(GatewayAttemptError::BindingConflict); - } + let occupied: capacity::SourceAllocation = + serde_json::from_slice(&bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let expected = allocation(&record.state.plan, key, slot)?; + occupied.validate_occupied(&expected, &bytes)?; slot += 1; } GatewayInsert::Exists { index } if refusal.is_none() => { @@ -921,7 +876,7 @@ impl ReservedAcquisition { ), ( GatewayRecordKind::EffectAllocation, - allocation_key(&capacity, slot), + capacity::allocation_key(&capacity, slot), ), ]; let native_indices = append_dependencies(&mut keys, &dependencies); @@ -965,7 +920,7 @@ impl ReservedAcquisition { eligible_source(&plan, snapshots[1].as_deref(), self.source_key, attempt.key)?; if !source_matches || snapshots[2].as_deref() - != Some(canonical(&Allocation::new(&plan, attempt.key, slot)?)?.as_slice()) + != Some(canonical(&allocation(&plan, attempt.key, slot)?)?.as_slice()) { return Err(GatewayAttemptError::BindingConflict); } @@ -1156,7 +1111,7 @@ pub(super) fn prerequisite_dependencies( )); keys.push(( GatewayRecordKind::EffectAllocation, - allocation_key(&capacity, 0), + capacity::allocation_key(&capacity, 0), )); } Ok(keys) @@ -1181,8 +1136,7 @@ pub(super) fn validate_prerequisites( if record.validate_header()? != *binding || record.state.plan != expected || record.state.allocation != Some(0) - || rows[1].as_deref() - != Some(canonical(&Allocation::new(&expected, key, 0)?)?.as_slice()) + || rows[1].as_deref() != Some(canonical(&allocation(&expected, key, 0)?)?.as_slice()) { return Err(GatewayAttemptError::BindingConflict); } diff --git a/product/runtime/auths-gateway/src/store/acquisition/candidate.rs b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs index f089e28bc..5d84e3f77 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/candidate.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs @@ -80,7 +80,7 @@ impl GatewayAttempts { (GatewayRecordKind::Attempt, key), ( GatewayRecordKind::EffectAllocation, - allocation_key(&capacity, slot), + capacity::allocation_key(&capacity, slot), ), ]; let native_indices = append_dependencies(&mut keys, &validation.dependencies()); @@ -105,9 +105,7 @@ impl GatewayAttempts { .map_err(|_| GatewayAttemptError::Corrupt)? .0 || snapshots[2].as_deref() - != Some( - canonical(&Allocation::new(&root.state.plan, key, slot)?)?.as_slice(), - ) + != Some(canonical(&allocation(&root.state.plan, key, slot)?)?.as_slice()) { return Err(GatewayAttemptError::BindingConflict); } diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index a858abc5f..15b257954 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -307,7 +307,7 @@ impl GatewayAttempts { if let Some(slot) = read.state.allocation { keys.push(( GatewayRecordKind::EffectAllocation, - allocation_key(&capacity, slot), + capacity::allocation_key(&capacity, slot), )); } let mut result = None; @@ -334,8 +334,7 @@ impl GatewayAttempts { if let Some(slot) = read.state.allocation && snapshots[2].as_deref() != Some( - canonical(&Allocation::new(&read.state.plan, read_key, slot)?)? - .as_slice(), + canonical(&allocation(&read.state.plan, read_key, slot)?)?.as_slice(), ) { return Err(GatewayAttemptError::Corrupt); diff --git a/product/runtime/auths-gateway/src/store/capacity.rs b/product/runtime/auths-gateway/src/store/capacity.rs index 1949369df..af2731aad 100644 --- a/product/runtime/auths-gateway/src/store/capacity.rs +++ b/product/runtime/auths-gateway/src/store/capacity.rs @@ -396,3 +396,70 @@ pub(super) fn dependencies( }) .collect()) } + +/// One append-only slot charges one invocation and its declared byte amount. +/// Unit domains and source eligibility remain in the bound protocol owner. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct SourceAllocation { + schema: String, + claim: String, + source: String, + count_key: String, + bytes_key: String, + slot: u64, + calls: u64, + bytes: u64, +} + +impl SourceAllocation { + pub(super) fn new( + source: [u8; 32], + capacity: &crate::effect::SourceCapacity, + key: GatewayAttemptKey, + slot: u64, + ) -> Result { + if slot >= capacity.attempts { + return Err(GatewayAttemptError::InvalidTransition); + } + Ok(Self { + schema: "auths.effect-allocation/1".to_owned(), + claim: hex::encode(key.as_bytes()), + source: hex::encode(source), + count_key: hex::encode(capacity.count_key), + bytes_key: hex::encode(capacity.bytes_key), + slot, + calls: 1, + bytes: capacity.maximum_bytes, + }) + } + + /// A losing admission can advance only past a canonical slot for the exact + /// same source and units. Another claim is expected; altered facts are not. + pub(super) fn validate_occupied( + &self, + expected: &Self, + bytes: &[u8], + ) -> Result<(), GatewayAttemptError> { + if canonical(self)? != bytes + || digest_bytes(&self.claim).is_err() + || self.schema != expected.schema + || self.source != expected.source + || self.count_key != expected.count_key + || self.bytes_key != expected.bytes_key + || self.slot != expected.slot + || self.calls != 1 + || self.bytes != expected.bytes + { + return Err(GatewayAttemptError::BindingConflict); + } + Ok(()) + } +} + +pub(super) fn allocation_key( + capacity: &crate::effect::SourceCapacity, + slot: u64, +) -> GatewayAttemptKey { + GatewayAttemptKey(crate::bounds::count_slot_key(&capacity.count_key, slot)) +} From 3f23e5f3171a419cec6b6596b188c4791e45ea0e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 21:55:33 +0000 Subject: [PATCH 053/136] feat(gateway)!: journal disclosure reservations and historical acknowledgements --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 8 + .../fixtures/gateway/content-journal.json | 8 +- .../fixtures/gateway/disclosure-journal.json | 237 ++++++++ .../fixtures/gateway/prerequisite-entry.json | 2 +- compliance.toml | 9 +- ...017-bound-effect-and-recovery-ownership.md | 29 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 4 +- docs/plans/0074-implementation-status.md | 38 +- .../0009-bound-effect-and-recovery.md | 16 + ...ound-effects-and-recovery-state-machine.md | 41 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6577 -> 6577 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6460 -> 6460 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5732 -> 5732 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5031 -> 5031 bytes .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 43 +- .../auths-gateway/src/effect/release.rs | 128 +++- .../auths-gateway/src/effect_content_tests.rs | 16 +- .../src/effect_disclosure_journal_tests.rs | 528 ++++++++++++++++ .../auths-gateway/src/effect_native_tests.rs | 3 + .../src/effect_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 129 ++++ product/runtime/auths-gateway/src/lib.rs | 18 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 1 + .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 26 +- .../auths-gateway/src/store/acquisition.rs | 9 +- .../src/store/acquisition/content.rs | 49 +- .../auths-gateway/src/store/disclosure.rs | 564 ++++++++++++++++++ product/runtime/auths-gateway/src/support.rs | 6 + 40 files changed, 1867 insertions(+), 73 deletions(-) create mode 100644 bindings/fixtures/gateway/disclosure-journal.json create mode 100644 product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs create mode 100644 product/runtime/auths-gateway/src/store/disclosure.rs diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index c5d2af1d6..5bfeb3fa3 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/13", + "attempt_schema": "auths.gateway-attempt/14", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index f103b1332..db0d1c46d 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -378,6 +378,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.disclosure.exhausted", + "owner": "effect", + "stage": "admission", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.disclosure.unsupported-bounds", "owner": "effect", diff --git a/bindings/fixtures/gateway/content-journal.json b/bindings/fixtures/gateway/content-journal.json index 4fa18b7ca..2dccf84b5 100644 --- a/bindings/fixtures/gateway/content-journal.json +++ b/bindings/fixtures/gateway/content-journal.json @@ -465,5 +465,11 @@ "exact_ack_validates": true, "scope": "compilation and evidence only; no delivery grant or transport" } - ] + ], + "disclosure_journal": { + "fixture": "disclosure-journal.json", + "admissions": 16, + "refusals": 2, + "delivered_bytes": 0 + } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/disclosure-journal.json b/bindings/fixtures/gateway/disclosure-journal.json new file mode 100644 index 000000000..0e7d60583 --- /dev/null +++ b/bindings/fixtures/gateway/disclosure-journal.json @@ -0,0 +1,237 @@ +{ + "schema": "auths.gateway-disclosure-journal-fixture/1", + "scope": "native installed file admission with real retained HTTP source; no authenticated delivery; synthetic grant assumptions only; no independent process, PostgreSQL or isolation claim", + "expired_approval_refused": true, + "changed_source_refused": true, + "disabled_connection_refused": true, + "concurrent_same_operation_one_allocation": true, + "changed_binding_conflicts": true, + "record_mutations_and_obsolete_schema_refused": true, + "ack_before_grant_refused": true, + "cross_protocol_refused": true, + "reopened_replay_preserves_record": true, + "ack_history": { + "assumption": "test-only synthetic retained grants, no recipient authentication or delivery", + "foreign_ack_refused": true, + "concurrent_exact_ack_preserves_revision": true, + "ack_after_connection_disable": true, + "acknowledged": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "late_acknowledged": { + "revision": 4, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 1, + "policy_byte_counters": 1 + } + }, + "history": [ + { + "operation": "release-0", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 1, + "policy_byte_counters": 1 + } + }, + { + "operation": "release-1", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 1, + "policy_byte_counters": 1 + } + }, + { + "operation": "release-policy-exhausted", + "snapshot": { + "revision": 1, + "stage": "not-entered", + "refusal": "gateway.policy.sum-exhausted", + "reserved_deliveries": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-2", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-3", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-4", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-5", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-6", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-7", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-8", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-9", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-10", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-11", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-12", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-13", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-14", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-15", + "snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + }, + { + "operation": "release-16", + "snapshot": { + "revision": 1, + "stage": "not-entered", + "refusal": "gateway.disclosure.exhausted", + "reserved_deliveries": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 73acc70c2..986cd1a13 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/13", + "attempt_schema": "auths.gateway-attempt/14", "cases": [ { "recipe": "stripe", diff --git a/compliance.toml b/compliance.toml index fdc2c1644..9ab133712 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/13", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/14", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1604,7 +1604,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/13", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/14", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1612,9 +1612,12 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +disclosure-journal-admission = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", +] disclosure-compilation-contract = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 8e5a1dc60..3f0ec2a1c 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -923,3 +923,32 @@ No schema, journal authority, admission decision or refund rule changes. The empty-disclosure ceiling convention does not alter nonempty acquisition bytes. This extracts the identical bounded record mechanism rather than copying the acquisition allocator into a second disclosure ledger. + +## Disclosure admission and historical ACK journal + +Attempt `/14` adds the closed disclosure state to the existing `JournalProtocol` +projection. The existing kernel reducer remains the sole transition decision; +file/PostgreSQL adapters retain their existing fenced insert/replace/CAS contract. +The plan is data only and validates source scope, installation, projection, exact +length, recipient key and typed reservations against the bound effect. Admission +loads and validates the retained acquisition under the same writer fence as native +configuration/authority. It atomically inserts one permanent source allocation +and the existing count/sum policy slots. No disclosure ledger, callback, provider +request or second capacity authority is introduced. Obsolete `/13` is rejected. + +The protocol's immutable ACK field is verified on every decode. Historical ACK +recording needs an existing grant and the common reducer, not fresh execution +authority. A concurrent identical ACK can be recognized after one bounded reload; +revision and charges remain unchanged. Public snapshots and support listings keep +provider/acquisition/recipient facts distinct and contain no private correlations. +Engine proposal/compile/admit operations have no delivery capability or custody. +The final recipient-authenticated grant and one-use transport remain unwired. + +`disclosure-journal.json` constructs real HTTP source content then executes native +installed file admission, duplicate claim concurrency, changed source/connection/ +approval refusal, policy/source exhaustion and reopened replay. Corrupt plan fields, +cross-protocol records and obsolete schemas refuse. ACK cases use explicitly +synthetic retained grants, exercise the real durable CAS/decoder/reducer, and assert +pre-grant/foreign refusal, concurrent exact replay and late evidence after disabling +the connection. They do not establish recipient authentication, actual send, +independent-process isolation or PostgreSQL qualification. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 5d99ea3d3..00a82df96 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -106,7 +106,7 @@ and full acceptance evidence remain open AP074 requirements. Compiler `/8` exposes native candidate-check compilation for an exact staged first-install or rotation descriptor. The corresponding engine acquisition API -now uses journal `/12` and entry audit `/3`: predecessor/absence, current native +now uses journal `/14` and entry audit `/3`: predecessor/absence, current native authority and all earlier check evidence are fenced before reads. It leases only the exact already-staged credential and returns redacted acquisition facts. This API does not publish credentials. The onboarding/rotation CLI staging and @@ -188,7 +188,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/13`; a store holding obsolete records is refused as + `auths.gateway-attempt/14`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 42dbb566b..3e4115fe3 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1256,6 +1256,38 @@ closure regeneration passed after that correction (one artifact-generation test) - This reduces duplication needed by disclosure admission; it does not yet implement that admission or a delivery grant. P3/P4 and A01–A22 remain open. +## Disclosure journal checkpoint + +- Based on `15d0bb8d`, added a closed disclosure protocol to the shared journal, + reducer projection and support listing. Journal `/14` rejects obsolete `/13`; + related source, qualification claims and generated schema/fuzz fixtures move + together with no migration reader. +- Native engine proposal/compile/admit APIs now use sealed retained provenance, + exact approval and the existing installed authority/configuration fence. Atomic + admission reserves the shared permanent source allocation and selected native + count/byte slots. It emits no content, credential lease or delivery permit. +- Durable ACK recording validates exact retained binding/length and the original + grant via the common reducer. Exact replay is revision-preserving; concurrent + CAS conflicts have one bounded reload. Late history after connection disable + remains recordable. The production authenticated grant is still unwired. +- Required artifact construction passed five exact generators in 9.69 seconds: + content journal (including new disclosure journal), code inventory, attempt + scenarios, prerequisite compilation and native entry/fuzz corpus. The fixture + executes installed file admission, duplicate concurrency, source/connection/ + approval refusal, sixteen source allocations and independent policy exhaustion, + conflicting binding, reopening and no disclosure/public private correlations. +- ACK persistence tests use explicitly synthetic retained grants, never real + recipient authentication or sends. They cover pre-grant/foreign ACK refusal, + concurrent identical ACKs, late unknown refinement, immutable revision/charges + and reopened replay. No process/PostgreSQL/isolation/complete A08 claim. +- Final content/disclosure journal and semantic-closure generators passed + together (two tests, 4.91 seconds), including ten record mutations and the + immediate obsolete schema. The byte-policy case exhausts its sum while count + capacity remains; public refusals distinguish it from source exhaustion. +- Production recipient authentication and final grant/transport, AP070 owner and + binding/UI cutovers, complete P4 evidence and hosted CI remain outstanding. + No A01–A22 case is closed by this checkpoint; no broad local or hosted gate ran. + ## Phase gates | Phase | State | Outstanding gate | @@ -1263,7 +1295,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Recovery/prerequisite/content acquisition runtime and ACK compilation wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), general acquisition/disclosure/ACK; remove Python semantic owner | +| P3 | Acquisition runtime, disclosure admission and historical ACK persistence wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), authenticated disclosure grant/transport; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -1281,8 +1313,8 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer corpus / pure histories executed | Persistent disclosure grant, actual send/ACK loss and restart pending | -| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Wire recipient/channel and journal integration pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer and file journal corpus / ACK persistence/replay under synthetic grants executed | Authenticated disclosure grant, actual send/ACK loss and process restart pending | +| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Authenticated live recipient/channel and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index a281a5891..2c89b2a0b 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -629,3 +629,19 @@ append-only row encoding/key and occupied-row equality check. No policy or source-eligibility callback is introduced. Required content/recovery native artifacts regenerate byte-for-byte unchanged after this extraction; disclosure compilation uses the same bounded reservation arithmetic with disjoint units. + +### Disclosure journal instance + +Disclosure now supplies typed state/plan projections to the same journal protocol +and kernel reducer as acquisition and mutation. Source provenance is checked under +the existing writer fence, alongside selected native dependencies and permanent +source/fixed-window slots. The count/sum arithmetic, immutable allocation encoding, +replay-key comparison and CAS transition owner remain shared. Provider evidence and +recipient ACK bytes remain divergent typed fields; no generic success outcome is +introduced. The native engine can reserve a disclosure but cannot deliver it yet. + +The file corpus adds real-source admission/exhaustion/replay and decoder mutations. +A synthetic retained-grant assumption enables real ACK persistence/concurrency and +late-history comparisons; it is explicitly not live recipient authentication or +transport evidence. The production grant/transport and complete differential and +performance gates remain outstanding. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index f4a5a1e98..e82b4f4ca 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -323,7 +323,7 @@ read proof/approval. Custody is checked for the exact staged reference before publication; independently stored custody and connection state are not claimed to be one atomic transaction. -The concrete journal encoding is `auths.gateway-attempt/13`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/14`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded @@ -411,9 +411,9 @@ encoding facts. Each header is missing, one value of at most 128 bytes, or inval by decoding a content record as ordinary prerequisite/recovery evidence. The typed `content-response-recorded` phase projects to the existing acquisition -response stage under the sole reducer. Attempt schema `/13` atomically retains +response stage under the sole reducer. Attempt schema `/14` atomically retains one additional closed result: protected content or a typed projection refusal. -Obsolete `/12` records are rejected; no compatibility decoder or migration exists. +Obsolete `/13` records are rejected; no compatibility decoder or migration exists. Required-version agreement, identity encoding, one valid media type and the exact compiled projection must all hold before protected content is constructed. Encoding may be absent or a single case-insensitive `identity` value; compressed @@ -474,9 +474,38 @@ that length (one is used only for the nonzero ceiling representation of empty content). Empty delivery charges zero bytes and one count. Selected native policy bounds use `maximum_disclosure_bytes`, disjoint disclosure count/byte counter domains and the existing bounded tightening/window arithmetic. The thirty-four -reservation bound is unchanged. These are compiler obligations, not a claim that -disclosure admission or delivery is already wired. The journal must enforce them -atomically before issuing any one-use delivery capability. +reservation bound is unchanged. These obligations are enforced by journal admission below; no admission +reservation itself authorizes a delivery. The separate final grant must recheck +the reservations before issuing any one-use delivery capability. + +Disclosure admission now uses a third closed journal protocol under attempt +schema `/14`. Its immutable plan retains source-binding/projection provenance and +recipient/channel/instance data; it cannot reconstruct an executable capability. +The existing writer fence validates the source response/MAC, full current native +authority and configuration, exact approval and fixed-window predecessors before +atomically inserting the disclosure record, permanent source slot and selected +policy slots. Lifetime and policy exhaustion create a retained not-entered record +without a new allocation. Concurrent same-operation claims return one reservation; +changed binding conflicts. Admission itself authenticates no recipient and emits +no plaintext or delivery permit. + +Public disclosure snapshots distinguish reserved, not-entered, unknown and +acknowledged, with explicit retained count/byte allocations and policy-counter +counts. No content, recipient/channel correlation or protected commitment is +public. The shared operation listing and support projection retain the disclosure +protocol distinction. Existing acquisition and mutation decoders refuse disclosure +state rather than interpreting its facts as provider evidence. + +The journal ACK recorder authenticates against its retained binding and exact +content length, requires the sole reducer's original grant, and persists immutable +canonical ACK bytes. It accepts historical evidence after authority changes; +current permission is not required to record past facts. Exact replay returns the +same revision. A concurrent CAS loser reloads at most once to recognize identical +stored evidence, never to redeliver. The native engine exposes separate proposal, +compile and admission operations, all without credential lease or byte delivery. +Production authenticated recipient entry and the one-use delivery transport remain +required. Current file ACK fixtures explicitly inject test-only retained grants; +they establish journal behavior, not an authenticated send or a completed A08. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index d4d047d64..371cb423e 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 30ff21324..ebeedb445 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index a7200a8b5..aeb3dd8d7 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index 7f2a47c20..eceddc572 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index bf1d8aa49..f0ce173ed 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/13","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index d3f48214788a5829d8d83685f551ad5eaa9861a3..23bbb680b8873b493d75cc30bb7426b5bde6df9c 100644 GIT binary patch delta 23 ccmdmJywP}qF{8;wlX*NK@+Q~jHR7yH0A$<;$^ZZW delta 23 ccmdmJywP}qF{ANDlX*NK@+Q~jHR7yH0A#`k$N&HU diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index c4979b17ce63101cacc72316670d425d50d70c83..30b298501fa4a8dd572a60b3e8136c01683c3f7e 100644 GIT binary patch delta 23 ccmdmEw8v bool { + matches!(self.wire.protocol, Protocol::Disclosure { .. }) + && self.matches_information_counters( + counts, + sums, + Unit::DisclosureCount, + Unit::DisclosureBytes, + ) + } + + fn matches_information_counters( + &self, + counts: &[[u8; 32]], + sums: &[[u8; 32]], + count: Unit, + bytes: Unit, + ) -> bool { let fixed: Vec<_> = self .wire .reservations @@ -539,8 +564,8 @@ impl EffectBinding { fixed.len() == counts.len() + sums.len() && fixed.iter().all(|entry| { let keys = match entry.unit { - Unit::AcquisitionCount => counts, - Unit::ResponseBytes => sums, + unit if unit == count => counts, + unit if unit == bytes => sums, _ => return false, }; keys.iter().filter(|key| **key == entry.key).count() == 1 @@ -1111,6 +1136,20 @@ impl ApprovedEffect { } } + pub(crate) fn disclosure_plan(&self) -> Result { + match &self.effect.command { + CompiledEffect::Disclosure(command) => command.target.journal_plan(), + _ => Err(EffectBindingError::Invalid), + } + } + + pub(crate) fn disclosure_bound(&self) -> Option<&crate::bounds::BoundAdmission> { + match &self.effect.command { + CompiledEffect::Disclosure(command) => command.bound.as_ref(), + _ => None, + } + } + pub(crate) fn content_target(&self) -> Option<&ContentReadTarget> { match &self.effect.command { CompiledEffect::Acquisition(command) => match &command.target { diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs index 4c681e682..508576f65 100644 --- a/product/runtime/auths-gateway/src/effect/release.rs +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -143,12 +143,22 @@ impl DisclosureTarget { } fn capacity(&self) -> Result { - let source = self.content.source.id(); - Ok(SourceCapacity { - count_key: commitment("auths.disclosure-source-count/1", source.as_bytes())?, - bytes_key: commitment("auths.disclosure-source-bytes/1", source.as_bytes())?, - maximum_bytes: self.content.bytes, - attempts: MAX_DELIVERIES, + self.journal_plan()?.capacity() + } + + pub(super) fn journal_plan(&self) -> Result { + Ok(DisclosurePlan { + source_binding: String::from_utf8(self.content.source.to_private_bytes()?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + source_contract: String::from_utf8(canonical(&self.content.review)?.to_vec()) + .map_err(|_| EffectBindingError::Invalid)?, + protected_content: self.content.commitment, + projection: self.content.projection, + bytes: self.content.bytes, + recipient_key: self.recipient_key, + recipient: self.recipient.clone(), + channel: self.channel, + instance: self.instance, }) } @@ -161,6 +171,7 @@ impl DisclosureTarget { pub(super) struct VerifiedDisclosure { pub(super) target: DisclosureTarget, + pub(super) bound: Option, pub(super) prerequisites: Prerequisites, #[cfg(unix)] actors: Vec, @@ -246,6 +257,7 @@ pub fn compile_disclosure( binding, command: CompiledEffect::Disclosure(Box::new(VerifiedDisclosure { target: target.clone(), + bound, prerequisites: Prerequisites::disclosure(), #[cfg(unix)] actors: branches.actors, @@ -265,3 +277,107 @@ pub fn compile_disclosure( .map_err(|_| invalid())?; Ok(effect) } + +/// Private data-only witness, never a deserializable retained source or permit. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct DisclosurePlan { + source_binding: String, + source_contract: String, + protected_content: [u8; 32], + projection: [u8; 32], + bytes: u64, + recipient_key: [u8; 32], + recipient: String, + channel: [u8; 32], + instance: [u8; 32], +} + +impl DisclosurePlan { + pub(crate) fn source(&self) -> Result { + EffectBinding::from_private_bytes(self.source_binding.as_bytes()) + } + + pub(crate) fn capacity(&self) -> Result { + if self.bytes > 65_536 { + return Err(EffectBindingError::Invalid); + } + let source = self.source()?.id(); + Ok(SourceCapacity { + count_key: commitment("auths.disclosure-source-count/1", source.as_bytes())?, + bytes_key: commitment("auths.disclosure-source-bytes/1", source.as_bytes())?, + maximum_bytes: self.bytes, + attempts: MAX_DELIVERIES, + }) + } + + pub(crate) fn matches_source( + &self, + source: &crate::RetainedContent, + ) -> Result { + Ok(self.source()? == source.source + && self.protected_content == source.commitment + && self.projection == source.projection + && self.bytes == source.bytes + && self.source_contract.as_bytes() == canonical(&source.review)?.as_slice()) + } + + pub(crate) fn validate( + &self, + effect: &EffectBinding, + ) -> Result { + let source = self.source()?; + let capacity = self.capacity()?; + if self.source_contract.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let contract: Value = + serde_json::from_str(&self.source_contract).map_err(|_| EffectBindingError::Invalid)?; + if canonical(&contract)?.as_slice() != self.source_contract.as_bytes() + || commitment( + "auths.gateway-content-acquisition/1", + self.source_contract.as_bytes(), + )? != self.projection + || !matches!(source.wire.protocol, Protocol::Acquisition { projection, .. } if projection == self.projection) + || source.wire.namespace != effect.wire.namespace + || source.wire.partition != effect.wire.partition + || source.wire.epoch != effect.wire.epoch + || source.wire.recipe != effect.wire.recipe + || source.wire.credential_generation != effect.wire.credential_generation + || source.wire.scope != Scope::Unscoped + || effect.wire.scope != Scope::Unscoped + || source.wire.connection != effect.wire.connection + || source.wire.operation == effect.wire.operation + || effect.wire.protocol + != (Protocol::Disclosure { + source_effect: *source.id().as_bytes(), + protected_content: self.protected_content, + recipient: self.recipient.clone(), + channel: self.channel, + delivery_instance: self.instance, + projection: self.projection, + maximum_bytes: self.bytes, + }) + || effect + .wire + .reservations + .iter() + .filter(|r| r.window == ReservationWindow::SourceLifetime) + .cloned() + .collect::>() + != capacity.reservations(Unit::DisclosureCount, Unit::DisclosureBytes) + || effect.wire.reservations.iter().any(|r| { + matches!(r.window, ReservationWindow::Fixed { .. }) + && match r.unit { + Unit::DisclosureCount => r.amount != 1, + Unit::DisclosureBytes => r.amount != self.bytes, + _ => true, + } + }) + { + return Err(EffectBindingError::Invalid); + } + DisclosureAcknowledgementRequest::for_delivery(effect, self.bytes, self.recipient_key)?; + Ok(capacity) + } +} diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index f18f6edbb..1c16e3aca 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -623,6 +623,7 @@ async fn native_content_journal_fixture_is_current() { let mut histories = vec![]; let mut first_protected = Value::Null; let mut disclosures = Vec::new(); + let mut disclosure_journal = Value::Null; for index in 0..17 { let approved = approve(&format!("content-journal-{index}")); let claim = attempts @@ -820,6 +821,17 @@ async fn native_content_journal_fixture_is_current() { if matches!(index, 0 | 8 | 9 | 10 | 13) { let retained_source = retained_source.expect("validated source"); assert_eq!(retained_source.bytes, expected_body.len() as u64); + if index == 0 { + disclosure_journal = super::disclosure_journal_tests::corpus( + retained_source.clone(), + &recipe, + &record, + &policy, + &store, + &path, + ) + .await; + } if matches!(index, 0 | 9) { disclosures.push(disclosure_compilation_cases( retained_source, @@ -847,7 +859,7 @@ async fn native_content_journal_fixture_is_current() { let mut changed = value.clone(); let cell = changed.pointer_mut(pointer).expect("field"); *cell = match pointer { - "/schema" => json!("auths.gateway-attempt/12"), + "/schema" => json!("auths.gateway-attempt/13"), "/state/facts/phase/content/value/schema" => { json!("auths.gateway-protected-content/0") } @@ -940,7 +952,7 @@ async fn native_content_journal_fixture_is_current() { "scope": "native signed compilation, installed file admission/entry, real bounded HTTP, reopened journal replay; no disclosure or process/PostgreSQL qualification", "permanent_source_attempts": 16, "real_http_requests": 15, "protected_content_mutations_refused": true, "same_content_foreign_source_refused": true, - "history": histories, "disclosure_compilation": disclosures}); + "history": histories, "disclosure_compilation": disclosures, "disclosure_journal": disclosure_journal}); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/content-journal.json"); let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); diff --git a/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs new file mode 100644 index 000000000..c26638a0e --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs @@ -0,0 +1,528 @@ +//! Native disclosure admission over the file journal that retained real HTTP +//! content. No recipient transport, grant or process isolation is claimed. +use super::*; +use crate::effect::{ + ApprovedEffect, DisclosureAcknowledgementRequest, DisclosureTarget, compile_disclosure, +}; +use std::sync::Arc; + +#[allow( + clippy::too_many_lines, + reason = "one native file admission/replay/capacity artifact corpus" +)] +pub(super) async fn corpus( + retained: crate::RetainedContent, + recipe: &CompiledRecipe, + connection: &ConnectionRecord, + policy: &EffectPolicy, + store: &Arc, + path: &std::path::Path, +) -> Value { + let root = signer(h::ROOT_SEED); + let observer = signer(h::OBSERVER_SEED); + let releaser = signer(0x44); + let recipient = SigningKey::from_bytes(&[51; 32]); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let target = DisclosureTarget::new( + retained.clone(), + recipient.verifying_key().to_bytes(), + [20; 32], + [21; 32], + ) + .expect("target"); + let probe = target + .authorization_call( + recipe, + &LogicalOperationId::parse("release-0").expect("operation"), + ) + .expect("call"); + let trust = h::context_for_tool(&root, &observer.principal, NOW, &probe).expect("trust"); + let grant = h::grant_for_tool( + &root, + &releaser.principal, + None, + window(NOW - 3600, NOW + 3600), + &probe, + ) + .expect("grant"); + let installed = policy.installation( + recipe, + &trust, + connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let approve = + |operation: &str, target: &DisclosureTarget, bounded: bool| -> Arc { + let call = target + .authorization_call( + recipe, + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("call"); + let bounded_grant = if bounded { + let budget = crate::ArgumentCeilingPolicy::new( + "maximum_disclosure_bytes", + retained.bytes, + 3600, + 3, + ) + .expect("policy") + .with_sum(retained.bytes * 2, None) + .expect("sum"); + Some(super::read_budget_tests::read_grant( + &root, &releaser, &call, &budget, + )) + } else { + None + }; + let signed = submission_for_call( + &root, + &releaser, + bounded_grant.as_ref().unwrap_or(&grant), + &call, + &[], + ); + let effect = compile_disclosure(&installed, target, NOW, &signed.proof, &signed.action) + .expect("effect"); + let request = effect.approval_request(NOW, NOW + 60).expect("request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + Arc::new( + effect + .approve(request.with_signature(signature), &public, NOW) + .expect("approval"), + ) + }; + let shared = crate::SharedConnection::new( + Arc::clone(store), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + let loaded = shared.load().await.expect("load").expect("connection"); + let configuration = crate::configuration::SharedConfiguration::new( + Arc::clone(store), + policy.configuration_key(recipe.namespace()).expect("key"), + [12; 32], + ); + let validation = |now| { + let qualification = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(now))), + auths_recipe_qualification::VerifierState::default(), + )); + crate::entry::EntryValidation::Installed(Box::new(crate::entry::InstalledEntry { + recipe: recipe.clone(), + trust: trust.clone(), + observer: None, + policy: policy.clone(), + configuration: configuration.clone(), + connection: crate::entry::EntryConnection::Installed(Box::new(loaded.clone())), + connection_key: crate::connection_key(connection.provider_kind(), connection.alias()), + qualification, + workload: connection.allowed_workloads()[0].clone(), + profile: connection.allowed_profiles()[0].clone(), + started: std::time::Instant::now(), + #[cfg(unix)] + commissioning: None, + })) + }; + let attempts = + crate::GatewayAttempts::new(Arc::clone(store), policy.clone()).expect("attempts"); + let refused = approve("release-expired", &target, false); + assert!( + attempts + .claim_disclosure(&refused, NOW, validation(NOW + 61)) + .await + .is_err() + ); + assert!( + attempts + .read_disclosure(&refused) + .await + .expect("read") + .is_none() + ); + let source_operation = + LogicalOperationId::parse(retained.source.journal_identity().1).expect("source operation"); + let source_key = + crate::GatewayAttemptKey::for_operation(policy, recipe.namespace(), &source_operation) + .expect("source key"); + let source_bytes = store + .load(crate::GatewayRecordKind::Attempt, &source_key) + .expect("load") + .expect("source"); + let mut source_value: Value = serde_json::from_slice(&source_bytes).expect("JSON"); + source_value["state"]["facts"]["phase"]["content"]["value"]["bytes"] = + json!(retained.bytes + 1); + let bad_source = serde_json::to_vec(&source_value).expect("bad bytes"); + store + .replace( + crate::GatewayRecordKind::Attempt, + &source_key, + &source_bytes, + &bad_source, + ) + .expect("inject source"); + let changed_source = approve("release-source-changed", &target, false); + assert!( + attempts + .claim_disclosure(&changed_source, NOW, validation(NOW)) + .await + .is_err() + ); + assert!( + attempts + .read_disclosure(&changed_source) + .await + .expect("read") + .is_none() + ); + store + .replace( + crate::GatewayRecordKind::Attempt, + &source_key, + &bad_source, + &source_bytes, + ) + .expect("restore source"); + let connection_key = crate::connection_key(connection.provider_kind(), connection.alias()); + let original_connection = connection.to_canonical_cbor().expect("connection"); + let disabled = connection + .transition_state(ConnectionState::Disabled, NOW) + .expect("disabled") + .to_canonical_cbor() + .expect("bytes"); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &original_connection, + &disabled, + ) + .expect("disable"); + let disabled_effect = approve("release-disabled", &target, false); + assert!( + attempts + .claim_disclosure(&disabled_effect, NOW, validation(NOW)) + .await + .is_err() + ); + assert!( + attempts + .read_disclosure(&disabled_effect) + .await + .expect("read") + .is_none() + ); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &disabled, + &original_connection, + ) + .expect("restore connection"); + let first = approve("release-0", &target, true); + let (one, two) = tokio::join!( + attempts.claim_disclosure(&first, NOW, validation(NOW)), + attempts.claim_disclosure(&first, NOW, validation(NOW)) + ); + let first_snapshot = one.expect("winner"); + assert_eq!(first_snapshot, two.expect("equal replay")); + assert_eq!(first_snapshot.stage, crate::DisclosureStage::Reserved); + assert_eq!(first_snapshot.reserved_deliveries, 1); + assert_eq!(first_snapshot.reserved_bytes, retained.bytes); + assert_eq!(first_snapshot.policy_count_counters, 1); + assert_eq!(first_snapshot.policy_byte_counters, 1); + let operation = LogicalOperationId::parse("release-0").expect("operation"); + let first_key = crate::GatewayAttemptKey::for_operation(policy, recipe.namespace(), &operation) + .expect("key"); + let first_bytes = store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("record"); + let original: Value = serde_json::from_slice(&first_bytes).expect("record JSON"); + for pointer in [ + "/schema", + "/state/protocol", + "/state/facts/allocation", + "/state/facts/plan/source_binding", + "/state/facts/plan/source_contract", + "/state/facts/plan/protected_content/0", + "/state/facts/plan/projection/0", + "/state/facts/plan/bytes", + "/state/facts/plan/recipient_key/0", + "/state/facts/phase/stage", + ] { + let mut changed = original.clone(); + let value = changed.pointer_mut(pointer).expect("field"); + *value = match pointer { + "/schema" => json!("auths.gateway-attempt/13"), + "/state/protocol" => json!("acquisition"), + "/state/facts/allocation" => json!(16), + "/state/facts/plan/source_binding" | "/state/facts/plan/source_contract" => json!("{}"), + "/state/facts/phase/stage" => json!("response-recorded"), + _ => json!(value.as_u64().expect("integer") ^ 1), + }; + let changed = serde_json::to_vec(&changed).expect("changed record"); + store + .replace( + crate::GatewayRecordKind::Attempt, + &first_key, + &first_bytes, + &changed, + ) + .expect("inject mutation"); + assert!(attempts.read_disclosure(&first).await.is_err(), "{pointer}"); + store + .replace( + crate::GatewayRecordKind::Attempt, + &first_key, + &changed, + &first_bytes, + ) + .expect("restore record"); + } + let ack = DisclosureAcknowledgementRequest::for_delivery( + first.effect().binding(), + retained.bytes, + recipient.verifying_key().to_bytes(), + ) + .expect("ACK"); + let ack_signature = recipient + .sign(&ack.signing_message().expect("message")) + .to_bytes(); + assert!( + attempts + .acknowledge_disclosure( + recipe.namespace(), + &operation, + &ack.with_signature(ack_signature) + ) + .await + .is_err(), + "a valid signature cannot invent a grant" + ); + assert_eq!( + store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("record"), + first_bytes + ); + let alternate = DisclosureTarget::new( + retained.clone(), + recipient.verifying_key().to_bytes(), + [22; 32], + [21; 32], + ) + .expect("target"); + let conflict = approve("release-0", &alternate, true); + assert!(matches!( + attempts + .claim_disclosure(&conflict, NOW, validation(NOW)) + .await, + Err(crate::GatewayAttemptError::BindingConflict) + )); + assert!( + attempts + .claim_content(&first, NOW, validation(NOW)) + .await + .is_err() + ); + assert!( + attempts + .claim_recovery(&first, NOW, validation(NOW)) + .await + .is_err() + ); + let mut history = vec![json!({"operation": "release-0", "snapshot": first_snapshot})]; + let second = approve("release-1", &target, true); + history.push(json!({"operation": "release-1", "snapshot": attempts.claim_disclosure(&second, NOW, validation(NOW)).await.expect("second")})); + let policy_exhausted = approve("release-policy-exhausted", &target, true); + let exhausted = attempts + .claim_disclosure(&policy_exhausted, NOW, validation(NOW)) + .await + .expect("policy refusal"); + assert_eq!(exhausted.stage, crate::DisclosureStage::NotEntered); + assert_eq!(exhausted.reserved_deliveries, 0); + assert_eq!(exhausted.reserved_bytes, 0); + assert_eq!( + exhausted.refusal.as_deref(), + Some("gateway.policy.sum-exhausted") + ); + history.push(json!({"operation": "release-policy-exhausted", "snapshot": exhausted})); + for index in 2..17 { + let operation = format!("release-{index}"); + // A changed channel still shares the source's lifetime allowance. + let effect = approve(&operation, &alternate, false); + let snapshot = attempts + .claim_disclosure(&effect, NOW, validation(NOW)) + .await + .expect("admission"); + assert_eq!( + snapshot.stage, + if index < 16 { + crate::DisclosureStage::Reserved + } else { + crate::DisclosureStage::NotEntered + } + ); + assert_eq!(snapshot.reserved_deliveries, u64::from(index < 16)); + history.push(json!({"operation": operation, "snapshot": snapshot})); + } + let reopened = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(path).expect("reopen")), + policy.clone(), + ) + .expect("attempts"); + assert_eq!( + reopened + .claim_disclosure(&first, NOW, validation(NOW)) + .await + .expect("replay"), + first_snapshot + ); + assert_eq!( + store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("record"), + first_bytes + ); + let listed = reopened.stages(64).await.expect("list"); + let disclosures = listed + .iter() + .filter(|(_, stage)| matches!(stage, crate::GatewayOperationStage::Disclosure(_))) + .count(); + assert_eq!(disclosures, 18); + let first_grant = reopened + .synthetic_disclosure_grant(&first, NOW, false) + .await + .expect("synthetic grant"); + let second_grant = reopened + .synthetic_disclosure_grant(&second, NOW, true) + .await + .expect("synthetic unknown grant"); + assert_eq!(first_grant.stage, crate::DisclosureStage::Unknown); + assert_eq!(second_grant.stage, crate::DisclosureStage::Unknown); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &original_connection, + &disabled, + ) + .expect("disable before late ACK"); + let acknowledgement = |effect: &ApprovedEffect| { + let statement = DisclosureAcknowledgementRequest::for_delivery( + effect.effect().binding(), + retained.bytes, + recipient.verifying_key().to_bytes(), + ) + .expect("statement"); + let signature = recipient + .sign(&statement.signing_message().expect("message")) + .to_bytes(); + statement.with_signature(signature) + }; + let first_ack = acknowledgement(&first); + let second_operation = LogicalOperationId::parse("release-1").expect("operation"); + assert!( + reopened + .acknowledge_disclosure(recipe.namespace(), &second_operation, &first_ack) + .await + .is_err(), + "valid foreign ACK cannot change unknown history" + ); + let (left, right) = tokio::join!( + reopened.acknowledge_disclosure(recipe.namespace(), &operation, &first_ack), + attempts.acknowledge_disclosure(recipe.namespace(), &operation, &first_ack), + ); + let acknowledged = left.expect("ACK"); + assert_eq!(acknowledged, right.expect("concurrent exact ACK")); + assert_eq!(acknowledged.stage, crate::DisclosureStage::Acknowledged); + assert_eq!(acknowledged.revision, 3); + assert_eq!(acknowledged.reserved_bytes, first_snapshot.reserved_bytes); + let late = reopened + .acknowledge_disclosure( + recipe.namespace(), + &second_operation, + &acknowledgement(&second), + ) + .await + .expect("late ACK"); + assert_eq!(late.stage, crate::DisclosureStage::Acknowledged); + assert_eq!(late.revision, 4); + assert_eq!(late.reserved_deliveries, 1); + let ack_bytes = store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("ACK record"); + let again = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(path).expect("reopen after ACK")), + policy.clone(), + ) + .expect("attempts"); + assert_eq!( + again + .acknowledge_disclosure(recipe.namespace(), &operation, &first_ack) + .await + .expect("ACK replay"), + acknowledged + ); + assert_eq!( + store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("ACK record"), + ack_bytes + ); + assert!( + again + .synthetic_disclosure_grant(&first, NOW, false) + .await + .is_err(), + "history cannot regrant" + ); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &disabled, + &original_connection, + ) + .expect("restore connection"); + let public_history = serde_json::to_string(&history).expect("public history"); + for private in [ + "PRIVATE-SYNTHETIC-CONTENT", + "commitment", + "recipient", + "channel", + "source_contract", + ] { + assert!(!public_history.contains(private), "{private}"); + } + let fixture = json!({"schema": "auths.gateway-disclosure-journal-fixture/1", + "scope": "native installed file admission with real retained HTTP source; no authenticated delivery; synthetic grant assumptions only; no independent process, PostgreSQL or isolation claim", + "expired_approval_refused": true, "changed_source_refused": true, "disabled_connection_refused": true, + "concurrent_same_operation_one_allocation": true, "changed_binding_conflicts": true, "record_mutations_and_obsolete_schema_refused": true, + "ack_before_grant_refused": true, "cross_protocol_refused": true, + "reopened_replay_preserves_record": true, + "ack_history": {"assumption": "test-only synthetic retained grants, no recipient authentication or delivery", "foreign_ack_refused": true, + "concurrent_exact_ack_preserves_revision": true, "ack_after_connection_disable": true, + "acknowledged": acknowledged, "late_acknowledged": late}, "history": history}); + let output = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/disclosure-journal.json"); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture bytes"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &bytes).expect("write"); + } + assert_eq!(std::fs::read(&output).expect("fixture"), bytes); + json!({"fixture": "disclosure-journal.json", "admissions": 16, "refusals": 2, "delivered_bytes": 0}) +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 9c1c9aad5..3198e269a 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -12,6 +12,9 @@ use ed25519_dalek::{Signer as _, SigningKey}; #[path = "effect_candidate_tests.rs"] mod candidate_tests; +#[path = "effect_disclosure_journal_tests.rs"] +mod disclosure_journal_tests; + #[path = "effect_content_tests.rs"] mod content_tests; diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 9514d70f1..8ca3c8d7d 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -239,7 +239,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/13", + "attempt_schema": "auths.gateway-attempt/14", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 9bcc87e5c..6f1491bfe 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1279,6 +1279,135 @@ impl GatewayEngine { .map_err(|_| not_entered("gateway.acquisition.binding")) } + /// Loads only validated retained provenance and proposes a private recipient + /// binding. This authenticates neither a live peer nor release authority. + /// + /// # Errors + /// Refuses absent, corrupt, rejected or unknown source content and invalid keys. + pub async fn disclosure_target( + &self, + source_operation: &str, + recipient_key: [u8; 32], + channel: [u8; 32], + delivery_instance: [u8; 32], + ) -> Result { + let operation = crate::LogicalOperationId::parse(source_operation) + .map_err(|_| not_entered("gateway.disclosure.binding"))?; + let source = self + .attempts + .retained_content(self.recipe.namespace(), &operation) + .await + .map_err(|_| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + })?; + crate::effect::DisclosureTarget::new(source, recipient_key, channel, delivery_instance) + .map_err(|_| not_entered("gateway.disclosure.binding")) + } + + /// Compiles fresh native disclosure authority under current installation. + /// Returns private review/approval data; performs no delivery or custody. + /// + /// # Errors + /// Refuses changed source/installation or invalid independent release proof. + pub async fn compile_disclosure_effect( + &self, + target: &crate::effect::DisclosureTarget, + proof: &[u8], + action: &[u8], + ) -> Result { + let (loaded, now) = self.effect_compilation_inputs().await?; + crate::effect::compile_disclosure( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + target, + now, + proof, + action, + ) + } + + /// Reserves an exactly approved disclosure in the shared journal, without + /// releasing content or granting delivery. Exact replay returns retained facts. + /// Current authority/configuration and source provenance are fenced together. + /// + /// # Errors + /// Refuses invalid authority/approval, changed installation or source, conflicts + /// and unavailable state. No error or reservation grants delivery permission. + pub async fn admit_disclosure( + &self, + target: &crate::effect::DisclosureTarget, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self + .compile_disclosure_effect(target, proof, action) + .await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + if let Some(snapshot) = self + .attempts + .read_disclosure(&approved) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => { + not_entered("gateway.effect.operation-conflict") + } + _ => GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }, + })? + { + return Ok(snapshot); + } + let io = EngineIo { + engine: self, + pending: std::sync::Mutex::new(None), + started, + prepared: OnceLock::new(), + #[cfg(unix)] + commissioning: None, + #[cfg(unix)] + commissioned_action: OnceLock::new(), + #[cfg(unix)] + commissioning_refusal: OnceLock::new(), + }; + io.prepare().await.map_err(not_entered)?; + let validation = io.entry_validation().map_err(not_entered)?; + match self + .attempts + .claim_disclosure(&approved, now, validation) + .await + { + Ok(snapshot) => Ok(snapshot), + Err(crate::GatewayAttemptError::BindingConflict) => { + Err(not_entered("gateway.effect.operation-conflict")) + } + Err(_) => self + .attempts + .read_disclosure(&approved) + .await + .ok() + .flatten() + .ok_or_else(|| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }), + } + } + /// Compiles a declared content GET from exact resource arguments using /// fresh independent native read authority. Performs no custody or provider /// I/O and returns private review/approval data only. diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 273520b21..c0bafc808 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -136,15 +136,15 @@ pub use separation::{ }; pub use store::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, - ClaimedGatewayAttempt, ContentProjectionStatus, FileGatewayAttemptStore, GatewayAttemptError, - GatewayAttemptKey, GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, - GatewayAttempts, GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, - GatewayFenceDecision, GatewayInsert, GatewayObservationFact, GatewayOperationStage, - GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, - GatewayRecoveryReport, GatewayRelativeBasis, ObservableGatewayAttempt, - PostgresGatewayAttemptStore, PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, - RecoverySourceFacts, ReservedAcquisition, RetainedContent, check_private_directory, - check_private_directory_owned_by, pre_entry_digest, + ClaimedGatewayAttempt, ContentProjectionStatus, DisclosureSnapshot, DisclosureStage, + FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptSnapshot, + GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, GatewayCounterEntry, + GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, GatewayInsert, + GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, + GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, + ObservableGatewayAttempt, PostgresGatewayAttemptStore, PrivateDirectoryError, + RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, + RetainedContent, check_private_directory, check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index e5edb64f5..0f10a0672 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/13"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/14"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index bc6b346bc..2a9d8302d 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,7 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.disclosure.exhausted effect admission new 74 -", "gateway.disclosure.binding effect compile new 74 -", "gateway.disclosure.unsupported-bounds effect compile new 74 -", "gateway.content.response-version ContentProjectionError response new 74 -", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 655186c65..215bf4626 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/13"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/14"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index ef89b1cd3..840f00685 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/13", + "store_schema": "auths.gateway-attempt/14", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index df4858dad..c418b2cd9 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/13"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/14"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/13", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/14", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 18e3bb859..c819dfb95 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "75d590f9ffbc5d53bb7fb52719fdba4f8c496929cafb632f48fe3eb86291e438"; + "6f0865c42e5c3da44502a453e2aca70342c3bc88bcf7e8a82080becfef2380ab"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index a8436d0b9..4a80f1a62 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/13`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/14`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/13"; +const SCHEMA: &str = "auths.gateway-attempt/14"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -179,6 +179,8 @@ pub enum GatewayOperationStage { Mutation(GatewayAttemptStage), /// Provider acquisition facts; never mutation success or recipient delivery. Acquisition(AcquisitionStage), + /// Recipient disclosure facts, never provider observations. + Disclosure(DisclosureStage), } impl GatewayOperationStage { @@ -186,6 +188,7 @@ impl GatewayOperationStage { match self { Self::Mutation(_) => "mutation", Self::Acquisition(_) => "acquisition", + Self::Disclosure(_) => "disclosure", } } } @@ -704,16 +707,19 @@ impl Record { enum ProtocolState { Mutation(MutationState), Acquisition(acquisition::AcquisitionState), + Disclosure(disclosure::DisclosureState), } mod acquisition; mod capacity; +mod disclosure; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, ContentProjectionStatus, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, RetainedContent, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; +pub use disclosure::{DisclosureSnapshot, DisclosureStage}; trait JournalProtocol: Clone + Sized { fn wrap(self) -> ProtocolState; @@ -729,7 +735,9 @@ impl JournalProtocol for MutationState { fn extract(state: ProtocolState) -> Result { match state { ProtocolState::Mutation(state) => Ok(state), - ProtocolState::Acquisition(_) => Err(GatewayAttemptError::BindingConflict), + ProtocolState::Acquisition(_) | ProtocolState::Disclosure(_) => { + Err(GatewayAttemptError::BindingConflict) + } } } fn view(record: &Record) -> Result { @@ -2273,6 +2281,12 @@ impl GatewayAttempts { return Ok(None); } let stage = match &record.state { + ProtocolState::Disclosure(_) => GatewayOperationStage::Disclosure( + record + .map_state(disclosure::DisclosureState::extract)? + .disclosure_snapshot()? + .stage, + ), ProtocolState::Mutation(_) => GatewayOperationStage::Mutation( record .map_state(MutationState::extract)? @@ -2859,6 +2873,12 @@ fn decode_protocol(bytes: &[u8]) -> Result, GatewayAttempt serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; record.validate_header()?; match &record.state { + ProtocolState::Disclosure(_) => { + let typed = record + .clone() + .map_state(disclosure::DisclosureState::extract)?; + disclosure::DisclosureState::validate(&typed)?; + } ProtocolState::Mutation(_) => { let typed = record.clone().map_state(MutationState::extract)?; MutationState::validate(&typed)?; diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index f799a7eeb..3fe287ea8 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -7,6 +7,7 @@ use crate::effect::{AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, S mod content; use content::ContentResult; +pub(super) use content::retained; pub use content::{ContentProjectionStatus, RetainedContent}; mod candidate; pub use candidate::CandidatePublication; @@ -119,7 +120,9 @@ impl JournalProtocol for AcquisitionState { fn extract(state: ProtocolState) -> Result { match state { ProtocolState::Acquisition(state) => Ok(state), - ProtocolState::Mutation(_) => Err(GatewayAttemptError::BindingConflict), + ProtocolState::Mutation(_) | ProtocolState::Disclosure(_) => { + Err(GatewayAttemptError::BindingConflict) + } } } @@ -1240,7 +1243,7 @@ fn insert_acquisition( /// A source connection can also be a native dependency. Read it once under the /// fence and retain each consumer's index; never drop either validation. -fn append_dependencies( +pub(super) fn append_dependencies( keys: &mut Vec<(GatewayRecordKind, GatewayAttemptKey)>, dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], ) -> Vec { @@ -1258,7 +1261,7 @@ fn append_dependencies( .collect() } -fn select_snapshots( +pub(super) fn select_snapshots( snapshots: &[Option>], indices: &[usize], ) -> Result>>, GatewayAttemptError> { diff --git a/product/runtime/auths-gateway/src/store/acquisition/content.rs b/product/runtime/auths-gateway/src/store/acquisition/content.rs index 3b915178b..ef71c51ba 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/content.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/content.rs @@ -55,25 +55,37 @@ impl GatewayAttempts { .await? .ok_or(GatewayAttemptError::Unavailable)?; let bytes = Zeroizing::new(bytes); - let record: Record = decode_as(&bytes)?; - let source = record.validate_header()?; - if !self.policy.contains(&source) - || source.journal_identity().0 != namespace.as_str() - || source.journal_identity().1 != operation.as_str() + let (content, _) = retained(&bytes)?; + if !self.policy.contains(&content.source) + || content.source.journal_identity().0 != namespace.as_str() + || content.source.journal_identity().1 != operation.as_str() { return Err(GatewayAttemptError::BindingConflict); } - let AcquisitionPlan::Content(plan) = &record.state.plan else { - return Err(GatewayAttemptError::InvalidTransition); - }; - let AcquisitionPhase::ContentResponseRecorded { - content: ContentResult::Ready(content), - .. - } = &record.state.phase - else { - return Err(GatewayAttemptError::InvalidTransition); - }; - Ok(RetainedContent { + Ok(content) + } +} + +/// The same bounded source validation runs on snapshots held by the journal +/// writer fence. It has no I/O and does not turn stored facts into a permit. +pub(in crate::store) fn retained( + bytes: &[u8], +) -> Result<(RetainedContent, u64), GatewayAttemptError> { + let record: Record = decode_as(bytes)?; + let source = record.validate_header()?; + let AcquisitionPlan::Content(plan) = &record.state.plan else { + return Err(GatewayAttemptError::InvalidTransition); + }; + let AcquisitionPhase::ContentResponseRecorded { + content: ContentResult::Ready(content), + response, + .. + } = &record.state.phase + else { + return Err(GatewayAttemptError::InvalidTransition); + }; + Ok(( + RetainedContent { source, commitment: content.commitment, projection: plan @@ -83,8 +95,9 @@ impl GatewayAttempts { review: plan .private_review() .map_err(|_| GatewayAttemptError::Corrupt)?, - }) - } + }, + response.received_at, + )) } #[derive(Clone, Deserialize, Serialize)] diff --git a/product/runtime/auths-gateway/src/store/disclosure.rs b/product/runtime/auths-gateway/src/store/disclosure.rs new file mode 100644 index 000000000..f8d5e9305 --- /dev/null +++ b/product/runtime/auths-gateway/src/store/disclosure.rs @@ -0,0 +1,564 @@ +//! Disclosure facts in the existing operation journal and transaction contract. +//! Admission reserves capacity only. Persisted facts never mint a delivery permit. +use super::acquisition::{append_dependencies, select_snapshots}; +use super::*; +use crate::effect::{DisclosureAcknowledgement, DisclosurePlan}; + +/// Redacted disclosure facts, separate from provider response and observation. +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +pub struct DisclosureSnapshot { + /// Exact retained journal revision. + pub revision: u64, + /// A retained grant without an ACK is conservatively unknown. + pub stage: DisclosureStage, + /// Stable pre-entry refusal, when the reservation was not admitted. + #[serde(skip_serializing_if = "Option::is_none")] + pub refusal: Option, + /// Permanent source invocation allocation; empty delivery also consumes one. + pub reserved_deliveries: u64, + /// Exact projected-byte allocation, retained on uncertainty. + pub reserved_bytes: u64, + /// Fixed-window native policy count counters. + pub policy_count_counters: u64, + /// Fixed-window native policy byte counters. + pub policy_byte_counters: u64, +} + +/// Disclosure cannot record provider responses or mutation observations. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub enum DisclosureStage { + /// Reservation has no delivery permission. + Reserved, + /// Closed before any delivery grant. + NotEntered, + /// Delivery may have happened; no redelivery or refund follows. + Unknown, + /// Exact authenticated recipient assertion, not proof of human attention. + Acknowledged, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct DisclosureState { + plan: DisclosurePlan, + allocation: Option, + counters: Vec, + phase: DisclosurePhase, +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(tag = "stage", rename_all = "kebab-case", deny_unknown_fields)] +enum DisclosurePhase { + Reserved, + NotEntered { code: String }, + EntryGranted, + Unknown, + Acknowledged { acknowledgement: String }, +} + +impl DisclosurePhase { + const fn kernel(&self) -> transition::Stage { + match self { + Self::Reserved => transition::Stage::Reserved, + Self::NotEntered { .. } => transition::Stage::NotEntered, + Self::EntryGranted => transition::Stage::EntryGranted, + Self::Unknown => transition::Stage::Unknown, + Self::Acknowledged { .. } => transition::Stage::Acknowledged, + } + } +} + +impl JournalProtocol for DisclosureState { + fn wrap(self) -> ProtocolState { + ProtocolState::Disclosure(self) + } + fn extract(state: ProtocolState) -> Result { + match state { + ProtocolState::Disclosure(state) => Ok(state), + _ => Err(GatewayAttemptError::BindingConflict), + } + } + fn view(record: &Record) -> Result { + Ok(AttemptView { + protocol: transition::Protocol::Disclosure, + revision: record.revision, + fixed: canonical(&( + &record.schema, + &record.binding_canonical, + &record.approval_canonical, + &record.namespace, + &record.operation_id, + &record.action_commitment, + &record.recipe_digest, + &record.nonce, + record.evaluated_at, + &record.state.plan, + record.state.allocation, + &record.state.counters, + ))?, + entry: record + .entry + .as_ref() + .map(canonical) + .transpose()? + .unwrap_or_default(), + stage: record.state.phase.kernel(), + refusal: matches!(record.state.phase, DisclosurePhase::NotEntered { .. }), + acknowledgement: match &record.state.phase { + DisclosurePhase::Acknowledged { acknowledgement } => { + acknowledgement.as_bytes().to_vec() + } + _ => Vec::new(), + }, + response: Vec::new(), + pre_entry: Vec::new(), + locator: Vec::new(), + reading: Reading::None, + evidence: false, + observation: false, + link: Link::None, + }) + } + fn validate(record: &Record) -> Result<(), GatewayAttemptError> { + let binding = record.validate_header()?; + let capacity = record + .state + .plan + .validate(&binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let counters = capacity::decode_counters(&record.state.counters)?; + if record.state.allocation.is_some() { + let counts: Vec<_> = counters + .iter() + .filter(|c| c.kind == GatewayCounterKind::Count) + .map(|c| c.counter) + .collect(); + let sums: Vec<_> = counters + .iter() + .filter(|c| c.kind == GatewayCounterKind::Sum) + .map(|c| c.counter) + .collect(); + if !binding.matches_disclosure_counters(&counts, &sums) { + return Err(GatewayAttemptError::Corrupt); + } + } else if !counters.is_empty() { + return Err(GatewayAttemptError::Corrupt); + } + if !transition::consistent(&Self::view(record)?) + || record.entry.as_ref().is_some_and(|e| e.pre_entry.is_some()) + || match record.state.allocation { + Some(slot) => slot >= capacity.attempts, + None => !matches!(record.state.phase, DisclosurePhase::NotEntered { .. }), + } + { + return Err(GatewayAttemptError::Corrupt); + } + match &record.state.phase { + DisclosurePhase::NotEntered { code } if !valid_code(code) => { + return Err(GatewayAttemptError::Corrupt); + } + DisclosurePhase::Acknowledged { acknowledgement } => { + DisclosureAcknowledgement::from_private_bytes(acknowledgement.as_bytes()) + .and_then(|ack| ack.verify(&binding, capacity.maximum_bytes)) + .map_err(|_| GatewayAttemptError::Corrupt)?; + } + _ => {} + } + Ok(()) + } +} + +impl Record { + pub(super) fn disclosure_snapshot(&self) -> Result { + DisclosureState::validate(self)?; + let allocated = self.state.allocation.is_some(); + Ok(DisclosureSnapshot { + revision: self.revision, + stage: match self.state.phase { + DisclosurePhase::Reserved => DisclosureStage::Reserved, + DisclosurePhase::NotEntered { .. } => DisclosureStage::NotEntered, + DisclosurePhase::EntryGranted | DisclosurePhase::Unknown => { + DisclosureStage::Unknown + } + DisclosurePhase::Acknowledged { .. } => DisclosureStage::Acknowledged, + }, + refusal: match &self.state.phase { + DisclosurePhase::NotEntered { code } => Some(code.clone()), + _ => None, + }, + reserved_deliveries: u64::from(allocated), + reserved_bytes: if allocated { + self.state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)? + .maximum_bytes + } else { + 0 + }, + policy_count_counters: self + .state + .counters + .iter() + .filter(|c| c.kind == GatewayCounterKind::Count) + .count() as u64, + policy_byte_counters: self + .state + .counters + .iter() + .filter(|c| c.kind == GatewayCounterKind::Sum) + .count() as u64, + }) + } +} + +fn allocation( + plan: &DisclosurePlan, + key: GatewayAttemptKey, + slot: u64, +) -> Result { + capacity::SourceAllocation::new( + *plan + .source() + .map_err(|_| GatewayAttemptError::Corrupt)? + .id() + .as_bytes(), + &plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?, + key, + slot, + ) +} + +fn source_matches(plan: &DisclosurePlan, bytes: Option<&[u8]>) -> Result { + let (source, received_at) = + acquisition::retained(bytes.ok_or(GatewayAttemptError::Unavailable)?)?; + if !plan + .matches_source(&source) + .map_err(|_| GatewayAttemptError::Corrupt)? + { + return Err(GatewayAttemptError::BindingConflict); + } + Ok(received_at) +} + +impl GatewayAttempts { + /// Reads exact disclosure history only. No source fetch, credential lease, + /// recipient authentication or delivery occurs on replay. + /// + /// # Errors + /// Refuses protocol/partition/binding mismatches and corrupt/unavailable state. + pub async fn read_disclosure( + &self, + approved: &ApprovedEffect, + ) -> Result, GatewayAttemptError> { + approved + .disclosure_plan() + .map_err(|_| GatewayAttemptError::BindingConflict)?; + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let (namespace, operation, _, _) = binding.journal_identity(); + let key = self.key( + &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, + &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, + )?; + let store = Arc::clone(&self.store); + let Some(bytes) = blocking(move || store.load(GatewayRecordKind::Attempt, &key)).await? + else { + return Ok(None); + }; + let record: Record = decode_as(&bytes)?; + if record.validate_header()? != *binding { + return Err(GatewayAttemptError::BindingConflict); + } + record.disclosure_snapshot().map(Some) + } + + /// Atomic reservation only. Recipient authentication and the later fresh + /// grant are independent; this method cannot return any content or permit. + #[allow( + clippy::too_many_lines, + reason = "one atomic source and policy allocation admission under the existing writer fence" + )] + pub(crate) async fn claim_disclosure( + &self, + approved: &Arc, + evaluated_at: u64, + validation: crate::entry::EntryValidation, + ) -> Result { + let binding = approved.effect().binding(); + let plan = approved + .disclosure_plan() + .map_err(|_| GatewayAttemptError::BindingConflict)?; + let capacity = plan + .validate(binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let (namespace, operation, _, _) = binding.journal_identity(); + let namespace = + OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?; + let operation = + LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; + let key = self.key(&namespace, &operation)?; + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let source_operation = LogicalOperationId::parse(source.journal_identity().1) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let source_key = self.key(&namespace, &source_operation)?; + let bound = approved.disclosure_bound().cloned(); + let expected = String::from_utf8( + binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_vec(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let store = Arc::clone(&self.store); + let admission = Admission { + approved: Arc::clone(approved), + validation, + authorization_started_at: evaluated_at, + }; + let mut dependencies = vec![(GatewayRecordKind::Attempt, source_key)]; + let native_indices = append_dependencies(&mut dependencies, &admission.dependencies()); + let result = blocking(move || { + if store.load(GatewayRecordKind::Attempt, &key)?.is_some() { + return Err(existing_binding(&*store, key, &expected)); + } + let base = Record::new( + admission.approved.effect().binding(), + admission.approved.approval(), + evaluated_at, + DisclosureState { + plan, + allocation: None, + counters: Vec::new(), + phase: DisclosurePhase::Reserved, + }, + )?; + base.validate_header()?; + let mut candidate = bound + .as_ref() + .map(|b| capacity::CapacityCandidate::new(&*store, b)) + .transpose()?; + let mut slot = 0; + for _ in 0..MAX_CLAIM_ROUNDS { + let refusal = if slot >= capacity.attempts { + Some("gateway.disclosure.exhausted") + } else { + candidate + .as_ref() + .and_then(capacity::CapacityCandidate::refusal) + }; + let mut record = base.clone(); + let mut slots = Vec::new(); + if let Some(code) = refusal { + record.state.phase = DisclosurePhase::NotEntered { + code: code.to_owned(), + }; + } else { + record.state.allocation = Some(slot); + if let Some(candidate) = &candidate { + (record.state.counters, slots) = + candidate.batch(key, &record.namespace, &record.operation_id)?; + } + } + DisclosureState::validate(&record)?; + let mut entries = vec![GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + if refusal.is_none() { + entries.push(GatewayRecordEntry { + kind: GatewayRecordKind::EffectAllocation, + key: capacity::allocation_key(&capacity, slot), + record: canonical(&allocation(&record.state.plan, key, slot)?)?, + expires_at: None, + }); + entries.extend(slots); + } + let fenced_candidate = if refusal.is_none() { + candidate.as_ref() + } else { + None + }; + let native_end = dependencies.len(); + let mut fenced = dependencies.clone(); + if let Some(candidate) = fenced_candidate { + fenced.extend(candidate.dependencies()); + } + let outcome = store.fenced_insert_all(&entries, &fenced, &mut |snapshots| { + if snapshots.len() != fenced.len() { + return Err(GatewayAttemptError::Corrupt); + } + let received_at = source_matches(&record.state.plan, snapshots[0].as_deref())?; + admission.stamp(&mut record, &select_snapshots(snapshots, &native_indices)?)?; + if record.evaluated_at < received_at { + return Err(GatewayAttemptError::InvalidTransition); + } + if let Some(candidate) = fenced_candidate { + candidate.validate_predecessors(&snapshots[native_end..])?; + } + encode(&record) + })?; + match outcome { + GatewayInsert::Inserted => return record.disclosure_snapshot(), + GatewayInsert::Exists { index: 0 } => { + return Err(existing_binding(&*store, key, &base.binding_canonical)); + } + GatewayInsert::Exists { index: 1 } if refusal.is_none() => { + let bytes = store + .load( + GatewayRecordKind::EffectAllocation, + &capacity::allocation_key(&capacity, slot), + )? + .ok_or(GatewayAttemptError::Corrupt)?; + let occupied: capacity::SourceAllocation = + serde_json::from_slice(&bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + occupied.validate_occupied( + &allocation(&record.state.plan, key, slot)?, + &bytes, + )?; + slot += 1; + } + GatewayInsert::Exists { index } if refusal.is_none() => { + candidate + .as_mut() + .ok_or(GatewayAttemptError::Corrupt)? + .advance(&*store, index - 2)?; + } + _ => return Err(GatewayAttemptError::Corrupt), + } + } + Err(GatewayAttemptError::Conflict) + }) + .await; + match result { + Err(GatewayAttemptError::Replay) => self + .read_disclosure(approved) + .await? + .ok_or(GatewayAttemptError::Unavailable), + other => other, + } + } + + /// Adds an exact authenticated historical ACK to a retained disclosure + /// grant. Current authority/approval expiry cannot erase legitimate history. + /// Exact canonical replay returns the same revision. No delivery is retried. + /// + /// # Errors + /// Refuses absent grants, other protocols/partitions, substituted ACK fields, + /// conflicting evidence, corrupt state and failed/ambiguous persistence. + pub async fn acknowledge_disclosure( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + acknowledgement: &DisclosureAcknowledgement, + ) -> Result { + let key = self.key(namespace, operation)?; + // One concurrent evidence writer may win the CAS. Re-read once so an + // exact ACK becomes a read-only replay; no network effect is retried. + for _ in 0..2 { + let store = Arc::clone(&self.store); + let stored = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&stored)?; + let binding = record.validate_header()?; + if !self.policy.contains(&binding) + || binding.journal_identity().0 != namespace.as_str() + || binding.journal_identity().1 != operation.as_str() + { + return Err(GatewayAttemptError::BindingConflict); + } + let bytes = record + .state + .plan + .capacity() + .map_err(|_| GatewayAttemptError::Corrupt)? + .maximum_bytes; + let verified = acknowledgement + .verify(&binding, bytes) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + let view = DisclosureState::view(&record)?; + if transition::exact_acknowledgement_replay(&view, verified.as_private_bytes()) { + return record.disclosure_snapshot(); + } + let mut next = record.clone(); + next.state.phase = DisclosurePhase::Acknowledged { + acknowledgement: std::str::from_utf8(verified.as_private_bytes()) + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_owned(), + }; + match (Attempt { + store: Arc::clone(&self.store), + key, + stored, + record, + }) + .advance(next) + .await + { + Ok(attempt) => return attempt.record.disclosure_snapshot(), + Err(GatewayAttemptError::Conflict) => continue, + Err(error) => return Err(error), + } + } + Err(GatewayAttemptError::Conflict) + } +} + +/// Test-only retained grant assumption for exercising historical ACK persistence. +/// This returns no permit, authenticates no live peer and sends no bytes. +#[cfg(test)] +impl GatewayAttempts { + pub(crate) async fn synthetic_disclosure_grant( + &self, + approved: &ApprovedEffect, + now: u64, + unknown: bool, + ) -> Result { + let binding = approved.effect().binding(); + let (namespace, operation, _, _) = binding.journal_identity(); + let key = self.key( + &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, + &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, + )?; + let stored = self + .store + .load(GatewayRecordKind::Attempt, &key)? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&stored)?; + if record.validate_header()? != *binding { + return Err(GatewayAttemptError::BindingConflict); + } + let mut next = record.clone(); + next.record_grant(approved, now, now, None, &[])?; + next.state.phase = DisclosurePhase::EntryGranted; + if !valid_transition(&record, &next)? { + return Err(GatewayAttemptError::InvalidTransition); + } + let replacement = encode(&next)?; + self.store + .replace(GatewayRecordKind::Attempt, &key, &stored, &replacement)?; + let attempt = Attempt { + store: Arc::clone(&self.store), + key, + stored: replacement, + record: next, + }; + if unknown { + let mut next = attempt.record.clone(); + next.state.phase = DisclosurePhase::Unknown; + attempt.advance(next).await?.record.disclosure_snapshot() + } else { + attempt.record.disclosure_snapshot() + } + } +} diff --git a/product/runtime/auths-gateway/src/support.rs b/product/runtime/auths-gateway/src/support.rs index 6f1d50720..dee15bc4e 100644 --- a/product/runtime/auths-gateway/src/support.rs +++ b/product/runtime/auths-gateway/src/support.rs @@ -80,6 +80,12 @@ const fn stage_token(stage: GatewayOperationStage) -> &'static str { GatewayAttemptStage::Observed => "observed", GatewayAttemptStage::ObservedByProvider => "observed-by-provider", }, + GatewayOperationStage::Disclosure(stage) => match stage { + crate::DisclosureStage::Reserved => "reserved", + crate::DisclosureStage::NotEntered => "not-entered", + crate::DisclosureStage::Unknown => "unknown", + crate::DisclosureStage::Acknowledged => "acknowledged", + }, GatewayOperationStage::Acquisition(stage) => match stage { AcquisitionStage::Reserved => "reserved", AcquisitionStage::EntryGranted => "entry-granted", From d5cfeb9996b73edb2d9a0175e33b20a14bc14980 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 22:18:20 +0000 Subject: [PATCH 054/136] feat(gateway)!: fence authenticated one-use Unix disclosures --- .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/codes.json | 72 +++ .../fixtures/gateway/content-journal.json | 3 +- .../fixtures/gateway/disclosure-delivery.json | 58 ++ .../fixtures/gateway/prerequisite-entry.json | 2 +- compliance.toml | 13 +- ...017-bound-effect-and-recovery-ownership.md | 64 +- .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 4 +- docs/plans/0074-implementation-status.md | 53 +- .../0009-bound-effect-and-recovery.md | 28 +- ...ound-effects-and-recovery-state-machine.md | 51 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6577 -> 6577 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6460 -> 6460 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5732 -> 5732 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5031 -> 5031 bytes .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/disclosure_transport.rs | 285 +++++++++ product/runtime/auths-gateway/src/effect.rs | 10 +- .../src/effect/disclosure_auth.rs | 203 +++++++ .../auths-gateway/src/effect/release.rs | 4 + .../src/effect_disclosure_delivery_tests.rs | 555 ++++++++++++++++++ .../src/effect_disclosure_journal_tests.rs | 58 +- .../src/effect_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 141 +++++ product/runtime/auths-gateway/src/lib.rs | 2 + .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 9 + .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 6 +- .../auths-gateway/src/store/acquisition.rs | 2 + .../src/store/acquisition/content.rs | 21 + .../auths-gateway/src/store/disclosure.rs | 216 ++++++- 40 files changed, 1834 insertions(+), 54 deletions(-) create mode 100644 bindings/fixtures/gateway/disclosure-delivery.json create mode 100644 product/runtime/auths-gateway/src/disclosure_transport.rs create mode 100644 product/runtime/auths-gateway/src/effect/disclosure_auth.rs create mode 100644 product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 5bfeb3fa3..eb0ee906e 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/14", + "attempt_schema": "auths.gateway-attempt/15", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index db0d1c46d..51422d8c4 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -370,6 +370,22 @@ "epic": 3, "case": null }, + { + "code": "gateway.disclosure.acknowledgement", + "owner": "disclosure_transport", + "stage": "acknowledgement", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.authentication", + "owner": "disclosure_transport", + "stage": "authentication", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.disclosure.binding", "owner": "effect", @@ -378,6 +394,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.disclosure.channel", + "owner": "disclosure_transport", + "stage": "authentication", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.disclosure.exhausted", "owner": "effect", @@ -386,6 +410,46 @@ "epic": 74, "case": null }, + { + "code": "gateway.disclosure.frame", + "owner": "disclosure_transport", + "stage": "transport", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.length", + "owner": "disclosure_transport", + "stage": "transport", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.peer", + "owner": "disclosure_transport", + "stage": "authentication", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.read", + "owner": "disclosure_transport", + "stage": "transport", + "status": "new", + "epic": 74, + "case": null + }, + { + "code": "gateway.disclosure.timeout", + "owner": "disclosure_transport", + "stage": "transport", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.disclosure.unsupported-bounds", "owner": "effect", @@ -394,6 +458,14 @@ "epic": 74, "case": null }, + { + "code": "gateway.disclosure.write", + "owner": "disclosure_transport", + "stage": "transport", + "status": "new", + "epic": 74, + "case": null + }, { "code": "gateway.echo-verify.absent", "owner": "echo-verify", diff --git a/bindings/fixtures/gateway/content-journal.json b/bindings/fixtures/gateway/content-journal.json index 2dccf84b5..919ab12ba 100644 --- a/bindings/fixtures/gateway/content-journal.json +++ b/bindings/fixtures/gateway/content-journal.json @@ -470,6 +470,7 @@ "fixture": "disclosure-journal.json", "admissions": 16, "refusals": 2, - "delivered_bytes": 0 + "journal_only_delivered_bytes": 0, + "unix_delivery_fixture": "disclosure-delivery.json" } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/disclosure-delivery.json b/bindings/fixtures/gateway/disclosure-delivery.json new file mode 100644 index 000000000..e49ac1063 --- /dev/null +++ b/bindings/fixtures/gateway/disclosure-delivery.json @@ -0,0 +1,58 @@ +{ + "schema": "auths.gateway-disclosure-delivery-fixture/1", + "scope": "real Unix socket pairs and installed native file fence; no independent processes, hostile UID isolation or PostgreSQL claim", + "authenticated_delivery": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "lost_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "late_ack": { + "revision": 4, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "competing_live_channels": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "approval_expired_after_authentication_refused": true, + "configuration_changed_after_authentication_refused": true, + "corrupt_source_after_authentication_refused": true, + "retained_authentication_corruption_refused": true, + "dropped_permit": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 25, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "reopened_grant_cannot_redeliver": true, + "disable_after_authentication_refuses_entry": true, + "wrong_recipient_signing_key_refused": true, + "changed_authentication_fields_refused": true, + "wrong_os_uid_refused": true, + "fresh_challenge_substitution_refused": true, + "wrong_key_response_refused": true, + "duplicate_unknown_noncanonical_oversized_frames_refused": true, + "noncanonical_and_oversized_authentication_refused": true, + "historical_authentication_grants_no_socket": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 986cd1a13..362c8d054 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/14", + "attempt_schema": "auths.gateway-attempt/15", "cases": [ { "recipe": "stripe", diff --git a/compliance.toml b/compliance.toml index 9ab133712..f69b77298 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/14", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/15", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1604,17 +1604,20 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/14", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/15", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] -transports = ["bounded-https", "postgresql-tls", "loopback-http-development"] +transports = ["uid-bound-unix-disclosure","bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +disclosure-local-socket-file-grant = [ + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", +] disclosure-journal-admission = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 3f0ec2a1c..eae3e6dfe 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -860,7 +860,7 @@ cutover remain required; this evidence grants no provider qualification. ## Protected content in the response transaction -Attempt `/13` extends the existing content response fact with one closed +Attempt `/15` retains the existing content response fact with one closed protected/refused result. Projection and key generation happen before the same response acknowledgement; a crash cannot leave a published content identifier without its retained response, or re-create a provider permit. Loading recomputes @@ -926,7 +926,7 @@ acquisition allocator into a second disclosure ledger. ## Disclosure admission and historical ACK journal -Attempt `/14` adds the closed disclosure state to the existing `JournalProtocol` +Attempt `/15` retains the closed disclosure state to the existing `JournalProtocol` projection. The existing kernel reducer remains the sole transition decision; file/PostgreSQL adapters retain their existing fenced insert/replace/CAS contract. The plan is data only and validates source scope, installation, projection, exact @@ -934,7 +934,7 @@ length, recipient key and typed reservations against the bound effect. Admission loads and validates the retained acquisition under the same writer fence as native configuration/authority. It atomically inserts one permanent source allocation and the existing count/sum policy slots. No disclosure ledger, callback, provider -request or second capacity authority is introduced. Obsolete `/13` is rejected. +request or second capacity authority is introduced. Obsolete `/14` is rejected. The protocol's immutable ACK field is verified on every decode. Historical ACK recording needs an existing grant and the common reducer, not fresh execution @@ -942,7 +942,7 @@ authority. A concurrent identical ACK can be recognized after one bounded reload revision and charges remain unchanged. Public snapshots and support listings keep provider/acquisition/recipient facts distinct and contain no private correlations. Engine proposal/compile/admit operations have no delivery capability or custody. -The final recipient-authenticated grant and one-use transport remain unwired. +The final recipient-authenticated grant and one-use transport use the boundary below. `disclosure-journal.json` constructs real HTTP source content then executes native installed file admission, duplicate claim concurrency, changed source/connection/ @@ -952,3 +952,59 @@ synthetic retained grants, exercise the real durable CAS/decoder/reducer, and as pre-grant/foreign refusal, concurrent exact replay and late evidence after disabling the connection. They do not establish recipient authentication, actual send, independent-process isolation or PostgreSQL qualification. + +## Local authenticated disclosure channel boundary + +The first delivery transport uses an owned Unix stream, not an arbitrary callback +or provider credential. A native channel commitment pins gateway UID, recipient +UID and an operator-selected channel identifier. Both peers check kernel peer UID +and their effective UID. The recipient additionally signs a freshly sampled +challenge bound to the complete native ACK statement under a distinct +`auths.gateway-disclosure-auth/1` domain. Authentication never signs an ACK or +claims receipt. The owned stream and bounded authentication transcript must remain +sealed through the final journal fence and the one-use send permit. + +The existing gateway admin listener already uses Tokio peer credentials. The +exchange Unix adapter supplies peer observations but does not bind this recipient, +effect, UID pair or fresh challenge; reusing its generic authenticated-server +label would not establish the needed fact. Reuse the pinned Tokio/rustix/Ed25519 +primitives and native canonical/domain codec without adding a dependency or a new +network authority framework. Native authority and exact approval still run at +final entry; channel authentication cannot substitute for either. + +This is local transport under kernel/UID/socket-access isolation. A recipient must +receive the expected effect and channel policy on its trusted private authoring +channel and check the gateway UID before signing. A same-UID synthetic socket test +establishes protocol behavior only, not hostile-process isolation. A malicious +host, gateway UID or recipient key holder can bypass or forward their own data; +that is outside this boundary. The retained MAC is opaque to the recipient: the +trusted gateway binds its exact projected bytes to that identifier, and the +recipient ACKs only after receiving the declared exact length on this channel. + + +The concrete final grant fences the attempt, protected source, permanent source +allocation, native connection/configuration dependencies and selected count/sum +slots in the existing transaction. It validates full native authority/approval and +the owned live channel, reconstructs exact content from the validated source, and +persists entry plus authentication atomically. Only acknowledged persistence +returns `DisclosureEntryPermit`; transport consumes it once. Neither a serialized +transcript nor a retained grant can recreate it. The existing transition owner +freezes `(EntryAudit, RecipientAuthentication)` as one immutable entry value. +Attempt `/15` rejects missing/invalid authentication on a disclosure grant and +rejects obsolete `/14`; no second reducer, store or compatible decoder exists. + +Framing is a four-byte unsigned big-endian length checked before allocation, +4,096 bytes for canonical authentication/ACK and 65,536 bytes for content, with +exact projected length. Authentication expires after five seconds; the whole +session expires after fifteen seconds, including final fence wait and send/ACK. +A transport timeout does not refresh native evidence or refund reservations. +The gateway deployment clock remains the final authority/freshness owner. + +`disclosure-delivery.json` is constructed from actual socket pairs and native +installed file grants over retained HTTP source content. It exercises actual +receipt/ACK, loss of ACK with reopened no-redelivery and late refinement, dropped +permits, competing authenticated channels, and connection/configuration/approval +changes after authentication. Authentication substitutions, malformed frames and +corrupt retained authentication refuse. This evidence is separate from the older +synthetic-grant corpus; neither establishes independent-process containment, +PostgreSQL parity, installed UI/bindings or completion of AP074 acceptance cases. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 00a82df96..58f58cf8f 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -106,7 +106,7 @@ and full acceptance evidence remain open AP074 requirements. Compiler `/8` exposes native candidate-check compilation for an exact staged first-install or rotation descriptor. The corresponding engine acquisition API -now uses journal `/14` and entry audit `/3`: predecessor/absence, current native +now uses journal `/15` and entry audit `/3`: predecessor/absence, current native authority and all earlier check evidence are fenced before reads. It leases only the exact already-staged credential and returns redacted acquisition facts. This API does not publish credentials. The onboarding/rotation CLI staging and @@ -188,7 +188,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/14`; a store holding obsolete records is refused as + `auths.gateway-attempt/15`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 3e4115fe3..e7134e3f3 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1288,6 +1288,49 @@ closure regeneration passed after that correction (one artifact-generation test) binding/UI cutovers, complete P4 evidence and hosted CI remain outstanding. No A01–A22 case is closed by this checkpoint; no broad local or hosted gate ran. +## Authenticated disclosure entry and transport checkpoint + +- Based on pushed `3f23e5f3`. The preceding status-only turn changed no source; + this continuation finishes the pending native grant and Unix transport slice. +- `UnixDisclosurePolicy` commits exact gateway/recipient UIDs and a private channel + identifier. Both peers check OS credentials; the recipient signs a fresh + challenge over the full bound delivery statement under an authentication domain + distinct from ACK. The owned socket remains sealed through the final grant. +- Final disclosure entry uses the existing writer fence and sole reducer. It + revalidates retained source/MAC, native proof/approval/configuration, permanent + source allocation and managed policy membership before persisting the immutable + authentication transcript plus entry audit. Only acknowledged persistence + returns the one-use send permit. Attempt `/15` rejects obsolete `/14` and + granted records lacking valid authentication. Historical decode creates no + socket or permit. Public projections remain redacted. +- `GatewayEngine::disclose` composes admission, fresh recipient authentication, + final native entry and exact retained-byte delivery. Recipient code explicitly + ACKs after complete receipt or retains native evidence for late recording. + Authentication/ACK frames are bounded to 4,096 canonical bytes, content to + 65,536 and exact projected length. Five-second handshake/fifteen-second session + deadlines supplement, never replace, native fenced authority time. +- Required artifact construction passed five exact generators in 8.94 seconds: + content journal (now also producing `disclosure-delivery.json`), code inventory, + attempt scenarios, prerequisite compilation and native entry/fuzz corpus. + Extended content/delivery generation then passed in 5.31 seconds. New source + evidence uses actual Unix socket pairs and the installed native file fence over + a real retained HTTP response. It covers actual receipt/ACK, lost ACK, reopened + no-redelivery, late ACK, dropped permit, competing authenticated channels with + one winner, and connection/configuration/approval/source changes after + authentication. It also refuses wrong UID/key/nonce, malformed/duplicate/ + unknown/noncanonical/oversized authentication and corrupted retained proofs. +- The configuration-change fixture initially named a nonexistent store variant + and passed a raw key. It now uses `EffectConfiguration` and the native key + wrapper; the repaired artifact passed without changing production checks. +- Final content/disclosure and semantic-closure artifact construction passed + together (two exact tests, 5.31 seconds). Fetch found no upstream commits. +- The earlier synthetic-grant ACK corpus remains explicitly scoped historical + unit evidence. New socket/file evidence is not an independent-process crash, + PostgreSQL, hostile-agent isolation, full engine/CLI/UI or A07/A08/A22 closure. + These, AP070 source-owner removal, standalone read-only installation, maintained + consumers and complete P4 evidence remain required. No broad local gate, + formal execution or hosted CI observation was run. AP073 remains untouched. + ## Phase gates | Phase | State | Outstanding gate | @@ -1295,7 +1338,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition runtime, disclosure admission and historical ACK persistence wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), authenticated disclosure grant/transport; remove Python semantic owner | +| P3 | Acquisition and authenticated Unix disclosure runtime wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), application/CLI/binding disclosure integration; remove Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -1312,12 +1355,12 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission, prerequisite and managed read charge fixtures | Full adapter concurrency and all units pending | | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | -| A07 | Revoke between acquisition and disclosure | Pending / no / no | Separate disclosure gate | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer and file journal corpus / ACK persistence/replay under synthetic grants executed | Authenticated disclosure grant, actual send/ACK loss and process restart pending | -| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Authenticated live recipient/channel and complete delivery integration pending | +| A07 | Revoke between acquisition and disclosure | Partial / socket-file corpus / connection disabled after authentication refuses entry | Independent-process revocation and installed journey pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer and socket-file corpus / actual send/ACK loss, reopen without redelivery and late ACK executed | Independent-process crash and installed runtime journey pending | +| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | -| A12 | Revocation/configuration races with both entries | Pending / no / no | Shared transaction order | +| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate / dependency changes after authentication and competing live grants executed | Full independent-process races on both adapters pending | | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and signed-observation cases / narrow file and native predicate fixtures | Installed lock-wait, independent expiry and adapter races pending | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 2c89b2a0b..5f1fb33cb 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -638,10 +638,34 @@ the existing writer fence, alongside selected native dependencies and permanent source/fixed-window slots. The count/sum arithmetic, immutable allocation encoding, replay-key comparison and CAS transition owner remain shared. Provider evidence and recipient ACK bytes remain divergent typed fields; no generic success outcome is -introduced. The native engine can reserve a disclosure but cannot deliver it yet. +introduced. The native engine reserves and delivers through the sealed Unix +channel boundary below. The file corpus adds real-source admission/exhaustion/replay and decoder mutations. A synthetic retained-grant assumption enables real ACK persistence/concurrency and late-history comparisons; it is explicitly not live recipient authentication or -transport evidence. The production grant/transport and complete differential and +transport evidence. The original corpus does not establish transport; complete differential and performance gates remain outstanding. + + +### Authenticated local disclosure instance + +The new Unix transport reuses kernel UID observations and pinned cryptographic +primitives, adding a closed fresh challenge over the exact native delivery +statement. It does not repurpose provider response evidence or generic exchange +server authentication as recipient possession. A proposed channel policy and a +serialized historical transcript are data; only the owned authenticated stream +can participate in the final native fenced decision. Only its acknowledged grant +constructs a one-use content permit. The source projection and protected-content +validator remain the acquisition owner; recipient code cannot supply a second +plaintext or destination to the send function. + +The identical shared leaves remain native verification/recompile, exact approval, +writer fencing, source/counter allocation membership, durable acknowledgement and +immutable entry/evidence transitions. The distinct disclosure instance fixes a +local UID/key/channel handshake and exact byte length with explicit bounded +framing and deadlines. It adds no provider dispatch or policy callback. The real +socket-pair/file artifact exercises ACK loss, late evidence, fresh-authentication +replay, dropped permit, one-winner concurrency and dependency changes before the +final fence. Independent processes/adapters, complete recipe differential and +performance evidence remain required by the extraction and AP074 exit gates. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index e82b4f4ca..5d8ca0634 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -323,7 +323,7 @@ read proof/approval. Custody is checked for the exact staged reference before publication; independently stored custody and connection state are not claimed to be one atomic transaction. -The concrete journal encoding is `auths.gateway-attempt/14`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/15`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded @@ -411,9 +411,9 @@ encoding facts. Each header is missing, one value of at most 128 bytes, or inval by decoding a content record as ordinary prerequisite/recovery evidence. The typed `content-response-recorded` phase projects to the existing acquisition -response stage under the sole reducer. Attempt schema `/14` atomically retains +response stage under the sole reducer. Attempt schema `/15` atomically retains one additional closed result: protected content or a typed projection refusal. -Obsolete `/13` records are rejected; no compatibility decoder or migration exists. +Obsolete `/14` records are rejected; no compatibility decoder or migration exists. Required-version agreement, identity encoding, one valid media type and the exact compiled projection must all hold before protected content is constructed. Encoding may be absent or a single case-insensitive `identity` value; compressed @@ -444,7 +444,7 @@ or new provider permit. Unknown/oversized responses retain their full charges. The public acquisition projection reports only `ready { bytes }` or `rejected { code }`, never the private key, content digest, hiding commitment or plaintext. A ready result grants no disclosure authority. Standalone read-only -installation, AP070 metadata predicates, disclosure entry/transport and installed +installation, AP070 metadata predicates and installed CLI/binding journeys remain required for the cutover. The journal's sealed `RetainedContent` is private provenance, with no public @@ -479,7 +479,7 @@ reservation itself authorizes a delivery. The separate final grant must recheck the reservations before issuing any one-use delivery capability. Disclosure admission now uses a third closed journal protocol under attempt -schema `/14`. Its immutable plan retains source-binding/projection provenance and +schema `/15`. Its immutable plan retains source-binding/projection provenance and recipient/channel/instance data; it cannot reconstruct an executable capability. The existing writer fence validates the source response/MAC, full current native authority and configuration, exact approval and fixed-window predecessors before @@ -503,9 +503,44 @@ current permission is not required to record past facts. Exact replay returns th same revision. A concurrent CAS loser reloads at most once to recognize identical stored evidence, never to redeliver. The native engine exposes separate proposal, compile and admission operations, all without credential lease or byte delivery. -Production authenticated recipient entry and the one-use delivery transport remain -required. Current file ACK fixtures explicitly inject test-only retained grants; -they establish journal behavior, not an authenticated send or a completed A08. +The native Unix delivery API now authenticates an owned stream before the final +fenced grant. `auths.gateway-unix-disclosure-channel/1` binds gateway/recipient +UIDs and a private channel identifier into the approved channel value. Both peers +check their effective UID and the kernel peer UID. Under +`auths.gateway-disclosure-auth/1`, the recipient signs a fresh 32-byte challenge +bound to the complete native delivery statement. This proves key possession for +that handshake; it is distinct from an ACK and never asserts receipt. + +The final writer fence rechecks the source/MAC, exact current native authority, +approval, configuration, allocation and managed counter memberships, plus the +live channel and its deadline. It persists the immutable authentication transcript +with the unique entry audit before returning a noncloneable delivery permit. +Only consuming that permit can send the exact reconstructed bytes. Attempt `/15` +requires authentication evidence whenever a disclosure has an entry grant; +obsolete `/14` is rejected. Decoding historical evidence cannot reconstruct a +socket or permit. ACK recording verifies the retained transcript and exact +original delivery even after current authority is lost. + +The local protocol uses unsigned big-endian 32-bit frame lengths, bounded before +allocation: authentication and ACK frames at most 4,096 bytes, content at most +65,536 bytes and exactly the approved projected length, including zero. Native +canonical decoding rejects duplicate/unknown/noncanonical authentication fields. +Authentication has a five-second deadline; the entire authenticated session has a +fifteen-second monotonic deadline. Those transport deadlines do not replace the +native deployment clock or final fenced authority evaluation. A lost permit, +partial send, lost ACK or ambiguous durable acknowledgement stays charged and +cannot produce a replacement permit. The recipient explicitly ACKs only after +complete receipt; retaining that native ACK enables later history recording. + +The recipient must obtain its expected effect and policy through its trusted +private authoring channel. This transport relies on host-enforced UID and socket +isolation; processes trusted under the gateway UID and a malicious host are +outside the containment guarantee. The existing synthetic-grant journal corpus +remains historical unit evidence. A separate real socket-pair/file fixture covers +actual send/ACK loss, reopening, one-winner concurrent grants, grant-before-send +loss and changes between authentication and grant. It is not independent-process, +PostgreSQL, hostile-agent or full installed A07/A08/A22 evidence. Application/CLI +routes, thin binding/UI integration and those complete journeys remain required. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 371cb423e..2e7953d91 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index ebeedb445..8dcf1740b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index aeb3dd8d7..3162999c1 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index eceddc572..eb5dad28b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index f0ce173ed..db7ab189b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/14","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index 23bbb680b8873b493d75cc30bb7426b5bde6df9c..be1bf6c879a7bb27d7643d0ebe9498a1254ab38b 100644 GIT binary patch delta 23 ccmdmJywP}qF{9~5lX*NK@+Q~jHR7yH0A%(D%m4rY delta 23 ccmdmJywP}qF{8;wlX*NK@+Q~jHR7yH0A$<;$^ZZW diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index 30b298501fa4a8dd572a60b3e8136c01683c3f7e..ee09ac318a6159cc5afca41637322c681329509c 100644 GIT binary patch delta 23 ccmdmEw8v Result<(), &'static str> { + self.peer(stream, self.gateway_uid(), self.recipient_uid()) + } + fn recipient_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { + self.peer(stream, self.recipient_uid(), self.gateway_uid()) + } + fn peer(&self, stream: &UnixStream, local: u32, remote: u32) -> Result<(), &'static str> { + if rustix::process::geteuid().as_raw() != local + || stream + .peer_cred() + .map_err(|_| "gateway.disclosure.peer")? + .uid() + != remote + { + return Err("gateway.disclosure.peer"); + } + Ok(()) + } +} + +/// An unchecked owned local connection and proposed channel policy. Constructing +/// this cannot authenticate the peer or grant access to retained content. +pub struct DisclosureConnection { + stream: UnixStream, + policy: UnixDisclosurePolicy, +} +impl DisclosureConnection { + /// Transfers the stream into the closed disclosure protocol. + #[must_use] + pub fn new(stream: UnixStream, policy: UnixDisclosurePolicy) -> Self { + Self { stream, policy } + } +} + +pub(crate) struct AuthenticatedDisclosureChannel { + stream: UnixStream, + authentication: RecipientAuthentication, + effect: EffectId, + deadline: Instant, +} + +impl AuthenticatedDisclosureChannel { + pub(crate) async fn authenticate( + connection: DisclosureConnection, + binding: &EffectBinding, + bytes: u64, + key: [u8; 32], + ) -> Result { + let DisclosureConnection { mut stream, policy } = connection; + policy.matches(binding)?; + policy.server_peer(&stream)?; + let start = Instant::now(); + let deadline = start + Duration::from_secs(SESSION_SECONDS); + let mut nonce = [0; 32]; + getrandom::fill(&mut nonce).map_err(|_| "gateway.disclosure.authentication")?; + let challenge = Challenge { + schema: AUTH_SCHEMA.to_owned(), + nonce, + delivery: DisclosureAcknowledgementRequest::for_delivery(binding, bytes, key) + .map_err(|_| "gateway.disclosure.authentication")?, + }; + let response = timeout_at(start + Duration::from_secs(AUTH_SECONDS), async { + write_frame(&mut stream, &bounded(&challenge)?, MAX_AUTH_BYTES).await?; + decode::(&read_frame(&mut stream, MAX_AUTH_BYTES).await?) + }) + .await + .map_err(|_| "gateway.disclosure.timeout")??; + let authentication = RecipientAuthentication { + policy, + challenge, + response, + }; + authentication.validate(binding, bytes, key)?; + Ok(Self { + stream, + authentication, + effect: binding.id(), + deadline, + }) + } + pub(crate) fn validate( + &self, + binding: &EffectBinding, + bytes: u64, + key: [u8; 32], + ) -> Result<(), &'static str> { + if self.effect != binding.id() || Instant::now() >= self.deadline { + return Err("gateway.disclosure.timeout"); + } + self.authentication.policy.server_peer(&self.stream)?; + self.authentication.validate(binding, bytes, key) + } + pub(crate) fn evidence(&self) -> RecipientAuthentication { + self.authentication.clone() + } + async fn deliver(mut self, content: Zeroizing>) -> Option { + timeout_at(self.deadline, async { + write_frame(&mut self.stream, &content, MAX_CONTENT_BYTES).await?; + let bytes = read_frame(&mut self.stream, MAX_AUTH_BYTES).await?; + DisclosureAcknowledgement::from_private_bytes(&bytes) + .map_err(|_| "gateway.disclosure.acknowledgement") + }) + .await + .ok()? + .ok() + } +} + +/// Recipient-side result from an authenticated local gateway. Only this client +/// API exposes the received plaintext; gateway journal/review APIs do not. +pub struct ReceivedDisclosure { + content: Zeroizing>, + stream: UnixStream, + statement: DisclosureAcknowledgementRequest, + deadline: Instant, + recipient_key: [u8; 32], +} + +impl ReceivedDisclosure { + /// Exact received bytes, including a valid empty projection. + #[must_use] + pub fn content(&self) -> &[u8] { + &self.content + } + /// Produces private historical evidence after receipt. Retain it privately + /// for late acknowledgement if the channel is lost; it grants no redelivery. + /// + /// # Errors + /// Refuses a signing failure or a key inconsistent with the received statement. + pub fn acknowledgement( + &self, + key: &SigningKey, + ) -> Result { + if key.verifying_key().to_bytes() != self.recipient_key { + return Err("gateway.disclosure.acknowledgement"); + } + let message = self + .statement + .signing_message() + .map_err(|_| "gateway.disclosure.acknowledgement")?; + Ok(self + .statement + .clone() + .with_signature(key.sign(&message).to_bytes())) + } + /// Sends the exact native ACK. Failure leaves delivery uncertain at the + /// gateway and does not authorize sending content again. + /// + /// # Errors + /// Returns a bounded transport/encoding failure. + pub async fn acknowledge(mut self, key: &SigningKey) -> Result<(), &'static str> { + let ack = self + .acknowledgement(key)? + .to_private_bytes() + .map_err(|_| "gateway.disclosure.acknowledgement")?; + timeout_at( + self.deadline, + write_frame(&mut self.stream, &ack, MAX_AUTH_BYTES), + ) + .await + .map_err(|_| "gateway.disclosure.timeout")? + } +} + +/// Authenticates the local gateway UID and exact expected effect, proves fresh +/// recipient key possession, then receives exactly the approved number of bytes. +/// The caller supplies its trusted expected binding/policy, never values copied +/// uncritically from the incoming challenge. No ACK is sent until requested. +/// +/// # Errors +/// Refuses peer, channel, binding, malformed/oversized frames, wrong length and +/// bounded deadline failures. No partial content is returned on failure. +pub async fn receive_disclosure( + connection: DisclosureConnection, + binding: &EffectBinding, + bytes: u64, + key: &SigningKey, +) -> Result { + let DisclosureConnection { mut stream, policy } = connection; + policy.matches(binding)?; + policy.recipient_peer(&stream)?; + let expected = DisclosureAcknowledgementRequest::for_delivery( + binding, + bytes, + key.verifying_key().to_bytes(), + ) + .map_err(|_| "gateway.disclosure.authentication")?; + let start = Instant::now(); + let deadline = start + Duration::from_secs(SESSION_SECONDS); + let challenge = timeout_at(start + Duration::from_secs(AUTH_SECONDS), async { + let challenge: Challenge = decode(&read_frame(&mut stream, MAX_AUTH_BYTES).await?)?; + if challenge.delivery != expected { + return Err("gateway.disclosure.authentication"); + } + let response = Response::sign(&challenge, key)?; + write_frame(&mut stream, &bounded(&response)?, MAX_AUTH_BYTES).await?; + Ok::<_, &'static str>(challenge) + }) + .await + .map_err(|_| "gateway.disclosure.timeout")??; + let content = timeout_at( + deadline, + read_frame( + &mut stream, + usize::try_from(bytes).map_err(|_| "gateway.disclosure.length")?, + ), + ) + .await + .map_err(|_| "gateway.disclosure.timeout")??; + if content.len() as u64 != bytes { + return Err("gateway.disclosure.length"); + } + Ok(ReceivedDisclosure { + content, + stream, + statement: challenge.delivery, + deadline, + recipient_key: key.verifying_key().to_bytes(), + }) +} + +async fn read_frame( + stream: &mut UnixStream, + maximum: usize, +) -> Result>, &'static str> { + let length = stream + .read_u32() + .await + .map_err(|_| "gateway.disclosure.read")? as usize; + if maximum > MAX_CONTENT_BYTES || length > maximum { + return Err("gateway.disclosure.frame"); + } + let mut bytes = Zeroizing::new(vec![0; length]); + stream + .read_exact(&mut bytes) + .await + .map_err(|_| "gateway.disclosure.read")?; + Ok(bytes) +} +async fn write_frame( + stream: &mut UnixStream, + bytes: &[u8], + maximum: usize, +) -> Result<(), &'static str> { + if bytes.len() > maximum || maximum > MAX_CONTENT_BYTES { + return Err("gateway.disclosure.frame"); + } + stream + .write_u32(u32::try_from(bytes.len()).map_err(|_| "gateway.disclosure.frame")?) + .await + .map_err(|_| "gateway.disclosure.write")?; + stream + .write_all(bytes) + .await + .map_err(|_| "gateway.disclosure.write") +} + +/// The only production content send accepts a newly granted one-use permit. +pub(crate) async fn deliver( + permit: crate::store::DisclosureEntryPermit, +) -> Option { + let (channel, content) = permit.into_delivery(); + channel.deliver(content).await +} diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 27492b44f..2637bd01b 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -28,6 +28,8 @@ pub use content::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisit mod release; pub(crate) use release::DisclosurePlan; pub use release::{DISCLOSURE_TOOL, DisclosureTarget, compile_disclosure}; +pub(crate) mod disclosure_auth; +pub use disclosure_auth::UnixDisclosurePolicy; mod disclosure; pub use disclosure::{ AuthenticatedDisclosureAcknowledgement, DISCLOSURE_ACK_SCHEMA, DisclosureAcknowledgement, @@ -504,13 +506,13 @@ impl fmt::Debug for EffectBinding { } } -fn commitment(domain: &str, bytes: &[u8]) -> Result<[u8; 32], EffectBindingError> { +pub(crate) fn commitment(domain: &str, bytes: &[u8]) -> Result<[u8; 32], EffectBindingError> { auths_codec::domain_commitment(domain, bytes) .map(|digest| *digest.as_bytes()) .map_err(|_| EffectBindingError::Invalid) } -fn canonical(value: &T) -> Result>, EffectBindingError> { +pub(crate) fn canonical(value: &T) -> Result>, EffectBindingError> { let bytes = Zeroizing::new( serde_json_canonicalizer::to_vec(value).map_err(|_| EffectBindingError::Invalid)?, ); @@ -572,6 +574,10 @@ impl EffectBinding { }) } + pub(crate) fn disclosure_channel_matches(&self, channel: &[u8; 32]) -> bool { + matches!(&self.wire.protocol, Protocol::Disclosure { channel: expected, .. } if expected == channel) + } + pub(crate) fn is_mutation(&self) -> bool { matches!(self.wire.protocol, Protocol::Mutation { .. }) } diff --git a/product/runtime/auths-gateway/src/effect/disclosure_auth.rs b/product/runtime/auths-gateway/src/effect/disclosure_auth.rs new file mode 100644 index 000000000..bac820931 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/disclosure_auth.rs @@ -0,0 +1,203 @@ +//! Bounded private local-channel identity and historical authentication data. +//! This module has no socket access and cannot construct a live channel/permit. +use super::{DisclosureAcknowledgementRequest, EffectBinding, canonical, commitment}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use ed25519_dalek::{Signature, VerifyingKey}; +#[cfg(any(unix, test))] +use ed25519_dalek::{Signer as _, SigningKey}; +use serde::{Deserialize, Serialize}; +use std::fmt; +use zeroize::Zeroizing; +const CHANNEL_SCHEMA: &str = "auths.gateway-unix-disclosure-channel/1"; +pub(crate) const AUTH_SCHEMA: &str = "auths.gateway-disclosure-auth/1"; +pub(crate) const MAX_AUTH_BYTES: usize = 4_096; + +/// Proposed local channel identity. This is data, never proof that a live peer +/// has authenticated. Its native commitment must match the approved effect. +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub struct UnixDisclosurePolicy { + schema: String, + gateway_uid: u32, + recipient_uid: u32, + channel_id: [u8; 32], +} + +impl fmt::Debug for UnixDisclosurePolicy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("UnixDisclosurePolicy { private: [redacted] }") + } +} + +impl UnixDisclosurePolicy { + /// Pins OS identities and a channel identifier chosen on the private + /// authoring channel. Same-UID use does not establish agent isolation. + #[must_use] + pub fn new(gateway_uid: u32, recipient_uid: u32, channel_id: [u8; 32]) -> Self { + Self { + schema: CHANNEL_SCHEMA.to_owned(), + gateway_uid, + recipient_uid, + channel_id, + } + } + /// Native channel value for the disclosure target and exact approval. + /// + /// # Errors + /// Refuses unsupported/invalid policy encodings. + pub fn commitment(&self) -> Result<[u8; 32], &'static str> { + if self.schema != CHANNEL_SCHEMA { + return Err("gateway.disclosure.channel"); + } + commitment( + CHANNEL_SCHEMA, + &canonical(self).map_err(|_| "gateway.disclosure.channel")?, + ) + .map_err(|_| "gateway.disclosure.channel") + } + pub(crate) fn matches(&self, binding: &EffectBinding) -> Result<(), &'static str> { + if !binding.disclosure_channel_matches(&self.commitment()?) { + return Err("gateway.disclosure.channel"); + } + Ok(()) + } + #[cfg(unix)] + pub(crate) fn gateway_uid(&self) -> u32 { + self.gateway_uid + } + #[cfg(unix)] + pub(crate) fn recipient_uid(&self) -> u32 { + self.recipient_uid + } +} + +#[derive(Clone, Deserialize, Eq, PartialEq, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct Challenge { + pub(crate) schema: String, + pub(crate) delivery: DisclosureAcknowledgementRequest, + pub(crate) nonce: [u8; 32], +} + +impl Challenge { + pub(crate) fn message(&self) -> Result<[u8; 32], &'static str> { + if self.schema != AUTH_SCHEMA { + return Err("gateway.disclosure.authentication"); + } + self.delivery + .to_private_bytes() + .map_err(|_| "gateway.disclosure.authentication")?; + commitment(AUTH_SCHEMA, &bounded(self)?).map_err(|_| "gateway.disclosure.authentication") + } +} + +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct Response { + schema: String, + signature: String, +} + +impl Response { + #[cfg(any(unix, test))] + pub(crate) fn sign(challenge: &Challenge, key: &SigningKey) -> Result { + Ok(Self { + schema: AUTH_SCHEMA.to_owned(), + signature: Base64UrlUnpadded::encode_string( + &key.sign(&challenge.message()?).to_bytes(), + ), + }) + } + pub(crate) fn verify(&self, challenge: &Challenge, key: [u8; 32]) -> Result<(), &'static str> { + if self.schema != AUTH_SCHEMA { + return Err("gateway.disclosure.authentication"); + } + let mut signature = [0; 64]; + let bytes = Base64UrlUnpadded::decode(&self.signature, &mut signature) + .map_err(|_| "gateway.disclosure.authentication")?; + if bytes.len() != 64 || Base64UrlUnpadded::encode_string(bytes) != self.signature { + return Err("gateway.disclosure.authentication"); + } + let key = + VerifyingKey::from_bytes(&key).map_err(|_| "gateway.disclosure.authentication")?; + if key.is_weak() { + return Err("gateway.disclosure.authentication"); + } + key.verify_strict(&challenge.message()?, &Signature::from_bytes(&signature)) + .map_err(|_| "gateway.disclosure.authentication") + } +} + +/// Private authenticated historical transcript. Decoding it never reconstructs +/// an owned live stream or a one-use delivery permit. +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct RecipientAuthentication { + pub(crate) policy: UnixDisclosurePolicy, + pub(crate) challenge: Challenge, + pub(crate) response: Response, +} +impl RecipientAuthentication { + /// Historical fixture assumption only; no socket or permit is constructed. + #[cfg(test)] + pub(crate) fn synthetic( + binding: &EffectBinding, + bytes: u64, + key: &SigningKey, + policy: UnixDisclosurePolicy, + ) -> Self { + let challenge = Challenge { + schema: AUTH_SCHEMA.to_owned(), + delivery: DisclosureAcknowledgementRequest::for_delivery( + binding, + bytes, + key.verifying_key().to_bytes(), + ) + .expect("fixture delivery"), + nonce: [17; 32], + }; + let response = Response::sign(&challenge, key).expect("fixture response"); + Self { + policy, + challenge, + response, + } + } + + pub(crate) fn validate( + &self, + binding: &EffectBinding, + bytes: u64, + key: [u8; 32], + ) -> Result<(), &'static str> { + self.policy.matches(binding)?; + let expected = DisclosureAcknowledgementRequest::for_delivery(binding, bytes, key) + .map_err(|_| "gateway.disclosure.authentication")?; + if self.challenge.delivery != expected { + return Err("gateway.disclosure.authentication"); + } + bounded(self)?; + self.response.verify(&self.challenge, key) + } +} + +pub(crate) fn bounded(value: &T) -> Result>, &'static str> { + let bytes = canonical(value).map_err(|_| "gateway.disclosure.authentication")?; + if bytes.is_empty() || bytes.len() > MAX_AUTH_BYTES { + return Err("gateway.disclosure.frame"); + } + Ok(bytes) +} +#[cfg(unix)] +pub(crate) fn decode( + bytes: &[u8], +) -> Result { + if bytes.is_empty() || bytes.len() > MAX_AUTH_BYTES { + return Err("gateway.disclosure.frame"); + } + let value: T = serde_json::from_slice(bytes).map_err(|_| "gateway.disclosure.frame")?; + if bounded(&value)?.as_slice() != bytes { + return Err("gateway.disclosure.frame"); + } + Ok(value) +} diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs index 508576f65..7a5639e56 100644 --- a/product/runtime/auths-gateway/src/effect/release.rs +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -294,6 +294,10 @@ pub(crate) struct DisclosurePlan { } impl DisclosurePlan { + pub(crate) fn recipient_key(&self) -> [u8; 32] { + self.recipient_key + } + pub(crate) fn source(&self) -> Result { EffectBinding::from_private_bytes(self.source_binding.as_bytes()) } diff --git a/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs new file mode 100644 index 000000000..03632e2aa --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs @@ -0,0 +1,555 @@ +//! Real local sockets over the native installed file fence. Same-process UID +//! checks do not establish independent-process isolation or PostgreSQL evidence. +use super::*; +use crate::disclosure_transport::{ + AuthenticatedDisclosureChannel, DisclosureConnection, ReceivedDisclosure, deliver, + receive_disclosure, +}; +use crate::effect::UnixDisclosurePolicy; +use tokio::net::UnixStream; + +async fn authenticate( + approved: &ApprovedEffect, + bytes: u64, + recipient: &SigningKey, + policy: &UnixDisclosurePolicy, +) -> ( + AuthenticatedDisclosureChannel, + tokio::task::JoinHandle>, +) { + let (server, client) = UnixStream::pair().expect("socket pair"); + let binding = approved.effect().binding().clone(); + let client_policy = policy.clone(); + let client_key = recipient.clone(); + let receiver = tokio::spawn(async move { + receive_disclosure( + DisclosureConnection::new(client, client_policy), + &binding, + bytes, + &client_key, + ) + .await + }); + let channel = AuthenticatedDisclosureChannel::authenticate( + DisclosureConnection::new(server, policy.clone()), + approved.effect().binding(), + bytes, + recipient.verifying_key().to_bytes(), + ) + .await + .expect("fresh recipient authentication"); + (channel, receiver) +} + +#[allow( + clippy::too_many_arguments, + clippy::too_many_lines, + reason = "one actual socket/fenced-journal artifact using its native installed context" +)] +pub(super) async fn corpus( + attempts: &crate::GatewayAttempts, + store: &Arc, + path: &std::path::Path, + policy: &EffectPolicy, + recipe: &CompiledRecipe, + connection: &ConnectionRecord, + bytes: u64, + recipient: &SigningKey, + channel_policy: &UnixDisclosurePolicy, + approve: impl Fn(u8, &UnixDisclosurePolicy) -> Arc, + validation: impl Fn(u64) -> crate::entry::EntryValidation, +) { + let first = approve(2, channel_policy); + let operation = LogicalOperationId::parse("release-2").expect("operation"); + let (channel, receiver) = authenticate(&first, bytes, recipient, channel_policy).await; + let transcript = channel.evidence(); + // A signed historical transcript is immutable data, never a live socket. + let transcript_bytes = crate::effect::disclosure_auth::bounded(&transcript).expect("canonical"); + let decoded: crate::effect::disclosure_auth::RecipientAuthentication = + crate::effect::disclosure_auth::decode(&transcript_bytes).expect("decode"); + decoded + .validate( + first.effect().binding(), + bytes, + recipient.verifying_key().to_bytes(), + ) + .expect("history"); + let original: Value = serde_json::from_slice(&transcript_bytes).expect("JSON"); + for pointer in [ + "/policy/channel_id/0", + "/policy/gateway_uid", + "/policy/recipient_uid", + "/challenge/nonce/0", + ] { + let mut changed = original.clone(); + let field = changed.pointer_mut(pointer).expect("field"); + *field = json!(field.as_u64().expect("integer") ^ 1); + let changed: crate::effect::disclosure_auth::RecipientAuthentication = + serde_json::from_value(changed).expect("shape"); + assert!( + changed + .validate( + first.effect().binding(), + bytes, + recipient.verifying_key().to_bytes() + ) + .is_err(), + "{pointer}" + ); + } + let mut noncanonical = transcript_bytes.to_vec(); + noncanonical.push(b' '); + assert!( + crate::effect::disclosure_auth::decode::< + crate::effect::disclosure_auth::RecipientAuthentication, + >(&noncanonical) + .is_err() + ); + assert!( + crate::effect::disclosure_auth::decode::< + crate::effect::disclosure_auth::RecipientAuthentication, + >(&vec![b' '; 4097]) + .is_err() + ); + let (_, permit) = attempts + .grant_disclosure(Arc::clone(&first), validation(NOW), NOW, channel) + .await + .expect("grant"); + let receive_and_ack = async { + let received = receiver.await.expect("receiver task").expect("delivery"); + assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + assert_eq!(received.content().len() as u64, bytes); + assert!( + received + .acknowledgement(&SigningKey::from_bytes(&[52; 32])) + .is_err() + ); + received.acknowledge(recipient).await.expect("ACK send"); + }; + let (ack, ()) = tokio::join!(deliver(permit), receive_and_ack); + let ack = ack.expect("received ACK"); + let acknowledged = attempts + .acknowledge_disclosure(recipe.namespace(), &operation, &ack) + .await + .expect("record ACK"); + assert_eq!(acknowledged.stage, crate::DisclosureStage::Acknowledged); + assert_eq!(acknowledged.revision, 3); + + let first_key = crate::GatewayAttemptKey::for_operation(policy, recipe.namespace(), &operation) + .expect("operation key"); + let first_bytes = store + .load(crate::GatewayRecordKind::Attempt, &first_key) + .expect("load") + .expect("grant record"); + let original_record: Value = serde_json::from_slice(&first_bytes).expect("JSON"); + for field in ["authentication", "signature"] { + let mut changed = original_record.clone(); + if field == "authentication" { + changed["state"]["facts"]["authentication"] = Value::Null; + } else { + changed["state"]["facts"]["authentication"]["response"]["signature"] = json!("invalid"); + } + let changed = serde_json::to_vec(&changed).expect("changed record"); + store + .replace( + crate::GatewayRecordKind::Attempt, + &first_key, + &first_bytes, + &changed, + ) + .expect("mutate retained authentication"); + assert!(attempts.read_disclosure(&first).await.is_err()); + store + .replace( + crate::GatewayRecordKind::Attempt, + &first_key, + &changed, + &first_bytes, + ) + .expect("restore record"); + } + + // Actual receipt followed by loss of the ACK channel retains full charges. + let second = approve(3, channel_policy); + let second_operation = LogicalOperationId::parse("release-3").expect("operation"); + let (channel, receiver) = authenticate(&second, bytes, recipient, channel_policy).await; + let (grant, permit) = attempts + .grant_disclosure(Arc::clone(&second), validation(NOW), NOW, channel) + .await + .expect("grant"); + let lose_ack = async { + let received = receiver.await.expect("receiver task").expect("delivery"); + assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + received + .acknowledgement(recipient) + .expect("retain late ACK") + // Owned client socket drops without sending its ACK. + }; + let (lost, late_ack) = tokio::join!(deliver(permit), lose_ack); + assert!(lost.is_none()); + let unknown = grant.record_unknown().await.expect("unknown"); + assert_eq!(unknown.stage, crate::DisclosureStage::Unknown); + assert_eq!(unknown.reserved_bytes, bytes); + let reopened = crate::GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(path).expect("reopen")), + policy.clone(), + ) + .expect("attempts"); + assert_eq!( + reopened.read_disclosure(&second).await.expect("read"), + Some(unknown.clone()) + ); + let (channel, receiver) = authenticate(&second, bytes, recipient, channel_policy).await; + assert!( + reopened + .grant_disclosure(Arc::clone(&second), validation(NOW), NOW, channel) + .await + .is_err(), + "fresh authentication cannot remint a permit" + ); + assert!( + receiver.await.expect("receiver task").is_err(), + "replay receives no content frame" + ); + assert_eq!( + reopened.read_disclosure(&second).await.expect("read"), + Some(unknown.clone()) + ); + let late = reopened + .acknowledge_disclosure(recipe.namespace(), &second_operation, &late_ack) + .await + .expect("late ACK"); + assert_eq!(late.stage, crate::DisclosureStage::Acknowledged); + assert_eq!(late.reserved_bytes, unknown.reserved_bytes); + assert_eq!(late.revision, 4); + + // Revocation linearizes after successful peer authentication, before entry. + let revoked = approve(4, channel_policy); + let before = attempts.read_disclosure(&revoked).await.expect("before"); + let (channel, receiver) = authenticate(&revoked, bytes, recipient, channel_policy).await; + let connection_key = crate::connection_key(connection.provider_kind(), connection.alias()); + let original_connection = connection.to_canonical_cbor().expect("connection"); + let disabled = connection + .transition_state(ConnectionState::Disabled, NOW) + .expect("disable") + .to_canonical_cbor() + .expect("connection bytes"); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &original_connection, + &disabled, + ) + .expect("disable after authentication"); + assert!( + attempts + .grant_disclosure(Arc::clone(&revoked), validation(NOW), NOW, channel) + .await + .is_err() + ); + assert!( + receiver.await.expect("receiver task").is_err(), + "revoked recipient receives no content frame" + ); + assert_eq!( + attempts.read_disclosure(&revoked).await.expect("read"), + before + ); + store + .replace( + crate::GatewayRecordKind::Connection, + &connection_key, + &disabled, + &original_connection, + ) + .expect("restore connection"); + + // An acknowledged grant lost before send is unknown and cannot be reminted. + let dropped = approve(5, channel_policy); + let (channel, receiver) = authenticate(&dropped, bytes, recipient, channel_policy).await; + let (_, permit) = attempts + .grant_disclosure(Arc::clone(&dropped), validation(NOW), NOW, channel) + .await + .expect("grant"); + drop(permit); + assert!(receiver.await.expect("receiver task").is_err()); + let dropped_snapshot = reopened + .read_disclosure(&dropped) + .await + .expect("read") + .expect("record"); + assert_eq!(dropped_snapshot.stage, crate::DisclosureStage::Unknown); + assert_eq!(dropped_snapshot.reserved_bytes, bytes); + let (channel, receiver) = authenticate(&dropped, bytes, recipient, channel_policy).await; + assert!( + reopened + .grant_disclosure(Arc::clone(&dropped), validation(NOW), NOW, channel) + .await + .is_err() + ); + assert!(receiver.await.expect("receiver task").is_err()); + + // Competing live authenticated sockets do not turn one reservation into two + // permits. The failed channel closes before any content frame. + let raced = approve(6, channel_policy); + let (left, left_receiver) = authenticate(&raced, bytes, recipient, channel_policy).await; + let (right, right_receiver) = authenticate(&raced, bytes, recipient, channel_policy).await; + let (left, right) = tokio::join!( + attempts.grant_disclosure(Arc::clone(&raced), validation(NOW), NOW, left), + reopened.grant_disclosure(Arc::clone(&raced), validation(NOW), NOW, right), + ); + let ((_, permit), winner, loser) = match (left, right) { + (Ok(granted), Err(_)) => (granted, left_receiver, right_receiver), + (Err(_), Ok(granted)) => (granted, right_receiver, left_receiver), + _ => panic!("exactly one live grant"), + }; + assert!(loser.await.expect("losing receiver").is_err()); + let receive = async { + let received = winner.await.expect("winner").expect("one delivery"); + assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + received.acknowledge(recipient).await.expect("ACK"); + }; + let (ack, ()) = tokio::join!(deliver(permit), receive); + let raced_snapshot = attempts + .acknowledge_disclosure( + recipe.namespace(), + &LogicalOperationId::parse("release-6").expect("operation"), + &ack.expect("ACK"), + ) + .await + .expect("record"); + assert_eq!(raced_snapshot.reserved_deliveries, 1); + assert_eq!(raced_snapshot.revision, 3); + + let expired = approve(7, channel_policy); + let before_expiry = attempts.read_disclosure(&expired).await.expect("read"); + let (channel, receiver) = authenticate(&expired, bytes, recipient, channel_policy).await; + assert!( + attempts + .grant_disclosure(Arc::clone(&expired), validation(NOW + 61), NOW, channel) + .await + .is_err() + ); + assert!(receiver.await.expect("receiver").is_err()); + assert_eq!( + attempts.read_disclosure(&expired).await.expect("read"), + before_expiry + ); + + let changed = approve(8, channel_policy); + let before_change = attempts.read_disclosure(&changed).await.expect("read"); + let (channel, receiver) = authenticate(&changed, bytes, recipient, channel_policy).await; + let config_key = crate::GatewayAttemptKey::from_bytes( + policy + .configuration_key(recipe.namespace()) + .expect("configuration key"), + ); + let config_bytes = store + .load(crate::GatewayRecordKind::EffectConfiguration, &config_key) + .expect("load configuration") + .expect("configuration"); + let mut config: Value = serde_json::from_slice(&config_bytes).expect("configuration JSON"); + config["installation"][0] = json!(13); + let changed_bytes = serde_json_canonicalizer::to_vec(&config).expect("changed configuration"); + store + .replace( + crate::GatewayRecordKind::EffectConfiguration, + &config_key, + &config_bytes, + &changed_bytes, + ) + .expect("change configuration after authentication"); + assert!( + attempts + .grant_disclosure(Arc::clone(&changed), validation(NOW), NOW, channel) + .await + .is_err() + ); + assert!(receiver.await.expect("receiver").is_err()); + assert_eq!( + attempts.read_disclosure(&changed).await.expect("read"), + before_change + ); + store + .replace( + crate::GatewayRecordKind::EffectConfiguration, + &config_key, + &changed_bytes, + &config_bytes, + ) + .expect("restore configuration"); + + let changed_source = approve(9, channel_policy); + let before_source = attempts + .read_disclosure(&changed_source) + .await + .expect("read"); + let (channel, receiver) = authenticate(&changed_source, bytes, recipient, channel_policy).await; + let source = changed_source + .disclosure_plan() + .expect("plan") + .source() + .expect("source"); + let source_operation = + LogicalOperationId::parse(source.journal_identity().1).expect("source operation"); + let source_key = + crate::GatewayAttemptKey::for_operation(policy, recipe.namespace(), &source_operation) + .expect("source key"); + let source_bytes = store + .load(crate::GatewayRecordKind::Attempt, &source_key) + .expect("load source") + .expect("source"); + let mut changed: Value = serde_json::from_slice(&source_bytes).expect("source JSON"); + changed["state"]["facts"]["phase"]["content"]["value"]["bytes"] = json!(bytes + 1); + let corrupt = serde_json::to_vec(&changed).expect("mutated source"); + store + .replace( + crate::GatewayRecordKind::Attempt, + &source_key, + &source_bytes, + &corrupt, + ) + .expect("change source after authentication"); + assert!( + attempts + .grant_disclosure(Arc::clone(&changed_source), validation(NOW), NOW, channel) + .await + .is_err() + ); + assert!(receiver.await.expect("receiver").is_err()); + assert_eq!( + attempts + .read_disclosure(&changed_source) + .await + .expect("read"), + before_source + ); + store + .replace( + crate::GatewayRecordKind::Attempt, + &source_key, + &corrupt, + &source_bytes, + ) + .expect("restore source"); + + // The wrong OS identity cannot even complete the handshake. + let (server, _client) = UnixStream::pair().expect("sockets"); + let wrong_uid = rustix::process::geteuid().as_raw() ^ 1; + let wrong_policy = UnixDisclosurePolicy::new(wrong_uid, wrong_uid, [22; 32]); + let wrong_effect = approve(6, &wrong_policy); + assert!(matches!( + AuthenticatedDisclosureChannel::authenticate( + DisclosureConnection::new(server, wrong_policy), + wrong_effect.effect().binding(), + bytes, + recipient.verifying_key().to_bytes() + ) + .await, + Err("gateway.disclosure.peer") + )); + authentication_failures(&first, bytes, recipient, channel_policy).await; + + let fixture = json!({"schema": "auths.gateway-disclosure-delivery-fixture/1", + "scope": "real Unix socket pairs and installed native file fence; no independent processes, hostile UID isolation or PostgreSQL claim", + "authenticated_delivery": acknowledged, "lost_ack": unknown, "late_ack": late, + "competing_live_channels": raced_snapshot, "approval_expired_after_authentication_refused": true, + "configuration_changed_after_authentication_refused": true, + "corrupt_source_after_authentication_refused": true, "retained_authentication_corruption_refused": true, + "dropped_permit": dropped_snapshot, "reopened_grant_cannot_redeliver": true, + "disable_after_authentication_refuses_entry": true, "wrong_recipient_signing_key_refused": true, + "changed_authentication_fields_refused": true, "wrong_os_uid_refused": true, + "fresh_challenge_substitution_refused": true, "wrong_key_response_refused": true, + "duplicate_unknown_noncanonical_oversized_frames_refused": true, "noncanonical_and_oversized_authentication_refused": true, + "historical_authentication_grants_no_socket": true}); + let output = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/disclosure-delivery.json"); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture bytes"); + assert!( + !std::str::from_utf8(&bytes) + .expect("UTF8") + .contains("PRIVATE-SYNTHETIC-CONTENT") + ); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &bytes).expect("write"); + } + assert_eq!(std::fs::read(output).expect("fixture"), bytes); +} + +/// Each client answers the gateway's real fresh challenge with one specific +/// violation. None reaches the final grant or receives a content frame. +async fn authentication_failures( + approved: &ApprovedEffect, + bytes: u64, + recipient: &SigningKey, + policy: &UnixDisclosurePolicy, +) { + use crate::effect::disclosure_auth::{Challenge, Response, bounded, decode}; + use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _}; + for mode in 0..6 { + let (server, mut client) = UnixStream::pair().expect("sockets"); + let key = recipient.clone(); + let peer = tokio::spawn(async move { + let length = client.read_u32().await.expect("challenge length") as usize; + assert!(length <= 4096); + let mut incoming = vec![0; length]; + client.read_exact(&mut incoming).await.expect("challenge"); + let mut challenge: Challenge = decode(&incoming).expect("canonical challenge"); + if mode == 0 { + challenge.nonce[0] ^= 1; + } + let key = if mode == 1 { + SigningKey::from_bytes(&[52; 32]) + } else { + key + }; + let response = Response::sign(&challenge, &key).expect("response"); + let mut response = bounded(&response).expect("bytes").to_vec(); + match mode { + 2 => response.push(b' '), + 3 => { + response.insert(1, b' '); + let mut unknown: Value = serde_json::from_slice(&response).expect("JSON"); + unknown["unexpected"] = json!(true); + response = serde_json::to_vec(&unknown).expect("unknown field"); + } + 4 => { + response.splice( + 1..1, + b"\"schema\":\"auths.gateway-disclosure-auth/1\"," + .iter() + .copied(), + ); + } + _ => {} + } + if mode == 5 { + client.write_u32(4097).await.expect("oversized header"); + } else { + client + .write_u32(response.len() as u32) + .await + .expect("length"); + client.write_all(&response).await.expect("response"); + } + // A failed handshake closes without any content frame. + assert!(client.read_u32().await.is_err()); + }); + let result = AuthenticatedDisclosureChannel::authenticate( + DisclosureConnection::new(server, policy.clone()), + approved.effect().binding(), + bytes, + recipient.verifying_key().to_bytes(), + ) + .await; + assert!( + matches!( + result, + Err("gateway.disclosure.authentication" | "gateway.disclosure.frame") + ), + "mode {mode}" + ); + peer.await.expect("peer task"); + } +} diff --git a/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs index c26638a0e..c02aca056 100644 --- a/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs +++ b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs @@ -24,10 +24,11 @@ pub(super) async fn corpus( let recipient = SigningKey::from_bytes(&[51; 32]); let key = SigningKey::from_bytes(&[29; 32]); let public = key.verifying_key().to_bytes(); + let channel_policy = crate::effect::UnixDisclosurePolicy::new(0, 0, [20; 32]); let target = DisclosureTarget::new( retained.clone(), recipient.verifying_key().to_bytes(), - [20; 32], + channel_policy.commitment().expect("channel"), [21; 32], ) .expect("target"); @@ -262,7 +263,7 @@ pub(super) async fn corpus( let mut changed = original.clone(); let value = changed.pointer_mut(pointer).expect("field"); *value = match pointer { - "/schema" => json!("auths.gateway-attempt/13"), + "/schema" => json!("auths.gateway-attempt/14"), "/state/protocol" => json!("acquisition"), "/state/facts/allocation" => json!(16), "/state/facts/plan/source_binding" | "/state/facts/plan/source_contract" => json!("{}"), @@ -315,10 +316,17 @@ pub(super) async fn corpus( .expect("record"), first_bytes ); + #[cfg(unix)] + let live_policy = { + let uid = rustix::process::geteuid().as_raw(); + crate::effect::UnixDisclosurePolicy::new(uid, uid, [22; 32]) + }; + #[cfg(not(unix))] + let live_policy = crate::effect::UnixDisclosurePolicy::new(0, 0, [22; 32]); let alternate = DisclosureTarget::new( retained.clone(), recipient.verifying_key().to_bytes(), - [22; 32], + live_policy.commitment().expect("channel"), [21; 32], ) .expect("target"); @@ -401,12 +409,20 @@ pub(super) async fn corpus( .filter(|(_, stage)| matches!(stage, crate::GatewayOperationStage::Disclosure(_))) .count(); assert_eq!(disclosures, 18); + let authentication = |effect: &ApprovedEffect| { + crate::effect::disclosure_auth::RecipientAuthentication::synthetic( + effect.effect().binding(), + retained.bytes, + &recipient, + channel_policy.clone(), + ) + }; let first_grant = reopened - .synthetic_disclosure_grant(&first, NOW, false) + .synthetic_disclosure_grant(&first, NOW, false, authentication(&first)) .await .expect("synthetic grant"); let second_grant = reopened - .synthetic_disclosure_grant(&second, NOW, true) + .synthetic_disclosure_grant(&second, NOW, true, authentication(&second)) .await .expect("synthetic unknown grant"); assert_eq!(first_grant.stage, crate::DisclosureStage::Unknown); @@ -485,7 +501,7 @@ pub(super) async fn corpus( ); assert!( again - .synthetic_disclosure_grant(&first, NOW, false) + .synthetic_disclosure_grant(&first, NOW, false, authentication(&first)) .await .is_err(), "history cannot regrant" @@ -498,6 +514,30 @@ pub(super) async fn corpus( &original_connection, ) .expect("restore connection"); + #[cfg(unix)] + live_delivery::corpus( + &attempts, + store, + path, + policy, + recipe, + connection, + retained.bytes, + &recipient, + &live_policy, + |index, channel: &crate::effect::UnixDisclosurePolicy| { + let target = DisclosureTarget::new( + retained.clone(), + recipient.verifying_key().to_bytes(), + channel.commitment().expect("channel"), + [21; 32], + ) + .expect("target"); + approve(&format!("release-{index}"), &target, false) + }, + validation, + ) + .await; let public_history = serde_json::to_string(&history).expect("public history"); for private in [ "PRIVATE-SYNTHETIC-CONTENT", @@ -524,5 +564,9 @@ pub(super) async fn corpus( std::fs::write(&output, &bytes).expect("write"); } assert_eq!(std::fs::read(&output).expect("fixture"), bytes); - json!({"fixture": "disclosure-journal.json", "admissions": 16, "refusals": 2, "delivered_bytes": 0}) + json!({"fixture": "disclosure-journal.json", "admissions": 16, "refusals": 2, "journal_only_delivered_bytes": 0, "unix_delivery_fixture": "disclosure-delivery.json"}) } + +#[cfg(unix)] +#[path = "effect_disclosure_delivery_tests.rs"] +mod live_delivery; diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 8ca3c8d7d..5bc827f8d 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -239,7 +239,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/14", + "attempt_schema": "auths.gateway-attempt/15", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 6f1491bfe..4c8244b93 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1408,6 +1408,147 @@ impl GatewayEngine { } } + /// Authenticates one local recipient, rechecks source/authority/capacity under + /// the final writer fence, then consumes the unique acknowledged permit to + /// send exact retained bytes. Replay never authenticates or sends again. + /// + /// # Errors + /// Refuses native/approval/peer/channel failures before release. Lost sends, + /// ACKs or persistence return retained uncertainty without a retry or refund. + #[cfg(unix)] + #[allow( + clippy::too_many_lines, + reason = "one typed admission, authenticated grant and evidence sequence" + )] + pub async fn disclose( + &self, + target: &crate::effect::DisclosureTarget, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + connection: crate::disclosure_transport::DisclosureConnection, + ) -> Result { + let started = Instant::now(); + let effect = self + .compile_disclosure_effect(target, proof, action) + .await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + if let Some(snapshot) = self + .attempts + .read_disclosure(&approved) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => { + not_entered("gateway.effect.operation-conflict") + } + _ => GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }, + })? + && snapshot.stage != crate::DisclosureStage::Reserved + { + return Ok(snapshot); + } + let io = EngineIo { + engine: self, + pending: std::sync::Mutex::new(None), + started, + prepared: OnceLock::new(), + commissioning: None, + commissioned_action: OnceLock::new(), + commissioning_refusal: OnceLock::new(), + }; + io.prepare().await.map_err(not_entered)?; + let claim = self + .attempts + .claim_disclosure(&approved, now, io.entry_validation().map_err(not_entered)?) + .await; + let snapshot = match claim { + Ok(snapshot) => snapshot, + Err(crate::GatewayAttemptError::BindingConflict) => { + return Err(not_entered("gateway.effect.operation-conflict")); + } + Err(_) => { + return self + .attempts + .read_disclosure(&approved) + .await + .ok() + .flatten() + .ok_or_else(|| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }); + } + }; + if snapshot.stage != crate::DisclosureStage::Reserved { + return Ok(snapshot); + } + let plan = approved + .disclosure_plan() + .map_err(|_| not_entered("gateway.disclosure.binding"))?; + let bytes = plan + .capacity() + .map_err(|_| not_entered("gateway.disclosure.binding"))? + .maximum_bytes; + let channel = crate::disclosure_transport::AuthenticatedDisclosureChannel::authenticate( + connection, + approved.effect().binding(), + bytes, + plan.recipient_key(), + ) + .await + .map_err(not_entered)?; + let entry_started = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let granted = self + .attempts + .grant_disclosure( + Arc::clone(&approved), + io.entry_validation().map_err(not_entered)?, + entry_started, + channel, + ) + .await; + if let Ok((grant, permit)) = granted { + if let Some(ack) = crate::disclosure_transport::deliver(permit).await { + let operation = crate::LogicalOperationId::parse( + approved.effect().binding().journal_identity().1, + ) + .map_err(|_| not_entered("gateway.disclosure.binding"))?; + if let Ok(snapshot) = self + .attempts + .acknowledge_disclosure(self.recipe.namespace(), &operation, &ack) + .await + { + return Ok(snapshot); + } + } + // A concurrently recorded exact late ACK wins; the reducer refuses + // replacing it with unknown and the final projection retains it. + if let Ok(snapshot) = grant.record_unknown().await { + return Ok(snapshot); + } + } + self.attempts + .read_disclosure(&approved) + .await + .ok() + .flatten() + .ok_or_else(|| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }) + } + /// Compiles a declared content GET from exact resource arguments using /// fresh independent native read authority. Performs no custody or provider /// I/O and returns private review/approval data only. diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index c0bafc808..c3d429d1a 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -29,6 +29,8 @@ mod engine; mod entry; mod execution_witness; pub use execution_witness::GatewayExecutionWitness; +#[cfg(unix)] +pub mod disclosure_transport; #[cfg(feature = "fuzzing")] pub mod fuzzing; mod generation_floor; diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index 0f10a0672..a4f75337d 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/14"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/15"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 2a9d8302d..707f737fa 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -27,6 +27,15 @@ const SCHEMA: &str = "auths.gateway-codes/1"; /// none exists yet). The fixture letters are R for the recipe corpus, A for /// the attempt scenarios, B for the bounds cases, and O for the outcomes. const ROWS: &[&str] = &[ + "gateway.disclosure.channel disclosure_transport authentication new 74 -", + "gateway.disclosure.peer disclosure_transport authentication new 74 -", + "gateway.disclosure.authentication disclosure_transport authentication new 74 -", + "gateway.disclosure.timeout disclosure_transport transport new 74 -", + "gateway.disclosure.acknowledgement disclosure_transport acknowledgement new 74 -", + "gateway.disclosure.length disclosure_transport transport new 74 -", + "gateway.disclosure.frame disclosure_transport transport new 74 -", + "gateway.disclosure.read disclosure_transport transport new 74 -", + "gateway.disclosure.write disclosure_transport transport new 74 -", "gateway.disclosure.exhausted effect admission new 74 -", "gateway.disclosure.binding effect compile new 74 -", "gateway.disclosure.unsupported-bounds effect compile new 74 -", diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 215bf4626..13d4a708f 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/14"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/15"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 840f00685..37438e76e 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/14", + "store_schema": "auths.gateway-attempt/15", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index c418b2cd9..b7aa48a6d 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/14"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/15"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/14", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/15", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index c819dfb95..bc5f05bef 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "6f0865c42e5c3da44502a453e2aca70342c3bc88bcf7e8a82080becfef2380ab"; + "5134ad54772c32a0ae5b4f92589e088925cc520d092afb0caffef5abc3467bc3"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 4a80f1a62..e26afaf2f 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/14`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/15`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/14"; +const SCHEMA: &str = "auths.gateway-attempt/15"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -719,6 +719,8 @@ pub use acquisition::{ RecoverySourceFacts, ReservedAcquisition, RetainedContent, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; +#[cfg(unix)] +pub(crate) use disclosure::DisclosureEntryPermit; pub use disclosure::{DisclosureSnapshot, DisclosureStage}; trait JournalProtocol: Clone + Sized { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 3fe287ea8..ec672f610 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -8,6 +8,8 @@ use crate::effect::{AcquisitionPlan, ClosedPrerequisiteRead, PrerequisiteKind, S mod content; use content::ContentResult; pub(super) use content::retained; +#[cfg(unix)] +pub(super) use content::retained_bytes; pub use content::{ContentProjectionStatus, RetainedContent}; mod candidate; pub use candidate::CandidatePublication; diff --git a/product/runtime/auths-gateway/src/store/acquisition/content.rs b/product/runtime/auths-gateway/src/store/acquisition/content.rs index ef71c51ba..3457220e0 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/content.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/content.rs @@ -100,6 +100,27 @@ pub(in crate::store) fn retained( )) } +/// Reconstructs bytes only for the final fenced delivery grant. The decoder +/// revalidates the source MAC and transport/projection facts before returning. +#[cfg(unix)] +pub(in crate::store) fn retained_bytes( + bytes: &[u8], +) -> Result>, GatewayAttemptError> { + let record: Record = decode_as(bytes)?; + let AcquisitionPlan::Content(plan) = &record.state.plan else { + return Err(GatewayAttemptError::InvalidTransition); + }; + let AcquisitionPhase::ContentResponseRecorded { + content: ContentResult::Ready(_), + response, + metadata, + } = &record.state.phase + else { + return Err(GatewayAttemptError::InvalidTransition); + }; + project(plan, response, metadata)?.map_err(|_| GatewayAttemptError::Corrupt) +} + #[derive(Clone, Deserialize, Serialize)] #[serde( tag = "kind", diff --git a/product/runtime/auths-gateway/src/store/disclosure.rs b/product/runtime/auths-gateway/src/store/disclosure.rs index f8d5e9305..23ea40d88 100644 --- a/product/runtime/auths-gateway/src/store/disclosure.rs +++ b/product/runtime/auths-gateway/src/store/disclosure.rs @@ -2,6 +2,7 @@ //! Admission reserves capacity only. Persisted facts never mint a delivery permit. use super::acquisition::{append_dependencies, select_snapshots}; use super::*; +use crate::effect::disclosure_auth::RecipientAuthentication; use crate::effect::{DisclosureAcknowledgement, DisclosurePlan}; /// Redacted disclosure facts, separate from provider response and observation. @@ -45,6 +46,7 @@ pub(super) struct DisclosureState { allocation: Option, counters: Vec, phase: DisclosurePhase, + authentication: Option, } #[derive(Clone, Deserialize, Serialize)] @@ -100,7 +102,7 @@ impl JournalProtocol for DisclosureState { entry: record .entry .as_ref() - .map(canonical) + .map(|entry| canonical(&(entry, &record.state.authentication))) .transpose()? .unwrap_or_default(), stage: record.state.phase.kernel(), @@ -127,6 +129,18 @@ impl JournalProtocol for DisclosureState { .plan .validate(&binding) .map_err(|_| GatewayAttemptError::Corrupt)?; + if record.entry.is_some() != record.state.authentication.is_some() { + return Err(GatewayAttemptError::Corrupt); + } + if let Some(authentication) = &record.state.authentication { + authentication + .validate( + &binding, + capacity.maximum_bytes, + record.state.plan.recipient_key(), + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; + } let counters = capacity::decode_counters(&record.state.counters)?; if record.state.allocation.is_some() { let counts: Vec<_> = counters @@ -337,6 +351,7 @@ impl GatewayAttempts { allocation: None, counters: Vec::new(), phase: DisclosurePhase::Reserved, + authentication: None, }, )?; base.validate_header()?; @@ -523,6 +538,7 @@ impl GatewayAttempts { approved: &ApprovedEffect, now: u64, unknown: bool, + authentication: RecipientAuthentication, ) -> Result { let binding = approved.effect().binding(); let (namespace, operation, _, _) = binding.journal_identity(); @@ -541,6 +557,7 @@ impl GatewayAttempts { let mut next = record.clone(); next.record_grant(approved, now, now, None, &[])?; next.state.phase = DisclosurePhase::EntryGranted; + next.state.authentication = Some(authentication); if !valid_transition(&record, &next)? { return Err(GatewayAttemptError::InvalidTransition); } @@ -562,3 +579,200 @@ impl GatewayAttempts { } } } + +/// Newly acknowledged local delivery authority. No clone, decoder or public +/// plaintext accessor exists; only the closed transport consumes this value. +#[cfg(unix)] +pub(crate) struct DisclosureEntryPermit { + _approved: Arc, + channel: crate::disclosure_transport::AuthenticatedDisclosureChannel, + content: zeroize::Zeroizing>, +} + +#[cfg(unix)] +impl DisclosureEntryPermit { + pub(crate) fn into_delivery( + self, + ) -> ( + crate::disclosure_transport::AuthenticatedDisclosureChannel, + zeroize::Zeroizing>, + ) { + (self.channel, self.content) + } +} + +#[cfg(unix)] +pub(crate) struct GrantedDisclosure { + attempt: Attempt, +} + +#[cfg(unix)] +impl GrantedDisclosure { + pub(crate) async fn record_unknown(self) -> Result { + let mut next = self.attempt.record.clone(); + next.state.phase = DisclosurePhase::Unknown; + self.attempt + .advance(next) + .await? + .record + .disclosure_snapshot() + } +} + +#[cfg(unix)] +impl GatewayAttempts { + /// Fresh native, source, capacity and live-channel validation under the + /// common writer fence. The permit exists only after durable acknowledgement. + #[allow( + clippy::too_many_lines, + reason = "one final fenced disclosure decision and acknowledgement boundary" + )] + pub(crate) async fn grant_disclosure( + &self, + approved: Arc, + validation: crate::entry::EntryValidation, + authorization_started_at: u64, + channel: crate::disclosure_transport::AuthenticatedDisclosureChannel, + ) -> Result<(GrantedDisclosure, DisclosureEntryPermit), GatewayAttemptError> { + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let plan = approved + .disclosure_plan() + .map_err(|_| GatewayAttemptError::BindingConflict)?; + let capacity = plan + .validate(binding) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let (namespace, operation, _, _) = binding.journal_identity(); + let namespace = + OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?; + let operation = + LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; + let key = self.key(&namespace, &operation)?; + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let source_operation = LogicalOperationId::parse(source.journal_identity().1) + .map_err(|_| GatewayAttemptError::Corrupt)?; + let source_key = self.key(&namespace, &source_operation)?; + let store = Arc::clone(&self.store); + blocking(move || { + let stored = store + .load(GatewayRecordKind::Attempt, &key)? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&stored)?; + if !matches!(record.state.phase, DisclosurePhase::Reserved) + || record.state.plan != plan + || record.validate_header()? != *approved.effect().binding() + { + return Err(GatewayAttemptError::BindingConflict); + } + let slot = record + .state + .allocation + .ok_or(GatewayAttemptError::Corrupt)?; + let mut keys = vec![ + (GatewayRecordKind::Attempt, key), + (GatewayRecordKind::Attempt, source_key), + ( + GatewayRecordKind::EffectAllocation, + capacity::allocation_key(&capacity, slot), + ), + ]; + let native_indices = append_dependencies(&mut keys, &validation.dependencies()); + let native_end = keys.len(); + keys.extend(capacity::dependencies(&record.state.counters)?); + let mut committed = None; + store.fenced_replace(&keys, &mut |snapshots| { + if snapshots.len() != keys.len() + || snapshots[0].as_deref() != Some(stored.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + let current: Record = decode_as( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if !matches!(current.state.phase, DisclosurePhase::Reserved) + || current.state.plan != plan + || current.validate_header()? != *approved.effect().binding() + { + return Err(GatewayAttemptError::BindingConflict); + } + let source_at = source_matches(&plan, snapshots[1].as_deref())?; + if snapshots[2].as_deref() + != Some(canonical(&allocation(&plan, key, slot)?)?.as_slice()) + { + return Err(GatewayAttemptError::BindingConflict); + } + let now = validation + .validate( + &approved, + &select_snapshots(snapshots, &native_indices)?, + authorization_started_at, + ) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + if now < source_at { + return Err(GatewayAttemptError::InvalidTransition); + } + capacity::validate_reservations( + ¤t.namespace, + ¤t.operation_id, + ¤t.state.counters, + key, + approved.disclosure_bound(), + &snapshots[native_end..], + now, + )?; + channel + .validate( + approved.effect().binding(), + capacity.maximum_bytes, + plan.recipient_key(), + ) + .map_err(|_| GatewayAttemptError::InvalidTransition)?; + let content = acquisition::retained_bytes( + snapshots[1] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if content.len() as u64 != capacity.maximum_bytes { + return Err(GatewayAttemptError::Corrupt); + } + let mut next = current.clone(); + next.record_grant( + &approved, + authorization_started_at, + now, + None, + &snapshots[1..], + )?; + next.state.phase = DisclosurePhase::EntryGranted; + next.state.authentication = Some(channel.evidence()); + if !valid_transition(¤t, &next)? { + return Err(GatewayAttemptError::InvalidTransition); + } + let bytes = encode(&next)?; + committed = Some((next, bytes.clone(), content)); + Ok(bytes) + })?; + let (record, stored, content) = committed.ok_or(GatewayAttemptError::Unavailable)?; + Ok(( + GrantedDisclosure { + attempt: Attempt { + store, + key, + stored, + record, + }, + }, + DisclosureEntryPermit { + _approved: approved, + channel, + content, + }, + )) + }) + .await + } +} From 189bb1ea6b5be09e020f236bd4bf655f38082ede Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 22:40:36 +0000 Subject: [PATCH 055/136] feat(gateway): expose native content and disclosure application controls --- .../gateway/application-content-cli.json | 54 +++ .../gateway/application-content-frame.json | 385 ++++++++++++++++++ .../fixtures/gateway/content-compilation.json | 3 +- .../fixtures/gateway/disclosure-delivery.json | 3 +- bindings/python/python/auths/gateway.py | 35 ++ bindings/python/tests/test_gateway_client.py | 36 ++ bindings/typescript/src/gateway.ts | 30 ++ .../test/unit/gateway-client.test.js | 27 ++ compliance.toml | 26 +- ...017-bound-effect-and-recovery-ownership.md | 36 ++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 30 ++ docs/plans/0074-implementation-status.md | 53 ++- .../0009-bound-effect-and-recovery.md | 19 + ...ound-effects-and-recovery-state-machine.md | 42 +- .../corpus/target_gateway_app_frame/content | 1 + .../target_gateway_app_frame/content-history | 1 + .../corpus/target_gateway_app_frame/disclose | 1 + .../target_gateway_app_frame/disclosure-ack | 1 + .../fuzz_targets/target_gateway_app_frame.rs | 9 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/app.rs | 141 ++++++- .../runtime/auths-gateway/src/app/content.rs | 375 +++++++++++++++++ .../auths-gateway/src/app/content_tests.rs | 200 +++++++++ .../auths-gateway/src/bin/auths-gateway.rs | 340 +++++++++++++++- .../auths-gateway/src/disclosure_transport.rs | 66 ++- product/runtime/auths-gateway/src/effect.rs | 4 +- .../auths-gateway/src/effect/acquisition.rs | 15 +- .../auths-gateway/src/effect/content.rs | 37 ++ .../auths-gateway/src/effect_content_tests.rs | 29 +- .../src/effect_disclosure_delivery_tests.rs | 77 +++- product/runtime/auths-gateway/src/engine.rs | 87 ++++ product/runtime/auths-gateway/src/lib.rs | 19 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 61 +++ .../auths-gateway/src/store/acquisition.rs | 7 +- .../src/store/acquisition/content.rs | 2 +- .../auths-gateway/src/store/disclosure.rs | 5 +- .../tests/application_content_cli.rs | 131 ++++++ 38 files changed, 2304 insertions(+), 88 deletions(-) create mode 100644 bindings/fixtures/gateway/application-content-cli.json create mode 100644 bindings/fixtures/gateway/application-content-frame.json create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content-history create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclosure-ack create mode 100644 product/runtime/auths-gateway/src/app/content.rs create mode 100644 product/runtime/auths-gateway/src/app/content_tests.rs create mode 100644 product/runtime/auths-gateway/tests/application_content_cli.rs diff --git a/bindings/fixtures/gateway/application-content-cli.json b/bindings/fixtures/gateway/application-content-cli.json new file mode 100644 index 000000000..44d832a6a --- /dev/null +++ b/bindings/fixtures/gateway/application-content-cli.json @@ -0,0 +1,54 @@ +{ + "schema": "auths.application-content-cli-fixture/1", + "scope": "production CLI with real refusal sockets; no installed engine/provider/disclosure-receive claim", + "cases": [ + { + "command": "content-acquire", + "request": { + "schema": "auths.gateway-content/1", + "submission": { + "schema": "auths.gateway-submit/2", + "proof_b64": "AA", + "action_b64": "AA", + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + } + }, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.acquisition.binding" + } + } + }, + { + "command": "content-history", + "request": { + "schema": "auths.gateway-content-history/1", + "operation": "fixture-1" + }, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.attempt.state-unavailable" + } + } + }, + { + "command": "disclosure-acknowledge", + "request": { + "schema": "auths.gateway-disclosure-acknowledge/1", + "operation": "fixture-1", + "acknowledgement_b64": "eyJyZXF1ZXN0Ijp7ImFja25vd2xlZGdlZF9ieXRlcyI6NDIsImNoYW5uZWwiOlsxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMl0sImRlbGl2ZXJ5X2luc3RhbmNlIjpbMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTNdLCJlZmZlY3QiOlsxODAsMTkwLDIzNSwzNSwyMzcsMTI1LDI1NCw5MSwyMiwyMzUsMjQxLDE4NywxMzksMTExLDExLDUsMjM0LDIyNiwxMTMsMTY0LDEwNywxMTEsMjM5LDg2LDIyNSw2OSwzNSwyMzIsMjQ2LDIxMywyNDcsMTY5XSwibWF4aW11bV9ieXRlcyI6MTAwLCJwcm9qZWN0aW9uIjpbMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTRdLCJwcm90ZWN0ZWRfY29udGVudCI6WzExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExXSwicmVjaXBpZW50Ijoia2V5OnNoYTI1NjprZUNTNXVtdjRnZkpUejJpMDFvcGZIaDZXTWo5RjZrYzF0c3lleXFvaTdnIiwicmVjaXBpZW50X2tleSI6WzY3LDQsMTA3LDI1NCw2NCwxNDYsMTc5LDIzMyw3MywxNDgsMjM0LDIxOCwyMSwyMjAsMTk0LDEzLDEzOCwxNzAsNywxODIsODgsMjUzLDU3LDg0LDIzNSwxNDIsMTQsMjUxLDEzOSwyMjAsMTY1LDIyMl0sInNjaGVtYSI6ImF1dGhzLmdhdGV3YXktZGlzY2xvc3VyZS1hY2svMSIsInNvdXJjZV9lZmZlY3QiOlsxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMF19LCJzaWduYXR1cmVfYjY0IjoiMlZOR1Z6NmVjd3NDeUM0bGdiZkFxcl94b1FkUDhFM0UySEFmYmJJV29tNWNLTlpPSVdLSzFmeTBXaDZsRWozRWduaTN6NFVRT3N3SVE2bmZ5U1RmQmcifQ" + }, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.disclosure.acknowledgement" + } + } + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/application-content-frame.json b/bindings/fixtures/gateway/application-content-frame.json new file mode 100644 index 000000000..5eaf1d6b9 --- /dev/null +++ b/bindings/fixtures/gateway/application-content-frame.json @@ -0,0 +1,385 @@ +{ + "schema": "auths.gateway-application-content-fixture/1", + "scope": "real socket framing with counting refusal oracle; no installed authority, provider I/O or content delivery", + "requests": { + "content": { + "schema": "auths.gateway-content/1", + "submission": { + "schema": "auths.gateway-submit/2", + "proof_b64": "AA", + "action_b64": "AA", + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + } + }, + "content-history": { + "schema": "auths.gateway-content-history/1", + "operation": "fixture-1" + }, + "disclose": { + "schema": "auths.gateway-disclose/1", + "target": { + "source_operation": "fixture-source", + "recipient_key": [ + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19 + ], + "channel": { + "schema": "auths.gateway-unix-disclosure-channel/1", + "gateway_uid": 100, + "recipient_uid": 101, + "channel_id": [ + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19, + 19 + ] + }, + "delivery_instance": [ + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20 + ] + }, + "submission": { + "schema": "auths.gateway-submit/2", + "proof_b64": "AA", + "action_b64": "AA", + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + } + }, + "disclosure-ack": { + "schema": "auths.gateway-disclosure-acknowledge/1", + "operation": "fixture-1", + "acknowledgement_b64": "eyJyZXF1ZXN0Ijp7ImFja25vd2xlZGdlZF9ieXRlcyI6NDIsImNoYW5uZWwiOlsxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMl0sImRlbGl2ZXJ5X2luc3RhbmNlIjpbMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTNdLCJlZmZlY3QiOlsxODAsMTkwLDIzNSwzNSwyMzcsMTI1LDI1NCw5MSwyMiwyMzUsMjQxLDE4NywxMzksMTExLDExLDUsMjM0LDIyNiwxMTMsMTY0LDEwNywxMTEsMjM5LDg2LDIyNSw2OSwzNSwyMzIsMjQ2LDIxMywyNDcsMTY5XSwibWF4aW11bV9ieXRlcyI6MTAwLCJwcm9qZWN0aW9uIjpbMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTRdLCJwcm90ZWN0ZWRfY29udGVudCI6WzExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExXSwicmVjaXBpZW50Ijoia2V5OnNoYTI1NjprZUNTNXVtdjRnZkpUejJpMDFvcGZIaDZXTWo5RjZrYzF0c3lleXFvaTdnIiwicmVjaXBpZW50X2tleSI6WzY3LDQsMTA3LDI1NCw2NCwxNDYsMTc5LDIzMyw3MywxNDgsMjM0LDIxOCwyMSwyMjAsMTk0LDEzLDEzOCwxNzAsNywxODIsODgsMjUzLDU3LDg0LDIzNSwxNDIsMTQsMjUxLDEzOSwyMjAsMTY1LDIyMl0sInNjaGVtYSI6ImF1dGhzLmdhdGV3YXktZGlzY2xvc3VyZS1hY2svMSIsInNvdXJjZV9lZmZlY3QiOlsxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMF19LCJzaWduYXR1cmVfYjY0IjoiMlZOR1Z6NmVjd3NDeUM0bGdiZkFxcl94b1FkUDhFM0UySEFmYmJJV29tNWNLTlpPSVdLSzFmeTBXaDZsRWozRWduaTN6NFVRT3N3SVE2bmZ5U1RmQmcifQ" + } + }, + "cases": [ + { + "route": "content", + "case": "valid", + "dispatched": true, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.acquisition.binding" + } + } + }, + { + "route": "content", + "case": "obsolete", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "route": "content", + "case": "transport-override", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "content", + "case": "duplicate-schema", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "content", + "case": "bad-approval", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-encoding" + } + } + }, + { + "route": "content", + "case": "oversized-action", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-encoding" + } + } + }, + { + "route": "disclose", + "case": "valid", + "dispatched": true, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.disclosure.binding" + } + } + }, + { + "route": "disclose", + "case": "obsolete", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "route": "disclose", + "case": "transport-override", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "disclose", + "case": "duplicate-schema", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "disclose", + "case": "bad-approval", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-encoding" + } + } + }, + { + "route": "disclose", + "case": "oversized-action", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-encoding" + } + } + }, + { + "route": "disclose", + "case": "unknown-channel", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.disclosure.channel" + } + } + }, + { + "route": "content-history", + "case": "valid", + "dispatched": true, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.attempt.state-unavailable" + } + } + }, + { + "route": "content-history", + "case": "obsolete", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "route": "content-history", + "case": "transport-override", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "content-history", + "case": "duplicate-schema", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "disclosure-ack", + "case": "valid", + "dispatched": true, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.disclosure.acknowledgement" + } + } + }, + { + "route": "disclosure-ack", + "case": "obsolete", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + } + }, + { + "route": "disclosure-ack", + "case": "transport-override", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "disclosure-ack", + "case": "duplicate-schema", + "dispatched": false, + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + } + }, + { + "route": "disclosure-ack", + "case": "oversized-ack", + "dispatched": false, + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + } + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/content-compilation.json b/bindings/fixtures/gateway/content-compilation.json index a54962a18..e2c54e9e2 100644 --- a/bindings/fixtures/gateway/content-compilation.json +++ b/bindings/fixtures/gateway/content-compilation.json @@ -1810,5 +1810,6 @@ ], "unsafe_path_query_pointer_refused": true }, - "undeclared_content_read_refused": true + "undeclared_content_read_refused": true, + "native_action_resource_projection_parity": true } \ No newline at end of file diff --git a/bindings/fixtures/gateway/disclosure-delivery.json b/bindings/fixtures/gateway/disclosure-delivery.json index e49ac1063..ceeccf2f2 100644 --- a/bindings/fixtures/gateway/disclosure-delivery.json +++ b/bindings/fixtures/gateway/disclosure-delivery.json @@ -1,6 +1,7 @@ { "schema": "auths.gateway-disclosure-delivery-fixture/1", - "scope": "real Unix socket pairs and installed native file fence; no independent processes, hostile UID isolation or PostgreSQL claim", + "scope": "native application client with a control-frame shim, real Unix socket pairs and installed native file fence; no installed app dispatcher, independent processes, hostile UID isolation or PostgreSQL claim", + "native_application_client_protocol_switch": true, "authenticated_delivery": { "revision": 3, "stage": "acknowledged", diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index e8ff89180..1a9d2b38f 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -486,6 +486,41 @@ async def recover( payload, "gateway recovery exchange unavailable; outcome may be unknown" ) + async def acquire_content(self, *, proof: bytes, action: bytes, approval: bytes) -> bytes: + """Return native acquisition/refusal bytes; no provider content is released. + + Resource arguments come only from the signed native action. IPC failure + cannot authorize a new read. Disclosure uses the native recipient client. + """ + payload = json.dumps({"schema": "auths.gateway-content/1", + "submission": _submission(proof, action, approval)}, + separators=(",", ":")).encode("utf-8") + return await self._exchange(payload, "content acquisition may be unknown") + + async def content_history(self, operation: str) -> bytes: + """Return redacted native history unchanged, without provider I/O.""" + if not isinstance(operation, str) or _OPERATION_ID.fullmatch(operation) is None: + raise ValueError("operation ID must be a canonical 1-128-byte token") + payload = json.dumps({"schema": "auths.gateway-content-history/1", "operation": operation}, + separators=(",", ":")).encode("utf-8") + return await self._exchange(payload, "content history unavailable") + + async def acknowledge_disclosure(self, operation: str, acknowledgement: bytes) -> bytes: + """Carry exact ACK bytes produced by the native recipient client. + + Rust validates the signature and retained grant. This wrapper does not + sign, hash, interpret evidence or authorize another delivery. + """ + if not isinstance(operation, str) or _OPERATION_ID.fullmatch(operation) is None: + raise ValueError("operation ID must be a canonical 1-128-byte token") + if not isinstance(acknowledgement, bytes) or not 1 <= len(acknowledgement) <= 4096: + raise ValueError("acknowledgement must be 1-4096 native canonical bytes") + payload = json.dumps({"schema": "auths.gateway-disclosure-acknowledge/1", + "operation": operation, + "acknowledgement_b64": _encode_base64url(acknowledgement)}, + separators=(",", ":")).encode("utf-8") + return await self._exchange(payload, "disclosure acknowledgement persistence may be unknown") + async def observe_outcome(self, operation_id: str) -> GatewayObserveResult: """Ask the gateway to sign the stored outcome of one logical operation. diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index 9d386230b..ea0285ba2 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -436,3 +436,39 @@ def test_native_replay_projection_corpus() -> None: for value in corpus["reserved_decoding"]["invalid"]: with pytest.raises(GatewayProtocolError): _parse_result(json.dumps(value).encode()) + + +@pytest.mark.skipif(sys.platform == "win32", reason="Unix application socket") +@pytest.mark.parametrize("route", ["content", "content-history", "disclosure-ack"]) +def test_content_controls_preserve_native_envelopes(socket_dir, route) -> None: + corpus = json.loads((Path(__file__).resolve().parents[2] / "fixtures/gateway/application-content-frame.json").read_text()) + request = corpus["requests"][route] + reply = json.dumps(next(case["response"] for case in corpus["cases"] if case["route"] == route and case["case"] == "valid")).encode() + def decode(value: str) -> bytes: + return base64.urlsafe_b64decode(value + "=" * (-len(value) % 4)) + async def scenario() -> None: + seen: list[dict[str, object]] = [] + server = await _serve_once(socket_dir / "gateway.sock", reply, seen) + async with server: + client = GatewayClient(GatewayEndpoint(socket_dir / "gateway.sock")) + if route == "content": + result = await client.acquire_content(**{name: decode(request["submission"][name + "_b64"]) for name in ("proof", "action", "approval")}) + elif route == "content-history": + result = await client.content_history(request["operation"]) + else: + result = await client.acknowledge_disclosure(request["operation"], decode(request["acknowledgement_b64"])) + assert result == reply + assert seen == [request] + asyncio.run(scenario()) + + +def test_content_controls_refuse_unbounded_or_invalid_input(socket_dir) -> None: + client = GatewayClient(GatewayEndpoint(socket_dir / "unused.sock")) + for operation in ("", "bad/id", "a" * 129): + with pytest.raises(ValueError): + asyncio.run(client.content_history(operation)) + with pytest.raises(ValueError): + asyncio.run(client.acknowledge_disclosure(operation, b"ack")) + for acknowledgement in (b"", b"a" * 4097): + with pytest.raises(ValueError): + asyncio.run(client.acknowledge_disclosure("fixture-1", acknowledgement)) diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index 66e02faa6..a0208f404 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -388,6 +388,36 @@ export class GatewayClient { return this.#exchange(payload, "recovery outcome may be unknown", (bytes) => bytes); } + /** Native acquisition facts only. Resources come from the signed action; + * no content is released and a lost reply never permits another read. */ + async acquireContent(input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Promise { + const payload = new TextEncoder().encode(JSON.stringify({ schema: "auths.gateway-content/1", submission: submission(input) })); + return this.#exchange(payload, "content acquisition may be unknown", (bytes) => bytes); + } + + /** Redacted native history, unchanged, with no provider or recipient I/O. */ + async contentHistory(operation: string): Promise { + if (typeof operation !== "string" || !OPERATION_ID.test(operation)) { + throw new TypeError("operation ID must be a canonical 1-128-byte token"); + } + const payload = new TextEncoder().encode(JSON.stringify({ schema: "auths.gateway-content-history/1", operation })); + return this.#exchange(payload, "content history unavailable", (bytes) => bytes); + } + + /** Carries canonical ACK bytes produced by the native recipient client. + * Rust alone checks signatures and retained grants; this never redelivers. */ + async acknowledgeDisclosure(operation: string, acknowledgement: Uint8Array): Promise { + if (typeof operation !== "string" || !OPERATION_ID.test(operation)) { + throw new TypeError("operation ID must be a canonical 1-128-byte token"); + } + if (!(acknowledgement instanceof Uint8Array) || acknowledgement.length < 1 || acknowledgement.length > 4096) { + throw new TypeError("acknowledgement must be 1-4096 native canonical bytes"); + } + const payload = new TextEncoder().encode(JSON.stringify({ schema: "auths.gateway-disclosure-acknowledge/1", + operation, acknowledgement_b64: encodeBase64Url(acknowledgement) })); + return this.#exchange(payload, "disclosure acknowledgement persistence may be unknown", (bytes) => bytes); + } + /** * Asks the gateway to sign the stored outcome of one logical operation. The gateway * reads only its own attempt store; no provider is contacted. Throws `TypeError` for a diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index 0f34e8376..be080d27b 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -313,3 +313,30 @@ test("gateway decodes the native replay and reservation corpus", { skip: process await assert.rejects(replyOnce(JSON.stringify(invalid)), GatewayProtocolError); } }); + + +test("native content control envelopes preserve Rust fixtures", { skip: process.platform === "win32" }, async () => { + for (const route of ["content", "content-history", "disclosure-ack"]) { + const corpus = JSON.parse(await readFile(new URL("../../../fixtures/gateway/application-content-frame.json", import.meta.url), "utf8")); + const request = corpus.requests[route]; + const reply = JSON.stringify(corpus.cases.find((item) => item.route === route && item.case === "valid").response); + const { result, seen } = await observeOnce(reply, (client) => { + if (route === "content") return client.acquireContent(Object.fromEntries(["proof", "action", "approval"].map((name) => [name, Buffer.from(request.submission[`${name}_b64`], "base64url")]))); + if (route === "content-history") return client.contentHistory(request.operation); + return client.acknowledgeDisclosure(request.operation, Buffer.from(request.acknowledgement_b64, "base64url")); + }); + assert.equal(new TextDecoder().decode(result), reply); + assert.deepEqual(seen, [request]); + } +}); + +test("content controls reject invalid operation and ACK bounds", async () => { + const client = new GatewayClient(new GatewayEndpoint("/tmp/unused-content.sock")); + for (const operation of ["", "bad/id", "a".repeat(129)]) { + await assert.rejects(client.contentHistory(operation), TypeError); + await assert.rejects(client.acknowledgeDisclosure(operation, new Uint8Array([1])), TypeError); + } + for (const acknowledgement of [new Uint8Array(), new Uint8Array(4097)]) { + await assert.rejects(client.acknowledgeDisclosure("fixture-1", acknowledgement), TypeError); + } +}); diff --git a/compliance.toml b/compliance.toml index f69b77298..d11fe9939 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1430,8 +1430,8 @@ kind = "cargo" layer = "bindings" path = "bindings/python" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-identity", "auths-identity-raw-key", "auths-model", "auths-ports", "auths-raw-key", "auths-registries", "auths-signature", "auths-signature-core", "auths-signature-ed25519", "auths-verifier"] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.openapi-derive-result/1", "auths.portable-receipt/1"] -wire_objects = ["ActionEnvelope", "AuthorizationPlan", "CanonicalAction", "GrantStatement", "GrantStatusSnapshot", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusSnapshot", "PrincipalStatusStatement", "ProofBundle", "SignedAction", "SignedGrant", "SignedGrantStatus", "SignedPrincipalStatus", "VerifierContext"] +protocol_versions = ["auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths-proof/v1", "auths.gateway-submit/2", "auths.openapi-derive-result/1", "auths.portable-receipt/1"] +wire_objects = ["AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "ActionEnvelope", "AuthorizationPlan", "CanonicalAction", "GrantStatement", "GrantStatusSnapshot", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusSnapshot", "PrincipalStatusStatement", "ProofBundle", "SignedAction", "SignedGrant", "SignedGrantStatus", "SignedPrincipalStatus", "VerifierContext"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/openapi-derivation", "bindings/python/differential-fixtures-v1.json", "core/fixtures/v1"] principal_families = ["self-contained-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1441,6 +1441,10 @@ configuration_inputs = ["gateway-app-socket", "trusted-authority-configuration"] security_state = ["portable-linked-receipts"] [packages.auths-proof-python.claims] +content-control-envelopes = [ + "bindings/python/tests/test_gateway_client.py#test_content_controls_preserve_native_envelopes", + "bindings/python/tests/test_gateway_client.py#test_content_controls_refuse_unbounded_or_invalid_input", +] core-wire-consumer = ["bindings/python/tests/test_native_boundary_contract.py#test_every_registry_code_classifies_through_the_native_layer", "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_projection_is_self_contained", "bindings/python/tests/test_native_authoring.py#test_child_planning_matches_the_shared_rust_typescript_fixture", "bindings/python/tests/test_workflow.py#test_attach_and_delegate_use_native_authority_without_protocol_bytes"] language-binding = ["bindings/python/tests/test_remote_approval.py#test_python_issues_the_native_requests", "bindings/python/tests/test_remote_approval.py#test_python_opens_every_request_vector", "bindings/python/tests/test_remote_approval.py#test_python_collects_every_vector", "bindings/python/tests/test_approval_quorum.py#test_python_authors_the_exact_gateway_quorum_bytes", "bindings/python/tests/test_approval_quorum.py#test_python_verifier_decides_every_gateway_vector_identically", "bindings/python/tests/test_openapi_derivation.py#test_native_route_reproduces_the_corpus", "bindings/python/tests/test_openapi_derivation.py#test_derive_generate_check_and_hand_edit", "bindings/python/tests/test_public_api_v2.py#test_exact_public_inventory", "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_rejects_contradictory_projection", "bindings/python/tests/test_gateway_outcome_v2.py#test_python_client_accepts_every_signed_outcome", "bindings/python/tests/test_gateway_outcome_v2.py#test_python_verifier_reaches_the_gateway_verdict", "bindings/python/tests/test_self_hosted_operator.py#test_trusted_context_is_the_native_compile_bound_to_one_request", "bindings/python/tests/test_self_hosted_operator.py#test_root_grant_equals_the_native_path_and_carries_the_signer_evidence", "bindings/python/tests/test_enforcement_init.py#test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest", "bindings/python/tests/test_enforcement_init.py#test_audit_passes_the_gateway_verdict_through_and_adds_no_option"] runtime-enforcement-boundary = ["bindings/python/tests/test_public_api_v2.py#test_receipts_reject_direct_construction", "bindings/python/tests/test_public_api_v2.py#test_product_root_is_small_and_removed_names_are_absent", "bindings/python/tests/test_public_api_v2.py#test_local_agent_client_modules_are_not_importable", "bindings/python/tests/test_native_boundary_contract.py#test_a_python_caller_cannot_mint_a_canonical_action_for_its_own_profile", "bindings/python/tests/test_native_boundary_contract.py#test_no_native_symbol_is_exported_without_being_declared"] @@ -1604,8 +1608,8 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/15", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] -wire_objects = ["UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/15", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] @@ -1615,6 +1619,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +content-application-boundary = [ + "product/runtime/auths-gateway/src/app/content_tests.rs#native_application_content_frame_fixture_is_current", + "product/runtime/auths-gateway/tests/application_content_cli.rs#native_application_content_cli_fixture_is_current", +] disclosure-local-socket-file-grant = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", ] @@ -2050,9 +2058,9 @@ kind = "npm" layer = "bindings" path = "bindings/typescript" core_apis = ["auths-openapi-derive-wasm", "auths-proof-wasm"] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.portable-receipt/1"] -wire_objects = ["ActionEnvelope", "CanonicalAction", "GrantStatement", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusStatement", "ProofBundle", "VerifierContext"] -fixture_suites = ["core/fixtures/v1"] +protocol_versions = ["auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths-proof/v1", "auths.gateway-submit/2", "auths.portable-receipt/1"] +wire_objects = ["AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "ActionEnvelope", "CanonicalAction", "GrantStatement", "GrantStatusStatement", "PortableReceiptV1", "PortableVerificationResult", "PrincipalStatusStatement", "ProofBundle", "VerifierContext"] +fixture_suites = ["bindings/fixtures/gateway", "core/fixtures/v1"] principal_families = ["self-contained-v1"] signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2", "core-corpus"] @@ -2061,6 +2069,10 @@ configuration_inputs = ["gateway-app-socket", "trusted-authority-configuration"] security_state = ["portable-linked-receipts"] [packages."@auths-dev/sdk".claims] +content-control-envelopes = [ + "bindings/typescript/test/unit/gateway-client.test.js#native content control envelopes preserve Rust fixtures", + "bindings/typescript/test/unit/gateway-client.test.js#content controls reject invalid operation and ACK bounds", +] core-wire-consumer = ["bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt v1 uses the Rust projection and needs no companion input", "bindings/typescript/test/integration/workflow/attach.test.js#attachAgent binds one canonical root authority through native Rust", "bindings/typescript/test/integration/workflow/delegation.test.js#delegate plans reviews approves and signs one attenuated child", "bindings/typescript/test/integration/workflow/client.test.js#transaction binding drives the real Rust WASM authoring ABI"] language-binding = ["bindings/typescript/test/unit/public-api-v2.test.js#clean-cut modules expose the intended domain-neutral surface", "bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt projection rejects ID and variant contradictions", "bindings/typescript/test/unit/self-hosted-authority.test.js#malformed trust or grant input is refused before native code or custody", "bindings/typescript/test/unit/self-hosted-authority.test.js#a declining or unbound root custody response issues no grant"] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index eae3e6dfe..41e9156db 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1008,3 +1008,39 @@ changes after authentication. Authentication substitutions, malformed frames and corrupt retained authentication refuse. This evidence is separate from the older synthetic-grant corpus; neither establishes independent-process containment, PostgreSQL parity, installed UI/bindings or completion of AP074 acceptance cases. + + +## Content application and recipient-client boundary + +Four closed application schemas route acquisition, separate disclosure, local +history and exact late ACK to the existing engine/journal. Content's resource +arguments now come from its native-verified action. The existing acquisition +compiler is split at the sealed verification result so target construction and +binding use that same result without an additional verifier or weaker map. Native +fixture parity compares this path with explicit target compilation. The initial +verification precedes target validation; final entry recompilation remains the +same full native check. + +The disclosure control path invokes native proposal/admission and emits either +redacted history/refusal or Ready. Ready transfers the owned stream to the native +engine and authenticating transport; it confers no entry permission. Current +compilation/admission run again after the protocol switch, and the existing final +writer fence still exclusively grants delivery. This bounded repetition avoids +exporting an approved or live-channel capability to a generic application handler. +The transport also honors the enclosing application's deadline. Lost control or +ACK responses never schedule another read or delivery. + +The native recipient client checks UID/channel/key before sending its private +request. CLI receipt writes new 0600 content and ACK files, syncing file and +parent, before sending the ACK. It reports only that the recipient sent evidence; +retained ACK persistence is queried separately. Native history restricts recipe, +namespace, partition and epoch and exposes only typed redacted projections. Thin +Python/TypeScript control methods pass proof/action/approval/ACK bytes without +hashing, signing, recovery or accounting. No non-native recipient protocol is added. + +Application frame/fuzz fixtures exercise real sockets with a counting refusal +oracle. The three control CLI cases capture exact envelopes against real refusal +sockets. Native socket/file delivery cases now use the production recipient client +with an explicit control-frame shim; the native installed file grant still uses +real approved authority. These are not a complete installed app dispatcher, +recipient CLI process, language runtime, authenticated UI or hostile-agent claim. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 58f58cf8f..4342227c0 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -372,3 +372,33 @@ verifier reads. Git trust pins a single root anchor today; the M-of-N composition in §1 applies to gateway trust. + + +## Native content controls under AP074 + +A content-capable installation accepts `content-acquire --app-socket ... --proof +... --action ... --approval ...`. Its result is redacted acquisition history; +it does not release provider content. `effect-review --content` reviews the +native signed read action. Release is separately authorized and reviewed with +`effect-review --disclosure --binding-out `. +The proposal is the closed native `AppDisclosureTarget`: source operation, +recipient public key, exact UID/channel policy and delivery instance. Use native +call authoring; the CLI authoring integration and full installed UI journey are +still tracked by AP074 and are not completed by these controls. + +`disclosure-receive` requires the trusted expected-binding file, exact byte count, +proposal and independent proof/action/approval. Pipe the recipient's raw 32-byte +Ed25519 seed through non-interactive stdin with `--recipient-seed-stdin`; never +put it in command arguments. Use new absolute `--content-out` and +`--acknowledgement-out` paths. The native client checks the pinned gateway UID +before sending private authority. It writes private content and native ACK files +before transmitting the ACK. Its `recipient-ack-sent` result describes the client +send, not durable gateway acknowledgement. + +Use `content-history --app-socket ... --operation ...` to inspect native retained +facts. If a received ACK was lost before persistence, `disclosure-acknowledge +--app-socket ... --operation ... --acknowledgement ` records +that exact evidence without redelivery. A disconnect, unknown outcome or retained +grant must not trigger an automatic repeat. Python/TypeScript expose matching +acquisition/history/ACK control methods returning native result bytes. Recipient +handshake, binding/ACK interpretation and signing remain in Rust. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index e7134e3f3..be0cbc349 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1331,6 +1331,53 @@ closure regeneration passed after that correction (one artifact-generation test) consumers and complete P4 evidence remain required. No broad local gate, formal execution or hosted CI observation was run. AP073 remains untouched. +## Native content application, CLI and control-binding checkpoint + +- Based on pushed `d5cfeb99`; the preceding goal turn made concrete progress and + left a clean worktree. This continuation adds the maintained application path + over that native disclosure runtime, not another executor or state owner. +- Content acquisition now projects resource arguments from the native-verified + action. The existing acquisition compiler shares its body below that sealed + result. Native fixture parity confirms the same binding as explicit-target + compilation; candidate and recovery artifacts remain unchanged. +- Four closed application envelopes expose content acquisition, disclosure, + redacted history and late ACK. Native admission returns history/refusal or Ready; + Ready only transfers the owned socket to native authentication and fresh final + entry. The transport inherits the application deadline. Control loss cannot + recreate a permit. Historical queries check recipe/namespace/partition/epoch; + acquisition/disclosure facts are typed, private content stays in its owner. +- The Rust recipient client checks gateway UID/channel/key before sending private + proof/approval. CLI `content-acquire`, `content-history`, + `disclosure-acknowledge` and `disclosure-receive` call native operations. Receipt + saves new 0600 content and ACK files before sending ACK and reports only + `recipient-ack-sent`, never durable server persistence. Review supports content + and disclosure targets and can save the exact private recipient binding. +- Python/TypeScript control methods carry acquisition/history/ACK envelopes and + return native bytes without effect hashing, projection, signing, accounting or + retry logic. Their fixture and bounds tests are authored, not executed. The + recipient protocol remains Rust-owned; full installed binding/UI integration + and native call-authoring CLI work remain open. +- Required native application frame/content compilation/content journal artifact + generation passed three tests in 5.89 seconds. The first build caught two missed + `DisclosureConnection` deadline destructures; both peers now honor the parent + deadline. No production check was weakened to repair compilation. +- `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --test application_content_cli -- --exact native_application_content_cli_fixture_is_current` + passed (one generator, 0.89 seconds). It executes the production CLI for three + control envelopes against real refusal sockets; it does not exercise installed + engine authority, recipient CLI delivery or actual provider I/O. +- The native socket/file delivery generator now exercises the production recipient + client with an explicit control-frame shim, plus real approved native file grants. + It is not an installed application-dispatcher claim. Native history is tested + against retained snapshots and wrong-recipe refusal. The frame generator covers + closed routing, duplicate/obsolete/unknown/override/oversize refusal and writes + four maintained fuzz seeds; the fuzz dispatcher is updated for those schemas. +- Final required artifact generation passed six exact tests in 34.94 seconds: + application content frame, content compilation/journal, candidate compilation, + recovery acquisition and semantic closure. Candidate/recovery artifacts stayed + byte-for-byte unchanged. No Python/TypeScript suite, broad local gate, formal + execution or hosted CI observation ran. No A01–A22 case is closed. AP073 remains + untouched; full installed process/adapters/UI and AP070 owner cutover remain. + ## Phase gates | Phase | State | Outstanding gate | @@ -1338,7 +1385,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition and authenticated Unix disclosure runtime wired | Maintained deployment/example journeys (local approved candidate CLI journey executed), application/CLI/binding disclosure integration; remove Python semantic owner | +| P3 | Acquisition/disclosure runtime and application controls wired | Native call-authoring CLI, full installed recipient/binding/UI journeys; remove AP070 Python semantic owner | | P4 | Pending | Differential/local journey, installed bindings, formal links, CI | ## Acceptance ledger @@ -1366,11 +1413,11 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | -| A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests / native valid fixture only | Binding parity and negative corpus pending | +| A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | | A20 | Generated histories and shipping predicate refinement | Partial / 576 typed stage pairs, ACK histories and Kani source / pure corpus executed | Full generated concurrent histories and source-linked formal artifacts pending | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | -| A22 | Installed single-human/single-agent full journey/UI | Partial / local approved candidate CLI / candidate subprocess journey | Full installed read/disclosure/write/observation and authenticated UI | +| A22 | Installed single-human/single-agent full journey/UI | Partial / candidate CLI and content application controls / candidate journey and content refusal-socket CLI executed | Full installed read/disclosure/write/observation, recipient CLI and authenticated UI | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 5f1fb33cb..2d45a0f3f 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -669,3 +669,22 @@ socket-pair/file artifact exercises ACK loss, late evidence, fresh-authenticatio replay, dropped permit, one-winner concurrency and dependency changes before the final fence. Independent processes/adapters, complete recipe differential and performance evidence remain required by the extraction and AP074 exit gates. + + +### Application and thin-client cutover + +Content application inputs no longer supply a resource map beside the signed +native action. The acquisition compiler's existing body is shared below sealed +verification, allowing content target reconstruction from that same verified +command. This is one compilation owner; old explicit-target callers and new +native-action callers produce identical bindings in the native corpus. Native +history and ACK recording are exposed without capability reconstruction. + +The application control switch invokes existing native admission and then hands +one owned socket to the existing authenticated delivery owner. It does not infer +readiness, authorization or receipt from a transport label. Rust client/CLI code +alone executes recipient authentication and signs ACKs after receipt. Python and +TypeScript carry bounded envelopes and native result bytes; no shared semantic +predicate, hash, signature or capacity rule moves into those wrappers. Frame, +CLI refusal and native-client/file evidence have explicit narrow scopes. Full +installed consumer, reference differential and isolation gates remain required. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 5d8ca0634..45484e1fb 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -539,8 +539,46 @@ outside the containment guarantee. The existing synthetic-grant journal corpus remains historical unit evidence. A separate real socket-pair/file fixture covers actual send/ACK loss, reopening, one-winner concurrent grants, grant-before-send loss and changes between authentication and grant. It is not independent-process, -PostgreSQL, hostile-agent or full installed A07/A08/A22 evidence. Application/CLI -routes, thin binding/UI integration and those complete journeys remain required. +PostgreSQL, hostile-agent or full installed A07/A08/A22 evidence. The application/CLI controls below do not close installed binding/UI integration +or those complete journeys. + +The application now has closed `auths.gateway-content/1`, +`auths.gateway-disclose/1`, `auths.gateway-content-history/1` and +`auths.gateway-disclosure-acknowledge/1` frames. Acquisition carries only the +native proof/action/approval envelope. Its resource arguments are projected from +the verified action through the same acquisition compiler; no second caller map, +URL or transport override is accepted. The existing eight-MiB application frame, +four-MiB proof, 64-KiB action and native approval bounds remain in force. + +Disclosure carries a closed source-operation/recipient-key/channel/instance +proposal and its independent native envelope. The application resolves protected +source provenance and invokes native admission. Terminal replay returns redacted +history; a reservation returns `ready` only to switch the owned socket to native +recipient authentication. Ready is not a grant. The engine then repeats current +compilation/admission and makes the existing final fenced decision. Changes after +Ready fail closed. Transport inherits the application session deadline as well as +its own tighter limits. No external send is cancelled into a false non-entry +claim, and the session retains capacity until the bounded native work ends. + +The native recipient client checks gateway UID, expected binding/channel and its +key before sending the private request. It accepts at most 4,096 bytes of control +response, switches only on the typed Ready response, and exposes plaintext only +through the existing authenticated receipt value. The CLI saves content and +canonical late-ACK evidence to new owner-private files before sending its ACK; +`recipient-ack-sent` does not assert that the gateway persisted it. History and +late ACK use separate control calls and never request a fresh delivery. History +is restricted to the installed recipe, namespace, partition and epoch and uses +native redacted acquisition/disclosure projections. + +`effect-review --content` and `--disclosure ` use native complete +review and approval requests. Optional `--binding-out` preserves the exact native +binding for the trusted recipient channel. Python/TypeScript content acquisition, +history and late-ACK methods carry native bytes unchanged; they implement no +content projection, commitment, signing, accounting or retry decision. Recipient +protocol execution stays in Rust. Native frame/CLI artifacts and socket-client +cases are narrower than installed authority/UI/binding/hostile-process evidence; +those full journeys, native call-authoring CLI integration and AP070 cutover remain +required. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content new file mode 100644 index 000000000..9a8365f15 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content @@ -0,0 +1 @@ +{"schema":"auths.gateway-content/1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content-history b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content-history new file mode 100644 index 000000000..7a52a4a2b --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content-history @@ -0,0 +1 @@ +{"schema":"auths.gateway-content-history/1","operation":"fixture-1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose new file mode 100644 index 000000000..a0b54327b --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose @@ -0,0 +1 @@ +{"schema":"auths.gateway-disclose/1","target":{"source_operation":"fixture-source","recipient_key":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19],"channel":{"schema":"auths.gateway-unix-disclosure-channel/1","gateway_uid":100,"recipient_uid":101,"channel_id":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19]},"delivery_instance":[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20]},"submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclosure-ack b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclosure-ack new file mode 100644 index 000000000..154033b79 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclosure-ack @@ -0,0 +1 @@ +{"schema":"auths.gateway-disclosure-acknowledge/1","operation":"fixture-1","acknowledgement_b64":"eyJyZXF1ZXN0Ijp7ImFja25vd2xlZGdlZF9ieXRlcyI6NDIsImNoYW5uZWwiOlsxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMiwxMl0sImRlbGl2ZXJ5X2luc3RhbmNlIjpbMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTMsMTNdLCJlZmZlY3QiOlsxODAsMTkwLDIzNSwzNSwyMzcsMTI1LDI1NCw5MSwyMiwyMzUsMjQxLDE4NywxMzksMTExLDExLDUsMjM0LDIyNiwxMTMsMTY0LDEwNywxMTEsMjM5LDg2LDIyNSw2OSwzNSwyMzIsMjQ2LDIxMywyNDcsMTY5XSwibWF4aW11bV9ieXRlcyI6MTAwLCJwcm9qZWN0aW9uIjpbMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTQsMTRdLCJwcm90ZWN0ZWRfY29udGVudCI6WzExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExLDExXSwicmVjaXBpZW50Ijoia2V5OnNoYTI1NjprZUNTNXVtdjRnZkpUejJpMDFvcGZIaDZXTWo5RjZrYzF0c3lleXFvaTdnIiwicmVjaXBpZW50X2tleSI6WzY3LDQsMTA3LDI1NCw2NCwxNDYsMTc5LDIzMyw3MywxNDgsMjM0LDIxOCwyMSwyMjAsMTk0LDEzLDEzOCwxNzAsNywxODIsODgsMjUzLDU3LDg0LDIzNSwxNDIsMTQsMjUxLDEzOSwyMjAsMTY1LDIyMl0sInNjaGVtYSI6ImF1dGhzLmdhdGV3YXktZGlzY2xvc3VyZS1hY2svMSIsInNvdXJjZV9lZmZlY3QiOlsxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMCwxMF19LCJzaWduYXR1cmVfYjY0IjoiMlZOR1Z6NmVjd3NDeUM0bGdiZkFxcl94b1FkUDhFM0UySEFmYmJJV29tNWNLTlpPSVdLSzFmeTBXaDZsRWozRWduaTN6NFVRT3N3SVE2bmZ5U1RmQmcifQ"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs index 983848a2b..9cef4ba13 100644 --- a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs +++ b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_app_frame.rs @@ -4,7 +4,10 @@ #![no_main] use auths_gateway::admin::{ADMIN_REQUEST_SCHEMA, parse_admin_request}; -use auths_gateway::app::{APP_OBSERVE_SCHEMA, APP_RECOVERY_SCHEMA, APP_REQUEST_SCHEMA}; +use auths_gateway::app::{ + APP_CONTENT_HISTORY_SCHEMA, APP_CONTENT_SCHEMA, APP_DISCLOSURE_ACK_SCHEMA, + APP_DISCLOSURE_SCHEMA, APP_OBSERVE_SCHEMA, APP_RECOVERY_SCHEMA, APP_REQUEST_SCHEMA, +}; use auths_gateway::fuzzing; use libfuzzer_sys::fuzz_target; use serde_json::Value; @@ -25,6 +28,10 @@ fuzz_target!(|data: &[u8]| { "submit" => APP_REQUEST_SCHEMA, "observe" => APP_OBSERVE_SCHEMA, "recover" => APP_RECOVERY_SCHEMA, + "content" => APP_CONTENT_SCHEMA, + "disclose" => APP_DISCLOSURE_SCHEMA, + "content-history" => APP_CONTENT_HISTORY_SCHEMA, + "disclosure-ack" => APP_DISCLOSURE_ACK_SCHEMA, _ => panic!("unknown closed application frame"), }; assert_eq!(schema().as_deref(), Some(expected)); diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 753801fbe..4a906f093 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"c360f98f5632f0178c7f7ace5fa0f7f4688af15447bd1e7e1c9d18838adfa62b"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"fb9dfffd9886d5711fded313de3b8366b2392bcae917a1ec4675ab6ef251d239"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"80952d39cd0fe683123d83b2966a8e88a342c5b20cfa9b4263a3c687284d2e5c"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"3368c2b0ba759c0c33fbc93fc39ce78a607b07dc10546b6f1b88abe2783e0e89"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"ce872269471201db44507e5f120ec341840b6a4dd20c29b6bae1abe352650cdf"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"349ca7c7e95ec93873e6898e970fe59163198bee0623551218ebe65fce6487a9"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"47fb230b3bd9f796ab4cd7adcbfc3d3d8a523b8abb663890519dce13c63f824e"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"82935fc381916a0ce5eb6f91de29a7e19d91a7f59b4d4f9d5c38d98b9e323b23"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4194cfacc40eb50d780573c76527ba5d5acbbe5de2e6c58a560d03edd54eeb46"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"83cff59f8f9f82597420e7330cc7faf228553c7933b3cbf558c7ada394d81347"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"09df48006cefeb315ffe7f2ec32c297028499fa9c594524e2a86bc25ef6eb505"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"6f9e9064db06586019d4ebadb9ab59b8764299bbcc12bfe5e6949f469a2c9aad"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"2680b305a1e7402ac492a3b58a31f46d024606a28b9790c014fc0324228593e0"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"441e57efe4fc40786cdf1b1642ca0f6fc3c5a9f426b031451fa4e242392c7f7f"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"30330e58a09a00d5fb8e5747eee3916c1d638694a907b02872ff4fb277b7b776"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"6489f56bc090b6bc3487da3862b49d8f5f31a7d0e791c1801698d061b3f6bc53"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 88677d8c7..835d72302 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -1,7 +1,6 @@ -//! The application-socket protocol: one length-prefixed JSON frame in, one -//! out. Frames carry a proof/action submission, independently approved recovery, -//! or retained local history; anything else is refused without -//! reaching the application. +//! Closed application protocol: one control frame and native result, except +//! disclosure, which explicitly switches to bounded recipient authentication, +//! content and ACK frames. Native owners decide every effect and history change. use crate::effect::{ExactEffectApproval, MAX_EFFECT_APPROVAL_BYTES}; use crate::{GatewayEngine, GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult}; @@ -15,6 +14,17 @@ use tokio::net::UnixStream; use tokio::time::{Instant, sleep_until, timeout_at}; use zeroize::{Zeroize as _, Zeroizing}; +mod content; +#[cfg(test)] +#[path = "app/content_tests.rs"] +mod content_tests; +pub use content::{ + APP_CONTENT_HISTORY_SCHEMA, APP_CONTENT_SCHEMA, APP_DISCLOSURE_ACK_SCHEMA, + APP_DISCLOSURE_SCHEMA, AppContent, AppContentHistory, AppContentResult, AppDisclosure, + AppDisclosureAcknowledgement, AppDisclosureTarget, +}; +pub use content::{AppDisclosureReception, receive_content_disclosure}; + /// Schema of a proof/action submission frame. pub const APP_REQUEST_SCHEMA: &str = "auths.gateway-submit/2"; /// Schema of an observation request frame. @@ -253,6 +263,10 @@ enum AppFrame { Submit(AppSubmission), Observe(AppObservation), Recover(AppRecovery), + Content(AppContent), + Disclose(AppDisclosure), + ContentHistory(AppContentHistory), + DisclosureAck(AppDisclosureAcknowledgement), } /// Which closed frame `bytes` parse as, schema included: `submit`, @@ -267,6 +281,10 @@ pub(crate) fn frame_kind(bytes: &[u8]) -> Option<&'static str> { (observation.schema == APP_OBSERVE_SCHEMA).then_some("observe") } AppFrame::Recover(recovery) => recovery.decode().ok().map(|_| "recover"), + AppFrame::Content(request) => request.decode().ok().map(|_| "content"), + AppFrame::Disclose(request) => request.decode().ok().map(|_| "disclose"), + AppFrame::ContentHistory(request) => request.validate().ok().map(|()| "content-history"), + AppFrame::DisclosureAck(request) => request.decode().ok().map(|_| "disclosure-ack"), } } @@ -290,6 +308,43 @@ pub trait GatewayApplication { approval: ExactEffectApproval, ) -> impl Future; + /// Native content acquisition. Synthetic applications refuse by default. + fn acquire_content( + &self, + _submission: DecodedSubmission, + ) -> impl Future { + async { AppContentResult::refused("gateway.acquisition.binding") } + } + /// Native redacted history, with no current I/O authority. + fn content_history(&self, _operation: &str) -> impl Future { + async { AppContentResult::refused("gateway.attempt.state-unavailable") } + } + /// Exact historical evidence. Default implementations cannot invent grants. + fn acknowledge_disclosure( + &self, + _operation: &str, + _ack: crate::effect::DisclosureAcknowledgement, + ) -> impl Future { + async { AppContentResult::refused("gateway.disclosure.acknowledgement") } + } + /// Transfers the socket to the native disclosure protocol. This must finish + /// its bounded journal work rather than cancel after a possible grant. + fn disclose_content( + &self, + _target: AppDisclosureTarget, + _submission: DecodedSubmission, + mut stream: UnixStream, + clock: SessionClock, + ) -> impl Future { + async move { + if let Ok(bytes) = + serde_json::to_vec(&AppContentResult::refused("gateway.disclosure.binding")) + { + let _ = clock.write_frame(&mut stream, &bytes).await; + } + } + } + /// Signs or returns retained local history, without provider I/O. fn observe( &self, @@ -322,6 +377,45 @@ impl GatewayApplication for GatewayEngine { } } + async fn acquire_content(&self, submission: DecodedSubmission) -> AppContentResult { + match self + .acquire_content_action(&submission.proof, &submission.action, submission.approval) + .await + { + Ok(snapshot) => AppContentResult::History { + history: crate::ContentHistory::Acquisition(snapshot), + }, + Err(result) => AppContentResult::Refused { result }, + } + } + async fn content_history(&self, operation: &str) -> AppContentResult { + match GatewayEngine::content_history(self, operation).await { + Ok(history) => AppContentResult::History { history }, + Err(result) => AppContentResult::Refused { result }, + } + } + async fn acknowledge_disclosure( + &self, + operation: &str, + ack: crate::effect::DisclosureAcknowledgement, + ) -> AppContentResult { + match GatewayEngine::acknowledge_disclosure(self, operation, &ack).await { + Ok(snapshot) => AppContentResult::History { + history: crate::ContentHistory::Disclosure(snapshot), + }, + Err(result) => AppContentResult::Refused { result }, + } + } + async fn disclose_content( + &self, + target: AppDisclosureTarget, + submission: DecodedSubmission, + stream: UnixStream, + clock: SessionClock, + ) { + content::engine_disclose(self, target, submission, stream, clock).await; + } + async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { GatewayEngine::observe(self, request).await } @@ -332,19 +426,26 @@ impl GatewayApplication for GatewayEngine { /// # Errors /// Returns a stable code for an unreadable or out-of-bounds frame. pub async fn read_frame(stream: &mut UnixStream) -> Result, &'static str> { + read_frame_limited(stream, MAX_FRAME_BYTES).await +} + +async fn read_frame_limited( + stream: &mut UnixStream, + maximum: usize, +) -> Result, &'static str> { let length = stream .read_u32() .await .map_err(|_| "gateway.ipc.read-failed")? as usize; - if length == 0 || length > MAX_FRAME_BYTES { + if length == 0 || length > maximum { return Err("gateway.ipc.invalid-size"); } - let mut bytes = vec![0_u8; length]; + let mut bytes = Zeroizing::new(vec![0_u8; length]); stream .read_exact(&mut bytes) .await .map_err(|_| "gateway.ipc.read-failed")?; - Ok(bytes) + Ok(bytes.to_vec()) } /// Writes one bounded frame. @@ -437,15 +538,27 @@ pub async fn app_session_within( ) { let clock = SessionClock::start(limits); let request = clock.read_frame(&mut stream).await; + let request = request.and_then(|bytes| { + let bytes = Zeroizing::new(bytes); + serde_json::from_slice::(&bytes).map_err(|_| "gateway.submit.invalid-frame") + }); + if let Ok(AppFrame::Disclose(request)) = request { + content::disclose(request, stream, application, clock).await; + return; + } let response = async { match request { - Ok(bytes) => match serde_json::from_slice::(&bytes) { - Ok(AppFrame::Submit(submission)) => submit_frame(submission, application).await, - Ok(AppFrame::Observe(observation)) => observe_frame(observation, application).await, - Ok(AppFrame::Recover(recovery)) => recovery_frame(recovery, application).await, - Err(_) => serde_json::to_vec(&invalid_frame()).unwrap_or_default(), - }, - Err(_) => serde_json::to_vec(&invalid_frame()).unwrap_or_default(), + Ok(AppFrame::Submit(submission)) => submit_frame(submission, application).await, + Ok(AppFrame::Observe(observation)) => observe_frame(observation, application).await, + Ok(AppFrame::Recover(recovery)) => recovery_frame(recovery, application).await, + Ok(AppFrame::Content(request)) => content::acquire(request, application).await, + Ok(AppFrame::ContentHistory(request)) => content::history(request, application).await, + Ok(AppFrame::DisclosureAck(request)) => { + content::acknowledge(request, application).await + } + Ok(AppFrame::Disclose(_)) | Err(_) => { + serde_json::to_vec(&invalid_frame()).unwrap_or_default() + } } }; if let Some((mut stream, bytes)) = clock.complete(stream, response).await diff --git a/product/runtime/auths-gateway/src/app/content.rs b/product/runtime/auths-gateway/src/app/content.rs new file mode 100644 index 000000000..e4c6c5770 --- /dev/null +++ b/product/runtime/auths-gateway/src/app/content.rs @@ -0,0 +1,375 @@ +//! Closed content application envelopes. These carry native authority or history; +//! they never interpret resources, count capacity, hash effects or decide retries. +use super::*; +use crate::effect::{DisclosureAcknowledgement, UnixDisclosurePolicy}; + +/// Independently approved content acquisition from the signed action itself. +pub const APP_CONTENT_SCHEMA: &str = "auths.gateway-content/1"; +/// Separate recipient disclosure with an owned local channel. +pub const APP_DISCLOSURE_SCHEMA: &str = "auths.gateway-disclose/1"; +/// Redacted local content/disclosure history without external I/O. +pub const APP_CONTENT_HISTORY_SCHEMA: &str = "auths.gateway-content-history/1"; +/// Historical recipient evidence; never a new delivery request. +pub const APP_DISCLOSURE_ACK_SCHEMA: &str = "auths.gateway-disclosure-acknowledge/1"; + +/// No second resource map accompanies the signed native action. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppContent { + /// Must equal `APP_CONTENT_SCHEMA`. + pub schema: String, + /// Independently verified read authority and exact approval. + pub submission: AppSubmission, +} +impl AppContent { + /// Decodes bounded transport data; no authority is inferred here. + /// + /// # Errors + /// Refuses obsolete schemas and malformed native envelopes. + pub fn decode(&self) -> Result { + if self.schema != APP_CONTENT_SCHEMA { + return Err("gateway.submit.invalid-frame"); + } + self.submission.decode() + } +} + +/// Proposed recipient address. The native target/compiler binds it to the +/// retained source and exact proof/approval before entry. +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppDisclosureTarget { + /// Retained acquisition in the installed recipe/partition. + pub source_operation: String, + /// Raw Ed25519 public key, never a credential or signing seed. + pub recipient_key: [u8; 32], + /// Exact UID/channel policy committed by the approved effect. + pub channel: UnixDisclosurePolicy, + /// Explicit delivery instance committed by the approved effect. + pub delivery_instance: [u8; 32], +} +impl AppDisclosureTarget { + pub(super) fn validate(&self) -> Result<(), &'static str> { + crate::LogicalOperationId::parse(&self.source_operation) + .map_err(|_| "gateway.submit.invalid-frame")?; + self.channel.commitment()?; + Ok(()) + } + /// Loads native retained provenance for this proposal. This establishes no + /// release authority, approval or live recipient authentication. + /// + /// # Errors + /// Refuses invalid/foreign/unavailable content and invalid channel or key. + pub async fn resolve( + &self, + engine: &GatewayEngine, + ) -> Result { + engine + .disclosure_target( + &self.source_operation, + self.recipient_key, + self.channel + .commitment() + .map_err(|code| GatewaySubmitResult::NotEntered { + code: code.to_owned(), + })?, + self.delivery_instance, + ) + .await + } +} + +/// After admission this request switches the owned socket to native disclosure +/// authentication/content/ACK frames. `Ready` is not a delivery grant. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppDisclosure { + /// Must equal `APP_DISCLOSURE_SCHEMA`. + pub schema: String, + /// Proposed exact recipient/source identity, checked against native authority. + pub target: AppDisclosureTarget, + /// Independent disclosure proof and exact approval. + pub submission: AppSubmission, +} +impl AppDisclosure { + /// Decodes closed bounded transport data without authenticating a peer. + /// + /// # Errors + /// Refuses malformed address, schema or native envelope. + pub fn decode(&self) -> Result { + if self.schema != APP_DISCLOSURE_SCHEMA { + return Err("gateway.submit.invalid-frame"); + } + self.target.validate()?; + self.submission.decode() + } +} + +/// Local redacted history. This carries no provider or disclosure permission. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppContentHistory { + /// Must equal `APP_CONTENT_HISTORY_SCHEMA`. + pub schema: String, + /// Logical operation in the installed recipe/partition. + pub operation: String, +} +impl AppContentHistory { + pub(super) fn validate(&self) -> Result<(), &'static str> { + if self.schema != APP_CONTENT_HISTORY_SCHEMA + || crate::LogicalOperationId::parse(&self.operation).is_err() + { + return Err("gateway.submit.invalid-frame"); + } + Ok(()) + } +} + +/// Exact late recipient evidence. A valid signature alone cannot invent a grant. +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct AppDisclosureAcknowledgement { + /// Must equal `APP_DISCLOSURE_ACK_SCHEMA`. + pub schema: String, + /// Original disclosure operation in this installation. + pub operation: String, + /// Canonical native ACK, unpadded base64url, at most 4,096 decoded bytes. + pub acknowledgement_b64: String, +} +impl AppDisclosureAcknowledgement { + /// Decodes bounded evidence; retained native binding/grant checks remain required. + /// + /// # Errors + /// Refuses malformed schema, operation, encoding or native ACK. + pub fn decode(&self) -> Result { + if self.schema != APP_DISCLOSURE_ACK_SCHEMA + || crate::LogicalOperationId::parse(&self.operation).is_err() + || self.acknowledgement_b64.len() > (4096 * 4_usize).div_ceil(3) + { + return Err("gateway.submit.invalid-frame"); + } + let bytes = Zeroizing::new( + Base64UrlUnpadded::decode_vec(&self.acknowledgement_b64) + .map_err(|_| "gateway.disclosure.acknowledgement")?, + ); + DisclosureAcknowledgement::from_private_bytes(&bytes) + .map_err(|_| "gateway.disclosure.acknowledgement") + } +} +impl Drop for AppDisclosureAcknowledgement { + fn drop(&mut self) { + self.acknowledgement_b64.zeroize(); + } +} + +/// Native redacted result, or permission to begin authentication only. +#[derive(Deserialize, Serialize)] +#[serde(tag = "outcome", rename_all = "kebab-case", deny_unknown_fields)] +pub enum AppContentResult { + /// The stream is switching to native authentication; no grant or bytes yet. + Ready, + /// Retained native facts, with acquisition and disclosure kept distinct. + History { + /// Redacted history. Decoding never creates a runtime capability. + history: crate::ContentHistory, + }, + /// Native refusal or unavailable state, never permission to retry a grant. + Refused { + /// Original native stage and stable code. + result: GatewaySubmitResult, + }, +} +impl AppContentResult { + pub(super) fn refused(code: &'static str) -> Self { + Self::Refused { + result: GatewaySubmitResult::NotEntered { + code: code.to_owned(), + }, + } + } +} + +pub(super) async fn acquire(request: AppContent, application: &impl GatewayApplication) -> Vec { + let result = match request.decode() { + Ok(decoded) => application.acquire_content(decoded).await, + Err(code) => AppContentResult::refused(code), + }; + serde_json::to_vec(&result).unwrap_or_default() +} +pub(super) async fn history( + request: AppContentHistory, + application: &impl GatewayApplication, +) -> Vec { + let result = match request.validate() { + Ok(()) => application.content_history(&request.operation).await, + Err(code) => AppContentResult::refused(code), + }; + serde_json::to_vec(&result).unwrap_or_default() +} +pub(super) async fn acknowledge( + request: AppDisclosureAcknowledgement, + application: &impl GatewayApplication, +) -> Vec { + let result = match request.decode() { + Ok(ack) => { + application + .acknowledge_disclosure(&request.operation, ack) + .await + } + Err(code) => AppContentResult::refused(code), + }; + serde_json::to_vec(&result).unwrap_or_default() +} + +pub(super) async fn disclose( + request: AppDisclosure, + stream: UnixStream, + application: &impl GatewayApplication, + clock: SessionClock, +) { + match request.decode() { + Ok(decoded) => { + application + .disclose_content(request.target, decoded, stream, clock) + .await + } + Err(code) => { + let mut stream = stream; + if let Ok(bytes) = serde_json::to_vec(&AppContentResult::refused(code)) { + let _ = clock.write_frame(&mut stream, &bytes).await; + } + } + } +} + +pub(super) async fn engine_disclose( + engine: &GatewayEngine, + target: AppDisclosureTarget, + decoded: DecodedSubmission, + stream: UnixStream, + clock: SessionClock, +) { + // Admission is an existing native operation, not an application decision. + // It returns only a reservation/history; the later engine call repeats all + // current checks and owns the unique authenticated grant. + let prepare = async { + let native = target.resolve(engine).await?; + let snapshot = engine + .admit_disclosure( + &native, + &decoded.proof, + &decoded.action, + decoded.approval.clone(), + ) + .await?; + Ok::<_, GatewaySubmitResult>((native, snapshot)) + }; + let Some((mut stream, prepared)) = clock.complete(stream, prepare).await else { + return; + }; + let (native, response) = match prepared { + Ok((native, snapshot)) if snapshot.stage == crate::DisclosureStage::Reserved => { + (Some(native), AppContentResult::Ready) + } + Ok((_, snapshot)) => ( + None, + AppContentResult::History { + history: crate::ContentHistory::Disclosure(snapshot), + }, + ), + Err(result) => (None, AppContentResult::Refused { result }), + }; + let Ok(bytes) = serde_json::to_vec(&response) else { + return; + }; + if clock.write_frame(&mut stream, &bytes).await.is_err() { + return; + } + let Some(native) = native else { + return; + }; + let connection = crate::disclosure_transport::DisclosureConnection::new(stream, target.channel) + .within(clock.deadline); + // Once handed over, the transport owns framing and the finite deadline. + // ACK submission is not a persistence acknowledgement; callers use a fresh + // history query after completion/loss, never an implicit redelivery request. + let _ = engine + .disclose( + &native, + &decoded.proof, + &decoded.action, + decoded.approval, + connection, + ) + .await; +} + +/// Result of the native application client. A retained history/refusal contains +/// no received bytes and never authorizes automatic redelivery. +pub enum AppDisclosureReception { + /// Exact plaintext received through the authenticated native transport. + Received(crate::disclosure_transport::ReceivedDisclosure), + /// The operation already has retained history; no handshake/send occurred. + History(crate::DisclosureSnapshot), + /// Native pre-handshake refusal. + Refused(GatewaySubmitResult), +} + +/// Sends a disclosure request only after checking the pinned gateway UID, then +/// handles the closed protocol switch. `expected` comes from the trusted private +/// approval channel, never from the server's Ready response. ACK is explicit on +/// the returned received value. After channel loss, query history or record a +/// retained exact ACK; do not automatically repeat delivery. +/// +/// # Errors +/// Refuses mismatched channel/key, invalid envelope/control frames, deadlines and +/// the native recipient protocol's errors. Returns no partial plaintext. +pub async fn receive_content_disclosure( + mut stream: UnixStream, + request: &AppDisclosure, + expected: &crate::effect::EffectBinding, + bytes: u64, + key: &ed25519_dalek::SigningKey, +) -> Result { + request.target.channel.matches(expected)?; + request.target.channel.recipient_peer(&stream)?; + if request.target.recipient_key != key.verifying_key().to_bytes() { + return Err("gateway.disclosure.authentication"); + } + request.decode()?; + let clock = SessionClock::start(APP_SESSION_LIMITS); + let encoded = + Zeroizing::new(serde_json::to_vec(request).map_err(|_| "gateway.submit.invalid-frame")?); + clock.write_frame(&mut stream, &encoded).await?; + let response = Zeroizing::new( + timeout_at( + clock + .deadline + .min(Instant::now() + clock.limits.result_wait), + super::read_frame_limited(&mut stream, 4096), + ) + .await + .map_err(|_| "gateway.ipc.read-timeout")??, + ); + let response: AppContentResult = + serde_json::from_slice(&response).map_err(|_| "gateway.submit.invalid-response")?; + match response { + AppContentResult::Ready => crate::disclosure_transport::receive_disclosure( + crate::disclosure_transport::DisclosureConnection::new( + stream, + request.target.channel.clone(), + ) + .within(clock.deadline), + expected, + bytes, + key, + ) + .await + .map(AppDisclosureReception::Received), + AppContentResult::History { + history: crate::ContentHistory::Disclosure(snapshot), + } => Ok(AppDisclosureReception::History(snapshot)), + AppContentResult::History { .. } => Err("gateway.submit.invalid-response"), + AppContentResult::Refused { result } => Ok(AppDisclosureReception::Refused(result)), + } +} diff --git a/product/runtime/auths-gateway/src/app/content_tests.rs b/product/runtime/auths-gateway/src/app/content_tests.rs new file mode 100644 index 000000000..adbe04cc8 --- /dev/null +++ b/product/runtime/auths-gateway/src/app/content_tests.rs @@ -0,0 +1,200 @@ +//! Application framing only: a counting refusal oracle is not installed authority. +use super::*; +use std::sync::atomic::{AtomicUsize, Ordering}; + +struct Counted(AtomicUsize); +impl GatewayApplication for Counted { + async fn submit(&self, _: &[u8], _: &[u8], _: ExactEffectApproval) -> GatewaySubmitResult { + panic!("wrong route") + } + async fn recover( + &self, + _: &str, + _: &[u8], + _: &[u8], + _: ExactEffectApproval, + ) -> AppRecoveryResult { + panic!("wrong route") + } + async fn observe(&self, _: &GatewayObserveRequest) -> GatewayObserveResult { + panic!("wrong route") + } + async fn acquire_content(&self, input: DecodedSubmission) -> AppContentResult { + assert_eq!(&*input.proof, &[0]); + assert_eq!(&*input.action, &[0]); + self.0.fetch_add(1, Ordering::SeqCst); + AppContentResult::refused("gateway.acquisition.binding") + } + async fn content_history(&self, operation: &str) -> AppContentResult { + assert_eq!(operation, "fixture-1"); + self.0.fetch_add(1, Ordering::SeqCst); + AppContentResult::refused("gateway.attempt.state-unavailable") + } + async fn acknowledge_disclosure( + &self, + operation: &str, + _: crate::effect::DisclosureAcknowledgement, + ) -> AppContentResult { + assert_eq!(operation, "fixture-1"); + self.0.fetch_add(1, Ordering::SeqCst); + AppContentResult::refused("gateway.disclosure.acknowledgement") + } + async fn disclose_content( + &self, + _: AppDisclosureTarget, + _: DecodedSubmission, + mut stream: UnixStream, + clock: SessionClock, + ) { + self.0.fetch_add(1, Ordering::SeqCst); + clock + .write_frame( + &mut stream, + &serde_json::to_vec(&AppContentResult::refused("gateway.disclosure.binding")) + .expect("response"), + ) + .await + .expect("write"); + } +} + +#[tokio::test] +#[allow( + clippy::too_many_lines, + reason = "one closed-frame and native fact-decoding artifact" +)] +async fn native_application_content_frame_fixture_is_current() { + use serde_json::{Value, json}; + let root = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let effect: Value = serde_json::from_slice( + &std::fs::read(root.join("effect-binding.json")).expect("native fixture"), + ) + .expect("JSON"); + let submission = json!({"schema": APP_REQUEST_SCHEMA, "proof_b64": "AA", "action_b64": "AA", + "approval_b64": Base64UrlUnpadded::encode_string(effect["approval_canonical"].as_str().expect("approval").as_bytes())}); + let ack: Value = serde_json::from_slice( + &std::fs::read(root.join("disclosure-acknowledgement.json")).expect("ACK fixture"), + ) + .expect("JSON"); + let acknowledgement = + serde_json_canonicalizer::to_vec(&ack["acknowledgement"]).expect("native canonical ACK"); + let channel = crate::effect::UnixDisclosurePolicy::new(100, 101, [19; 32]); + let frames = [ + ( + "content", + json!({"schema": APP_CONTENT_SCHEMA, "submission": submission}), + ), + ( + "disclose", + json!({"schema": APP_DISCLOSURE_SCHEMA, "target": {"source_operation": "fixture-source", "recipient_key": vec![19;32], "channel": channel, "delivery_instance": vec![20;32]}, "submission": submission}), + ), + ( + "content-history", + json!({"schema": APP_CONTENT_HISTORY_SCHEMA, "operation": "fixture-1"}), + ), + ( + "disclosure-ack", + json!({"schema": APP_DISCLOSURE_ACK_SCHEMA, "operation": "fixture-1", "acknowledgement_b64": Base64UrlUnpadded::encode_string(&acknowledgement)}), + ), + ]; + let requests = frames + .iter() + .map(|(name, value)| (*name, value.clone())) + .collect::>(); + let app = Counted(AtomicUsize::new(0)); + let mut cases = Vec::new(); + for (name, valid) in frames { + let mut mutations = vec![("valid", serde_json::to_vec(&valid).expect("frame"), true)]; + let mut obsolete = valid.clone(); + obsolete["schema"] = json!("auths.gateway-content/0"); + mutations.push(( + "obsolete", + serde_json::to_vec(&obsolete).expect("frame"), + false, + )); + let mut unknown = valid.clone(); + unknown["url"] = json!("https://attacker.invalid/private"); + mutations.push(( + "transport-override", + serde_json::to_vec(&unknown).expect("frame"), + false, + )); + let mut duplicate = serde_json::to_vec(&valid).expect("frame"); + duplicate.pop(); + duplicate.extend_from_slice(format!(",\"schema\":{}}}", valid["schema"]).as_bytes()); + mutations.push(("duplicate-schema", duplicate, false)); + if valid.get("submission").is_some() { + let mut changed = valid.clone(); + changed["submission"]["approval_b64"] = json!("AA"); + mutations.push(( + "bad-approval", + serde_json::to_vec(&changed).expect("frame"), + false, + )); + let mut changed = valid.clone(); + changed["submission"]["action_b64"] = + json!("A".repeat((64 * 1024 * 4_usize).div_ceil(3) + 1)); + mutations.push(( + "oversized-action", + serde_json::to_vec(&changed).expect("frame"), + false, + )); + } + if name == "disclosure-ack" { + let mut changed = valid.clone(); + changed["acknowledgement_b64"] = json!("A".repeat((4096 * 4_usize).div_ceil(3) + 1)); + mutations.push(( + "oversized-ack", + serde_json::to_vec(&changed).expect("frame"), + false, + )); + } + if name == "disclose" { + let mut changed = valid.clone(); + changed["target"]["channel"]["schema"] = json!("unknown"); + mutations.push(( + "unknown-channel", + serde_json::to_vec(&changed).expect("frame"), + false, + )); + } + let seed = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("fuzz/corpus/target_gateway_app_frame") + .join(name); + let bytes = serde_json::to_vec(&valid).expect("seed"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&seed, &bytes).expect("seed"); + } + assert_eq!(std::fs::read(seed).expect("seed"), bytes); + for (mutation, bytes, dispatch) in mutations { + let before = app.0.load(Ordering::SeqCst); + let (server, mut client) = UnixStream::pair().expect("pair"); + let client_work = async { + write_frame(&mut client, &bytes).await.expect("write"); + let response = read_frame(&mut client).await.expect("response"); + let value: Value = serde_json::from_slice(&response).expect("JSON result"); + assert!( + !String::from_utf8(response) + .expect("UTF8") + .contains("attacker.invalid") + ); + value + }; + let ((), response) = tokio::join!(app_session(server, &app), client_work); + assert_eq!( + app.0.load(Ordering::SeqCst) - before, + usize::from(dispatch), + "{name}/{mutation}" + ); + cases.push(json!({"route": name, "case": mutation, "dispatched": dispatch, "response": response})); + } + } + let fixture = json!({"schema": "auths.gateway-application-content-fixture/1", "scope": "real socket framing with counting refusal oracle; no installed authority, provider I/O or content delivery", "requests": requests, "cases": cases}); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); + let path = root.join("application-content-frame.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index b59b4fc74..e2dade671 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -189,11 +189,20 @@ mod unix { #[arg(long)] state_dir: PathBuf, /// Compile independent read authority for this retained source. - #[arg(long, conflicts_with = "candidate")] + #[arg(long, conflicts_with_all = ["candidate", "content", "disclosure"])] recovery_of: Option, /// Private staged candidate proposal for credential-check review. - #[arg(long, conflicts_with = "recovery_of")] + #[arg(long, conflicts_with_all = ["recovery_of", "content", "disclosure"])] candidate: Option, + /// Review independently authorized content from its signed action. + #[arg(long, conflicts_with_all = ["recovery_of", "candidate", "disclosure"])] + content: bool, + /// Private native recipient/source proposal to review. + #[arg(long, conflicts_with_all = ["recovery_of", "candidate", "content"])] + disclosure: Option, + /// Preserve the exact native binding for the trusted recipient channel. + #[arg(long)] + binding_out: Option, #[arg(long)] proof: PathBuf, #[arg(long)] @@ -745,6 +754,59 @@ mod unix { #[arg(long)] approval: PathBuf, }, + /// Acquire approved content; returns facts only, never plaintext. + ContentAcquire { + #[arg(long)] + app_socket: PathBuf, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + }, + /// Inspect retained content/disclosure facts without external I/O. + ContentHistory { + #[arg(long)] + app_socket: PathBuf, + #[arg(long)] + operation: String, + }, + /// Record an exact previously received ACK without redelivery. + DisclosureAcknowledge { + #[arg(long)] + app_socket: PathBuf, + #[arg(long)] + operation: String, + #[arg(long)] + acknowledgement: PathBuf, + }, + /// Receive on the native authenticated channel, save private content and + /// late-ACK evidence, then send the ACK. Does not claim durable ACK storage. + DisclosureReceive { + #[arg(long)] + app_socket: PathBuf, + #[arg(long)] + target: PathBuf, + #[arg(long)] + proof: PathBuf, + #[arg(long)] + action: PathBuf, + #[arg(long)] + approval: PathBuf, + /// Exact private binding from the trusted native review channel. + #[arg(long)] + expected_binding: PathBuf, + #[arg(long)] + expected_bytes: u64, + /// Raw 32-byte Ed25519 seed through non-interactive stdin only. + #[arg(long, required = true)] + recipient_seed_stdin: bool, + #[arg(long)] + content_out: PathBuf, + #[arg(long)] + acknowledgement_out: PathBuf, + }, /// Check offline whether a provider record holds one action's echo /// token. Reads no network and no gateway state; exits 0 only on a /// match, which shows consistency with the action, not authorship. @@ -3191,6 +3253,9 @@ mod unix { state_dir: PathBuf, recovery_of: Option, candidate: Option, + content: bool, + disclosure: Option, + binding_out: Option, proof: PathBuf, action: PathBuf, not_before: u64, @@ -3201,6 +3266,16 @@ mod unix { if !request_out.is_absolute() { return Err("gateway.state.invalid-path".into()); } + if binding_out + .as_ref() + .is_some_and(|path| !path.is_absolute() || path.exists()) + { + return Err("gateway.state.file-exists-or-unavailable".into()); + } + let disclosure = disclosure + .as_ref() + .map(|path| read_disclosure_target(path)) + .transpose()?; let candidate = candidate .as_ref() .map(|path| read_candidate(&state_dir, path)) @@ -3210,19 +3285,29 @@ mod unix { .map_err(|_| "gateway.effect.unavailable")??; let proof = read_bounded(&proof, 4 * 1024 * 1024)?; let action = read_bounded(&action, 64 * 1024)?; - let effect = match (recovery_of, candidate) { - (Some(source), None) => { + let effect = match (recovery_of, candidate, content, disclosure) { + (Some(source), None, false, None) => { engine .compile_recovery_effect(&source, &proof, &action) .await } - (None, Some(target)) => { + (None, Some(target), false, None) => { engine .compile_candidate_effect(&target, &proof, &action) .await } - (None, None) => engine.compile_effect(&proof, &action).await, - (Some(_), Some(_)) => return Err("gateway.effect.review-refused".into()), + (None, None, false, None) => engine.compile_effect(&proof, &action).await, + (None, None, true, None) => engine.compile_content_action(&proof, &action).await, + (None, None, false, Some(proposal)) => { + let target = proposal + .resolve(&engine) + .await + .map_err(|_| "gateway.effect.review-refused")?; + engine + .compile_disclosure_effect(&target, &proof, &action) + .await + } + _ => return Err("gateway.effect.review-refused".into()), } .map_err(|_| "gateway.effect.review-refused")?; let request = effect @@ -3254,6 +3339,15 @@ mod unix { .write_all(&output) .and_then(|()| std::io::stdout().flush()) .map_err(|_| "gateway.output")?; + if let Some(path) = binding_out { + private_file( + &path, + &effect + .binding() + .to_private_bytes() + .map_err(|_| "gateway.effect.review-refused")?, + )?; + } private_file( &request_out, &request @@ -3293,6 +3387,158 @@ mod unix { Ok(()) } + fn content_submission( + proof: &Path, + action: &Path, + approval: &Path, + ) -> Result { + let submission = AppSubmission { + schema: APP_REQUEST_SCHEMA.to_owned(), + proof_b64: Base64UrlUnpadded::encode_string(&Zeroizing::new(read_bounded( + proof, + 4 * 1024 * 1024, + )?)), + action_b64: Base64UrlUnpadded::encode_string(&Zeroizing::new(read_bounded( + action, + 64 * 1024, + )?)), + approval_b64: Base64UrlUnpadded::encode_string( + &read_effect_approval(approval)? + .to_private_bytes() + .map_err(|_| "gateway.effect.approval")?, + ), + }; + submission.decode()?; + Ok(submission) + } + + fn read_disclosure_target( + path: &Path, + ) -> Result { + let metadata = fs::symlink_metadata(path).map_err(|_| "gateway.state.invalid-path")?; + if !metadata.file_type().is_file() || metadata.permissions().mode() & 0o077 != 0 { + return Err("gateway.state.invalid-path".into()); + } + serde_json::from_slice(&Zeroizing::new(read_bounded(path, 4096)?)) + .map_err(|_| "gateway.disclosure.binding".into()) + } + + async fn content_exchange(socket: &Path, request: &impl Serialize) -> Result<(), Failure> { + let bytes = Zeroizing::new( + serde_json::to_vec(request).map_err(|_| "gateway.submit.encoding-failed")?, + ); + let mut stream = connect_app_socket(socket, "gateway.submit.socket-unavailable").await?; + let clock = auths_gateway::app::SessionClock::start(auths_gateway::app::APP_SESSION_LIMITS); + clock.write_frame(&mut stream, &bytes).await?; + let bytes = tokio::time::timeout( + auths_gateway::app::APP_SESSION_LIMITS.result_wait, + read_frame(&mut stream), + ) + .await + .map_err(|_| "gateway.ipc.read-timeout")??; + let result: auths_gateway::app::AppContentResult = + serde_json::from_slice(&bytes).map_err(|_| "gateway.submit.invalid-response")?; + if matches!(result, auths_gateway::app::AppContentResult::Ready) { + return Err("gateway.submit.invalid-response".into()); + } + println!( + "{}", + serde_json::to_string(&result).map_err(|_| "gateway.output")? + ); + Ok(()) + } + + #[allow( + clippy::too_many_arguments, + reason = "typed CLI inputs remain explicit at the native recipient boundary" + )] + async fn receive_disclosure_cli( + socket: &Path, + target: &Path, + proof: &Path, + action: &Path, + approval: &Path, + expected_binding: &Path, + expected_bytes: u64, + seed_stdin: bool, + content_out: &Path, + acknowledgement_out: &Path, + ) -> Result<(), Failure> { + if !seed_stdin || std::io::stdin().is_terminal() || expected_bytes > 65_536 { + return Err("gateway.disclosure.authentication".into()); + } + for path in [content_out, acknowledgement_out] { + if !path.is_absolute() || path.exists() { + return Err("gateway.state.file-exists-or-unavailable".into()); + } + } + if content_out == acknowledgement_out { + return Err("gateway.state.invalid-path".into()); + } + let mut seed = Zeroizing::new(Vec::new()); + std::io::stdin() + .take(33) + .read_to_end(&mut seed) + .map_err(|_| "gateway.disclosure.authentication")?; + let key = ed25519_dalek::SigningKey::from_bytes( + seed.as_slice() + .try_into() + .map_err(|_| "gateway.disclosure.authentication")?, + ); + let expected = auths_gateway::effect::EffectBinding::from_private_bytes(&Zeroizing::new( + read_bounded(expected_binding, auths_gateway::effect::MAX_EFFECT_BYTES)?, + )) + .map_err(|_| "gateway.disclosure.binding")?; + let request = auths_gateway::app::AppDisclosure { + schema: auths_gateway::app::APP_DISCLOSURE_SCHEMA.to_owned(), + target: read_disclosure_target(target)?, + submission: content_submission(proof, action, approval)?, + }; + let stream = connect_app_socket(socket, "gateway.submit.socket-unavailable").await?; + match auths_gateway::app::receive_content_disclosure( + stream, + &request, + &expected, + expected_bytes, + &key, + ) + .await? + { + auths_gateway::app::AppDisclosureReception::Received(received) => { + private_file(content_out, received.content())?; + let ack = received + .acknowledgement(&key)? + .to_private_bytes() + .map_err(|_| "gateway.disclosure.acknowledgement")?; + private_file(acknowledgement_out, &ack)?; + received.acknowledge(&key).await?; + println!( + "{}", + serde_json::json!({"outcome": "recipient-ack-sent", "received_bytes": expected_bytes}) + ); + } + auths_gateway::app::AppDisclosureReception::History(snapshot) => { + println!( + "{}", + serde_json::to_string(&auths_gateway::app::AppContentResult::History { + history: auths_gateway::ContentHistory::Disclosure(snapshot) + }) + .map_err(|_| "gateway.output")? + ); + } + auths_gateway::app::AppDisclosureReception::Refused(result) => { + println!( + "{}", + serde_json::to_string(&auths_gateway::app::AppContentResult::Refused { + result + }) + .map_err(|_| "gateway.output")? + ); + } + } + Ok(()) + } + async fn app_recover( socket: PathBuf, source_operation: String, @@ -4151,6 +4397,9 @@ mod unix { state_dir, recovery_of, candidate, + content, + disclosure, + binding_out, proof, action, not_before, @@ -4161,6 +4410,9 @@ mod unix { state_dir, recovery_of, candidate, + content, + disclosure, + binding_out, proof, action, not_before, @@ -4645,6 +4897,80 @@ mod unix { outcome, pre_entry, } => observe(app_socket, outcome, pre_entry).await, + Command::ContentAcquire { + app_socket, + proof, + action, + approval, + } => { + let request = auths_gateway::app::AppContent { + schema: auths_gateway::app::APP_CONTENT_SCHEMA.to_owned(), + submission: content_submission(&proof, &action, &approval)?, + }; + request.decode()?; + content_exchange(&app_socket, &request).await + } + Command::ContentHistory { + app_socket, + operation, + } => { + auths_gateway::LogicalOperationId::parse(&operation) + .map_err(|_| "gateway.submit.invalid-frame")?; + content_exchange( + &app_socket, + &auths_gateway::app::AppContentHistory { + schema: auths_gateway::app::APP_CONTENT_HISTORY_SCHEMA.to_owned(), + operation, + }, + ) + .await + } + Command::DisclosureAcknowledge { + app_socket, + operation, + acknowledgement, + } => { + let bytes = Zeroizing::new(read_bounded(&acknowledgement, 4096)?); + let ack = + auths_gateway::effect::DisclosureAcknowledgement::from_private_bytes(&bytes) + .map_err(|_| "gateway.disclosure.acknowledgement")?; + let request = auths_gateway::app::AppDisclosureAcknowledgement { + schema: auths_gateway::app::APP_DISCLOSURE_ACK_SCHEMA.to_owned(), + operation, + acknowledgement_b64: Base64UrlUnpadded::encode_string( + &ack.to_private_bytes() + .map_err(|_| "gateway.disclosure.acknowledgement")?, + ), + }; + request.decode()?; + content_exchange(&app_socket, &request).await + } + Command::DisclosureReceive { + app_socket, + target, + proof, + action, + approval, + expected_binding, + expected_bytes, + recipient_seed_stdin, + content_out, + acknowledgement_out, + } => { + receive_disclosure_cli( + &app_socket, + &target, + &proof, + &action, + &approval, + &expected_binding, + expected_bytes, + recipient_seed_stdin, + &content_out, + &acknowledgement_out, + ) + .await + } Command::EchoVerify { record, pointer, diff --git a/product/runtime/auths-gateway/src/disclosure_transport.rs b/product/runtime/auths-gateway/src/disclosure_transport.rs index 77a65d85d..fb36995df 100644 --- a/product/runtime/auths-gateway/src/disclosure_transport.rs +++ b/product/runtime/auths-gateway/src/disclosure_transport.rs @@ -22,7 +22,7 @@ impl UnixDisclosurePolicy { fn server_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { self.peer(stream, self.gateway_uid(), self.recipient_uid()) } - fn recipient_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { + pub(crate) fn recipient_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { self.peer(stream, self.recipient_uid(), self.gateway_uid()) } fn peer(&self, stream: &UnixStream, local: u32, remote: u32) -> Result<(), &'static str> { @@ -44,12 +44,21 @@ impl UnixDisclosurePolicy { pub struct DisclosureConnection { stream: UnixStream, policy: UnixDisclosurePolicy, + deadline: Option, } impl DisclosureConnection { /// Transfers the stream into the closed disclosure protocol. #[must_use] pub fn new(stream: UnixStream, policy: UnixDisclosurePolicy) -> Self { - Self { stream, policy } + Self { + stream, + policy, + deadline: None, + } + } + pub(crate) fn within(mut self, deadline: Instant) -> Self { + self.deadline = Some(deadline); + self } } @@ -67,11 +76,18 @@ impl AuthenticatedDisclosureChannel { bytes: u64, key: [u8; 32], ) -> Result { - let DisclosureConnection { mut stream, policy } = connection; + let DisclosureConnection { + mut stream, + policy, + deadline: session_deadline, + } = connection; policy.matches(binding)?; policy.server_peer(&stream)?; let start = Instant::now(); - let deadline = start + Duration::from_secs(SESSION_SECONDS); + let deadline = session_deadline + .map_or(start + Duration::from_secs(SESSION_SECONDS), |limit| { + limit.min(start + Duration::from_secs(SESSION_SECONDS)) + }); let mut nonce = [0; 32]; getrandom::fill(&mut nonce).map_err(|_| "gateway.disclosure.authentication")?; let challenge = Challenge { @@ -80,10 +96,13 @@ impl AuthenticatedDisclosureChannel { delivery: DisclosureAcknowledgementRequest::for_delivery(binding, bytes, key) .map_err(|_| "gateway.disclosure.authentication")?, }; - let response = timeout_at(start + Duration::from_secs(AUTH_SECONDS), async { - write_frame(&mut stream, &bounded(&challenge)?, MAX_AUTH_BYTES).await?; - decode::(&read_frame(&mut stream, MAX_AUTH_BYTES).await?) - }) + let response = timeout_at( + deadline.min(start + Duration::from_secs(AUTH_SECONDS)), + async { + write_frame(&mut stream, &bounded(&challenge)?, MAX_AUTH_BYTES).await?; + decode::(&read_frame(&mut stream, MAX_AUTH_BYTES).await?) + }, + ) .await .map_err(|_| "gateway.disclosure.timeout")??; let authentication = RecipientAuthentication { @@ -197,7 +216,11 @@ pub async fn receive_disclosure( bytes: u64, key: &SigningKey, ) -> Result { - let DisclosureConnection { mut stream, policy } = connection; + let DisclosureConnection { + mut stream, + policy, + deadline: session_deadline, + } = connection; policy.matches(binding)?; policy.recipient_peer(&stream)?; let expected = DisclosureAcknowledgementRequest::for_delivery( @@ -207,16 +230,21 @@ pub async fn receive_disclosure( ) .map_err(|_| "gateway.disclosure.authentication")?; let start = Instant::now(); - let deadline = start + Duration::from_secs(SESSION_SECONDS); - let challenge = timeout_at(start + Duration::from_secs(AUTH_SECONDS), async { - let challenge: Challenge = decode(&read_frame(&mut stream, MAX_AUTH_BYTES).await?)?; - if challenge.delivery != expected { - return Err("gateway.disclosure.authentication"); - } - let response = Response::sign(&challenge, key)?; - write_frame(&mut stream, &bounded(&response)?, MAX_AUTH_BYTES).await?; - Ok::<_, &'static str>(challenge) - }) + let deadline = session_deadline.map_or(start + Duration::from_secs(SESSION_SECONDS), |limit| { + limit.min(start + Duration::from_secs(SESSION_SECONDS)) + }); + let challenge = timeout_at( + deadline.min(start + Duration::from_secs(AUTH_SECONDS)), + async { + let challenge: Challenge = decode(&read_frame(&mut stream, MAX_AUTH_BYTES).await?)?; + if challenge.delivery != expected { + return Err("gateway.disclosure.authentication"); + } + let response = Response::sign(&challenge, key)?; + write_frame(&mut stream, &bounded(&response)?, MAX_AUTH_BYTES).await?; + Ok::<_, &'static str>(challenge) + }, + ) .await .map_err(|_| "gateway.disclosure.timeout")??; let content = timeout_at( diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 2637bd01b..9214f947a 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -24,7 +24,9 @@ pub(crate) use capacity::SourceCapacity; mod candidate; mod content; pub(crate) use content::ContentPlan; -pub use content::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; +pub use content::{ + CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition, compile_content_action, +}; mod release; pub(crate) use release::DisclosurePlan; pub use release::{DISCLOSURE_TOOL, DisclosureTarget, compile_disclosure}; diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 3d861bd99..900e00967 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -485,16 +485,28 @@ pub fn compile_recovery_acquisition( ) } +pub(super) fn compile_acquisition( + installed: &EffectInstallation<'_>, + target: AcquisitionTarget, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; + compile_verified_acquisition(installed, target, now, proof, action, sealed) +} + #[allow( clippy::too_many_lines, reason = "one native verification path retains the closed acquisition target contracts" )] -pub(super) fn compile_acquisition( +pub(super) fn compile_verified_acquisition( installed: &EffectInstallation<'_>, target: AcquisitionTarget, now: u64, proof: &[u8], action: &[u8], + sealed: auths_verifier::SealedVerificationResult, ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) @@ -514,7 +526,6 @@ pub(super) fn compile_acquisition( .validate_installation(installed) .map_err(|_| invalid())?, } - let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; let verified = sealed.action().ok_or_else(invalid)?; let command = McpProfile .decode_verified(verified) diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index 8bcd32798..2b4062039 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -233,6 +233,43 @@ pub fn compile_content_acquisition( ) } +/// Compiles resource arguments directly from a native-verified content action. +/// There is no separate application map capable of changing the selected resource. +/// +/// # Errors +/// Refuses non-content actions, malformed resource arguments and every normal +/// native acquisition/installation constraint. Performs no custody or I/O. +pub fn compile_content_action( + installed: &EffectInstallation<'_>, + now: u64, + proof: &[u8], + action: &[u8], +) -> Result { + use auths_profile_api::ActionProfile as _; + let invalid = || not_entered("gateway.acquisition.binding"); + let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; + let verified = sealed.action().ok_or_else(invalid)?; + let command = auths_profile_mcp::McpProfile + .decode_verified(verified) + .map_err(|_| invalid())?; + let arguments = command + .arguments() + .get("resource_arguments") + .and_then(Value::as_object) + .cloned() + .ok_or_else(invalid)?; + let target = ContentReadTarget::new(installed.recipe, installed.connection, arguments) + .map_err(|_| invalid())?; + super::acquisition::compile_verified_acquisition( + installed, + AcquisitionTarget::Content(Box::new(target)), + now, + proof, + action, + sealed, + ) +} + /// Immutable reconstruction data, never a transport capability. The signed /// binding pins the complete contract and request; current connection bytes /// must also match under the common admission and entry fence. diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index 1c16e3aca..320082b17 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -257,6 +257,18 @@ fn native_content_compilation_fixture_is_current() { &submission.action, ) .expect("native effect"); + let from_action = crate::effect::compile_content_action( + &installed, + NOW, + &submission.proof, + &submission.action, + ) + .expect("native action projection"); + assert_eq!( + from_action.binding(), + effect.binding(), + "one resource and binding owner" + ); assert!(effect.private_request().is_none(), "not a mutation"); let review = effect.private_review().expect("review"); let literal = review @@ -434,7 +446,7 @@ fn native_content_compilation_fixture_is_current() { let fixture = json!({"schema": "auths.gateway-content-compilation-fixture/1", "scope": "native compilation and pure bounded projection; no acquisition entry, custody or disclosure", "cases": cases, "projections": projection_cases, "invalid_declarations": invalid_declarations(), - "undeclared_content_read_refused": true}); + "undeclared_content_read_refused": true, "native_action_resource_projection_parity": true}); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/content-compilation.json"); let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); @@ -799,6 +811,21 @@ async fn native_content_journal_fixture_is_current() { } else { assert_eq!(phase["stage"], "unknown"); } + let history_operation = + LogicalOperationId::parse(&format!("content-journal-{index}")).expect("operation"); + assert_eq!( + attempts + .content_history(recipe.namespace(), &history_operation, *recipe.digest()) + .await + .expect("content history"), + crate::ContentHistory::Acquisition(snapshot.clone()) + ); + assert!( + attempts + .content_history(recipe.namespace(), &history_operation, [0; 32]) + .await + .is_err() + ); let projection = serde_json::to_value(&snapshot.content_projection).expect("status"); let expected_projection = match index { 0 | 8 | 9 | 10 | 13 => json!({"kind": "ready", "bytes": expected_body.len()}), diff --git a/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs index 03632e2aa..164674879 100644 --- a/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs +++ b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs @@ -3,7 +3,6 @@ use super::*; use crate::disclosure_transport::{ AuthenticatedDisclosureChannel, DisclosureConnection, ReceivedDisclosure, deliver, - receive_disclosure, }; use crate::effect::UnixDisclosurePolicy; use tokio::net::UnixStream; @@ -17,19 +16,59 @@ async fn authenticate( AuthenticatedDisclosureChannel, tokio::task::JoinHandle>, ) { - let (server, client) = UnixStream::pair().expect("socket pair"); + use base64ct::{Base64UrlUnpadded, Encoding as _}; + let (mut server, client) = UnixStream::pair().expect("socket pair"); let binding = approved.effect().binding().clone(); - let client_policy = policy.clone(); + let source = approved + .disclosure_plan() + .expect("plan") + .source() + .expect("source"); + let wire: Value = + serde_json::from_slice(&binding.to_private_bytes().expect("binding")).expect("JSON"); + let request = crate::app::AppDisclosure { + schema: crate::app::APP_DISCLOSURE_SCHEMA.to_owned(), + target: crate::app::AppDisclosureTarget { + source_operation: source.journal_identity().1.to_owned(), + recipient_key: recipient.verifying_key().to_bytes(), + channel: policy.clone(), + delivery_instance: serde_json::from_value( + wire["protocol"]["delivery_instance"].clone(), + ) + .expect("instance"), + }, + // Framing shim only: the native installed grant below uses the real + // approved proof from the corpus. No installed app dispatch is claimed. + submission: crate::app::AppSubmission { + schema: crate::app::APP_REQUEST_SCHEMA.to_owned(), + proof_b64: "AA".to_owned(), + action_b64: "AA".to_owned(), + approval_b64: Base64UrlUnpadded::encode_string( + &approved.approval().to_private_bytes().expect("approval"), + ), + }, + }; let client_key = recipient.clone(); let receiver = tokio::spawn(async move { - receive_disclosure( - DisclosureConnection::new(client, client_policy), - &binding, - bytes, - &client_key, - ) - .await + match crate::app::receive_content_disclosure(client, &request, &binding, bytes, &client_key) + .await? + { + crate::app::AppDisclosureReception::Received(received) => Ok(received), + _ => Err("test.unexpected-history"), + } }); + let frame = crate::app::read_frame(&mut server) + .await + .expect("client request"); + let request: crate::app::AppDisclosure = + serde_json::from_slice(&frame).expect("typed envelope"); + request.decode().expect("bounded envelope"); + crate::app::write_frame( + &mut server, + &serde_json::to_vec(&crate::app::AppContentResult::Ready).expect("ready"), + ) + .await + .expect("ready frame"); let channel = AuthenticatedDisclosureChannel::authenticate( DisclosureConnection::new(server, policy.clone()), approved.effect().binding(), @@ -169,6 +208,20 @@ pub(super) async fn corpus( .expect("restore record"); } + assert_eq!( + attempts + .content_history(recipe.namespace(), &operation, *recipe.digest()) + .await + .expect("historical disclosure"), + crate::ContentHistory::Disclosure(acknowledged.clone()) + ); + assert!( + attempts + .content_history(recipe.namespace(), &operation, [0; 32]) + .await + .is_err() + ); + // Actual receipt followed by loss of the ACK channel retains full charges. let second = approve(3, channel_policy); let second_operation = LogicalOperationId::parse("release-3").expect("operation"); @@ -452,8 +505,8 @@ pub(super) async fn corpus( authentication_failures(&first, bytes, recipient, channel_policy).await; let fixture = json!({"schema": "auths.gateway-disclosure-delivery-fixture/1", - "scope": "real Unix socket pairs and installed native file fence; no independent processes, hostile UID isolation or PostgreSQL claim", - "authenticated_delivery": acknowledged, "lost_ack": unknown, "late_ack": late, + "scope": "native application client with a control-frame shim, real Unix socket pairs and installed native file fence; no installed app dispatcher, independent processes, hostile UID isolation or PostgreSQL claim", + "native_application_client_protocol_switch": true, "authenticated_delivery": acknowledged, "lost_ack": unknown, "late_ack": late, "competing_live_channels": raced_snapshot, "approval_expired_after_authentication_refused": true, "configuration_changed_after_authentication_refused": true, "corrupt_source_after_authentication_refused": true, "retained_authentication_corruption_refused": true, diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 4c8244b93..de7f3cbea 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1549,6 +1549,93 @@ impl GatewayEngine { }) } + /// Native compilation from the signed action's own resource arguments. + /// This application boundary accepts no independent URL/resource map. + /// + /// # Errors + /// Refuses malformed authority, unsupported content and changed installation. + pub async fn compile_content_action( + &self, + proof: &[u8], + action: &[u8], + ) -> Result { + let (loaded, now) = self.effect_compilation_inputs().await?; + crate::effect::compile_content_action( + &self.effect_policy.installation( + &self.recipe, + &self.trusted_context, + loaded.record(), + self.qualification.policy(), + self.effect_configuration_candidate().map_err(not_entered)?, + ), + now, + proof, + action, + ) + } + + /// Acquires content under native authority and approval of that exact action. + /// The result contains retained facts only, never plaintext or a release permit. + /// + /// # Errors + /// Preserves native refusal/uncertainty; existing grants are never retried. + pub async fn acquire_content_action( + &self, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result { + let started = Instant::now(); + let effect = self.compile_content_action(proof, action).await?; + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = Arc::new( + effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?, + ); + self.acquire_read_approved(approved, now, started).await + } + + /// Reads redacted content/disclosure history in this installed recipe and + /// partition. It performs no current authorization, custody or external I/O. + /// + /// # Errors + /// Refuses foreign, absent, obsolete or corrupt state without disclosing it. + pub async fn content_history( + &self, + operation: &str, + ) -> Result { + let operation = crate::LogicalOperationId::parse(operation) + .map_err(|_| not_entered("gateway.disclosure.binding"))?; + self.attempts + .content_history(self.recipe.namespace(), &operation, *self.recipe.digest()) + .await + .map_err(|_| GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }) + } + + /// Records historical recipient evidence without new delivery or capacity. + /// + /// # Errors + /// Refuses mismatched ACKs and absent/corrupt/foreign retained grants. + pub async fn acknowledge_disclosure( + &self, + operation: &str, + acknowledgement: &crate::effect::DisclosureAcknowledgement, + ) -> Result { + self.content_history(operation).await?; + let operation = crate::LogicalOperationId::parse(operation) + .map_err(|_| not_entered("gateway.disclosure.binding"))?; + self.attempts + .acknowledge_disclosure(self.recipe.namespace(), &operation, acknowledgement) + .await + .map_err(|_| not_entered("gateway.disclosure.acknowledgement")) + } + /// Compiles a declared content GET from exact resource arguments using /// fresh independent native read authority. Performs no custody or provider /// I/O and returns private review/approval data only. diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index c3d429d1a..65fc9e49c 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -138,15 +138,16 @@ pub use separation::{ }; pub use store::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, - ClaimedGatewayAttempt, ContentProjectionStatus, DisclosureSnapshot, DisclosureStage, - FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptSnapshot, - GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, GatewayCounterEntry, - GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, GatewayInsert, - GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, - GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, - ObservableGatewayAttempt, PostgresGatewayAttemptStore, PrivateDirectoryError, - RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, - RetainedContent, check_private_directory, check_private_directory_owned_by, pre_entry_digest, + ClaimedGatewayAttempt, ContentHistory, ContentProjectionStatus, DisclosureSnapshot, + DisclosureStage, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, + GatewayAttemptSnapshot, GatewayAttemptStage, GatewayAttemptStore, GatewayAttempts, + GatewayCounterEntry, GatewayCounterKind, GatewayEvidenceChannel, GatewayFenceDecision, + GatewayInsert, GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, + GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, + GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, + PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, + ReservedAcquisition, RetainedContent, check_private_directory, + check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index bc5f05bef..8cbb8850c 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "5134ad54772c32a0ae5b4f92589e088925cc520d092afb0caffef5abc3467bc3"; + "7c9d31da1ca994bda1fc4d8543c22f62f039448dfe0128c0f2dace699afc676f"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index e26afaf2f..974b16bb1 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2895,6 +2895,67 @@ fn decode_protocol(bytes: &[u8]) -> Result, GatewayAttempt Ok(record) } +/// Redacted retained content facts. History grants no current execution authority. +#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] +#[serde( + tag = "kind", + content = "snapshot", + rename_all = "kebab-case", + deny_unknown_fields +)] +pub enum ContentHistory { + /// Provider acquisition facts; no content or recipient receipt claim. + Acquisition(AcquisitionSnapshot), + /// Separate recipient disclosure/ACK facts. + Disclosure(DisclosureSnapshot), +} + +impl GatewayAttempts { + /// Loads exact local content history without reconstructing any entry permit. + /// + /// # Errors + /// Refuses absent, foreign or malformed state and non-content protocols. + pub async fn content_history( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + recipe: [u8; 32], + ) -> Result { + let key = self.key(namespace, operation)?; + let store = Arc::clone(&self.store); + let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let bytes = zeroize::Zeroizing::new(bytes); + let record = decode_protocol(&bytes)?; + let binding = record.validate_header()?; + if !self.policy.contains(&binding) + || record.namespace != namespace.as_str() + || record.operation_id != operation.as_str() + || record.recipe_digest != hex::encode(recipe) + { + return Err(GatewayAttemptError::BindingConflict); + } + match &record.state { + ProtocolState::Disclosure(_) => Ok(ContentHistory::Disclosure( + record + .map_state(disclosure::DisclosureState::extract)? + .disclosure_snapshot()?, + )), + ProtocolState::Acquisition(state) + if matches!(state.plan, crate::effect::AcquisitionPlan::Content(_)) => + { + Ok(ContentHistory::Acquisition( + record + .map_state(acquisition::AcquisitionState::extract)? + .snapshot()?, + )) + } + _ => Err(GatewayAttemptError::BindingConflict), + } + } +} + /// The snapshot of one stored record's bytes, for the fuzz targets. #[cfg(feature = "fuzzing")] pub(crate) fn fuzz_snapshot(bytes: &[u8]) -> Option { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index ec672f610..f8a1f2b74 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -20,7 +20,8 @@ pub use recovery::{ }; /// Public facts about a bounded acquisition, with no content or private digest. -#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] pub struct AcquisitionSnapshot { /// Durable journal revision. pub revision: u64, @@ -48,7 +49,7 @@ pub struct AcquisitionSnapshot { } /// Acquisition has no mutation-observed or disclosure-acknowledged state. -#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] pub enum AcquisitionStage { /// Capacity held; no provider permit. @@ -66,7 +67,7 @@ pub enum AcquisitionStage { #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub(super) struct AcquisitionState { - plan: AcquisitionPlan, + pub(super) plan: AcquisitionPlan, allocation: Option, counters: Vec, phase: AcquisitionPhase, diff --git a/product/runtime/auths-gateway/src/store/acquisition/content.rs b/product/runtime/auths-gateway/src/store/acquisition/content.rs index 3457220e0..718cacb5e 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/content.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/content.rs @@ -9,7 +9,7 @@ type ContentMac = Hmac; pub(crate) const PROTECTED_CONTENT_SCHEMA: &str = "auths.gateway-protected-content/1"; /// Public response interpretation without plaintext, key or correlation digest. -#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)] pub enum ContentProjectionStatus { /// Exact projected bytes are reconstructible from private retained evidence. diff --git a/product/runtime/auths-gateway/src/store/disclosure.rs b/product/runtime/auths-gateway/src/store/disclosure.rs index 23ea40d88..a9e5b3d1d 100644 --- a/product/runtime/auths-gateway/src/store/disclosure.rs +++ b/product/runtime/auths-gateway/src/store/disclosure.rs @@ -6,7 +6,8 @@ use crate::effect::disclosure_auth::RecipientAuthentication; use crate::effect::{DisclosureAcknowledgement, DisclosurePlan}; /// Redacted disclosure facts, separate from provider response and observation. -#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] pub struct DisclosureSnapshot { /// Exact retained journal revision. pub revision: u64, @@ -26,7 +27,7 @@ pub struct DisclosureSnapshot { } /// Disclosure cannot record provider responses or mutation observations. -#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] pub enum DisclosureStage { /// Reservation has no delivery permission. diff --git a/product/runtime/auths-gateway/tests/application_content_cli.rs b/product/runtime/auths-gateway/tests/application_content_cli.rs new file mode 100644 index 000000000..c34618827 --- /dev/null +++ b/product/runtime/auths-gateway/tests/application_content_cli.rs @@ -0,0 +1,131 @@ +//! Native CLI/control-frame artifact. Refusal servers prove framing only; +//! installed acquisition/disclosure and hostile-agent containment remain separate. +#![cfg(unix)] +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + os::unix::net::UnixListener, + process::Command, +}; + +fn serve(listener: UnixListener, reply: Value) -> std::thread::JoinHandle { + listener.set_nonblocking(true).expect("nonblocking"); + std::thread::spawn(move || { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10); + let mut stream = loop { + match listener.accept() { + Ok((stream, _)) => break stream, + Err(error) + if error.kind() == std::io::ErrorKind::WouldBlock + && std::time::Instant::now() < deadline => + { + std::thread::sleep(std::time::Duration::from_millis(5)) + } + Err(error) => panic!("CLI did not connect: {error}"), + } + }; + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(std::time::Duration::from_secs(5))) + .expect("deadline"); + let mut length = [0; 4]; + stream.read_exact(&mut length).expect("length"); + let length = u32::from_be_bytes(length) as usize; + assert!((1..=auths_gateway::app::MAX_FRAME_BYTES).contains(&length)); + let mut bytes = vec![0; length]; + stream.read_exact(&mut bytes).expect("frame"); + let captured = serde_json::from_slice(&bytes).expect("request"); + let response = serde_json::to_vec(&reply).expect("response"); + stream + .write_all(&u32::try_from(response.len()).expect("length").to_be_bytes()) + .expect("length"); + stream.write_all(&response).expect("response"); + captured + }) +} + +#[test] +fn native_application_content_cli_fixture_is_current() { + let root = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let corpus: Value = serde_json::from_slice( + &std::fs::read(root.join("application-content-frame.json")).expect("native frame corpus"), + ) + .expect("JSON"); + let requests = &corpus["requests"]; + let directory = tempfile::Builder::new() + .prefix("auths-content-") + .tempdir_in("/tmp") + .expect("directory"); + for field in ["proof", "action", "approval"] { + let bytes = Base64UrlUnpadded::decode_vec( + requests["content"]["submission"][format!("{field}_b64")] + .as_str() + .expect("input"), + ) + .expect("bytes"); + std::fs::write(directory.path().join(field), bytes).expect("input"); + } + std::fs::write( + directory.path().join("ack"), + Base64UrlUnpadded::decode_vec( + requests["disclosure-ack"]["acknowledgement_b64"] + .as_str() + .expect("ACK"), + ) + .expect("bytes"), + ) + .expect("input"); + let mut cases = Vec::new(); + for (name, command, code) in [ + ("content", "content-acquire", "gateway.acquisition.binding"), + ( + "content-history", + "content-history", + "gateway.attempt.state-unavailable", + ), + ( + "disclosure-ack", + "disclosure-acknowledge", + "gateway.disclosure.acknowledgement", + ), + ] { + let socket = directory.path().join(format!("{name}.sock")); + let reply = + json!({"outcome": "refused", "result": {"outcome": "not-entered", "code": code}}); + let server = serve(UnixListener::bind(&socket).expect("bind"), reply.clone()); + let mut cli = Command::new(env!("CARGO_BIN_EXE_auths-gateway")); + cli.arg(command).arg("--app-socket").arg(socket); + if name == "content" { + for field in ["proof", "action", "approval"] { + cli.arg(format!("--{field}")) + .arg(directory.path().join(field)); + } + } else { + cli.arg("--operation").arg("fixture-1"); + if name == "disclosure-ack" { + cli.arg("--acknowledgement") + .arg(directory.path().join("ack")); + } + } + let output = cli.output().expect("CLI"); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + let captured = server.join().expect("server"); + assert_eq!(captured, requests[name]); + let response: Value = serde_json::from_slice(&output.stdout).expect("response"); + assert_eq!(response, reply); + cases.push(json!({"command": command, "request": captured, "response": response})); + } + let fixture = json!({"schema": "auths.application-content-cli-fixture/1", "scope": "production CLI with real refusal sockets; no installed engine/provider/disclosure-receive claim", "cases": cases}); + let bytes = serde_json::to_vec_pretty(&fixture).expect("fixture"); + let path = root.join("application-content-cli.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} From c80902ab79f8a296a60624640253a43c12332404 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 22:53:28 +0000 Subject: [PATCH 056/136] feat(gateway): author native content calls and exercise process recovery --- .../gateway/content-process-journey.json | 115 +++ compliance.toml | 3 + ...017-bound-effect-and-recovery-ownership.md | 21 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 30 +- docs/plans/0074-implementation-status.md | 63 +- .../0009-bound-effect-and-recovery.md | 20 + ...ound-effects-and-recovery-state-machine.md | 25 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 77 ++ product/runtime/auths-gateway/src/engine.rs | 40 + product/runtime/auths-gateway/src/harness.rs | 30 +- .../auths-gateway/src/harness/authoring.rs | 12 + .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/content_journey.rs | 966 ++++++++++++++++++ 14 files changed, 1388 insertions(+), 18 deletions(-) create mode 100644 bindings/fixtures/gateway/content-process-journey.json create mode 100644 product/runtime/auths-gateway/tests/content_journey.rs diff --git a/bindings/fixtures/gateway/content-process-journey.json b/bindings/fixtures/gateway/content-process-journey.json new file mode 100644 index 000000000..7760fda23 --- /dev/null +++ b/bindings/fixtures/gateway/content-process-journey.json @@ -0,0 +1,115 @@ +{ + "schema": "auths.content-process-journey/1", + "scope": "production CLI and daemon processes, native proofs/exact approval, real file custody/journal and counting loopback HTTP; public fixed signing keys simulate reviewer, actor and recipient; no human presence, UID containment, installed language package, power loss or PostgreSQL claim", + "provider_requests": [ + "GET /documents/recTEST0000000001?format=text%2Fplain HTTP/1.1", + "PATCH /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1", + "GET /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1" + ], + "acquisition": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 32, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 32 + } + } + } + }, + "disclosure": { + "outcome": "history", + "history": { + "kind": "disclosure", + "snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 32, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + }, + "mutation": { + "outcome": "response-recorded", + "status": 200 + }, + "observation": { + "outcome": "recovery-report", + "report": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": 200, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": "actual-runtime-time-checked" + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded" + } + }, + "revoked_disclosure": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.connection.unavailable" + } + }, + "restart_replay_no_redelivery": true, + "crash_after_receipt_before_ack": { + "outcome": "history", + "history": { + "kind": "disclosure", + "snapshot": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 32, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + }, + "late_ack_after_crash": { + "outcome": "history", + "history": { + "kind": "disclosure", + "snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 32, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + }, + "late_ack_idempotent": true, + "private_recipient_outputs_mode": "0600", + "resource_authoring_rejects_duplicate_extra_nonobject_oversize": true, + "resource_limit_accepted_and_existing_call_not_overwritten": true, + "public_results_exclude_sentinel_content_and_credential": true +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index d11fe9939..f0e4eb08e 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1619,6 +1619,9 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +content-process-composition = [ + "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_journey_fixture_is_current", +] content-application-boundary = [ "product/runtime/auths-gateway/src/app/content_tests.rs#native_application_content_frame_fixture_is_current", "product/runtime/auths-gateway/tests/application_content_cli.rs#native_application_content_cli_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 41e9156db..4dc09864e 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1044,3 +1044,24 @@ sockets. Native socket/file delivery cases now use the production recipient clie with an explicit control-frame shim; the native installed file grant still uses real approved authority. These are not a complete installed app dispatcher, recipient CLI process, language runtime, authenticated UI or hostile-agent claim. + + +## Native authoring and process evidence + +Content/disclosure call-authoring APIs reuse `ContentReadTarget` and +`DisclosureTarget` with installed recipe/connection and retained provenance. +The CLI does not construct contracts or hashes. Content JSON reuses the existing +65,536-byte duplicate-rejecting parser as a mechanical leaf, then the native +recipe validates its closed resource fields. These operator-only authoring +surfaces return canonical private data, never an execution capability. + +The real daemon/recipient CLI artifact now covers acquisition, disclosure and +ACK, restart replay without redelivery, an approved mutation and independent +provider-linked observation. A separate test recipient uses the shipping native +client to retain ACK evidence without sending it; both peers are killed, and +reopen preserves unknown charges until exact late ACK. A separate operator +process disables before a further release and no bytes are delivered. These +histories use the shared file adapter and public fixed test signing keys. +Authenticated UI, installed language packages, complete fault/concurrency tests, +PostgreSQL and hostile process isolation remain distinct incomplete obligations. +No production transition predicate or wire schema changed in this increment. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 4342227c0..b5a9e752e 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -383,8 +383,26 @@ native signed read action. Release is separately authorized and reviewed with `effect-review --disclosure --binding-out `. The proposal is the closed native `AppDisclosureTarget`: source operation, recipient public key, exact UID/channel policy and delivery instance. Use native -call authoring; the CLI authoring integration and full installed UI journey are -still tracked by AP074 and are not completed by these controls. +call authoring as follows; the authenticated UI journey remains tracked by AP074. + +1. Save only the declared resource arguments in an owner-private JSON object. + Run `effect-content-call --state-dir ... --resource-arguments /private/resource.json + --operation ... --call-out /private/read-call.json`. The output path must be + new and absolute. The native parser rejects duplicates, extra fields and + input above 65,536 bytes. Obtain native proof/action for the returned exact + call, then review with `effect-review --content` and obtain exact approval. +2. Acquire through `content-acquire`. A recorded provider response is not a + delivery and does not authorize release. +3. Save the private native recipient proposal. Run `effect-disclosure-call + --state-dir ... --target /private/target.json --operation ... + --call-out /private/disclosure-call.json`. This loads retained provenance, + not provider content from the network. Obtain independent proof/action and + review with `effect-review --disclosure /private/target.json --binding-out + /private/expected-binding.json`, then obtain exact approval. + +Both authoring commands preserve native canonical calls; they create no proof, +approval, reservation, credential lease or transport permission. Resource data +is not a caller-controlled URL/body/limit override. `disclosure-receive` requires the trusted expected-binding file, exact byte count, proposal and independent proof/action/approval. Pipe the recipient's raw 32-byte @@ -402,3 +420,11 @@ that exact evidence without redelivery. A disconnect, unknown outcome or retaine grant must not trigger an automatic repeat. Python/TypeScript expose matching acquisition/history/ACK control methods returning native result bytes. Recipient handshake, binding/ACK interpretation and signing remain in Rust. + + +The `content-process-journey.json` artifact runs the real local daemon, authoring, +review and recipient CLI with a counting HTTP double. It exercises read/release, +ACK-loss crash/reopen/no-redelivery/late ACK, an exact write and independent +observation, plus separate-process disable before release. Public fixed keys +simulate signing. This establishes neither human presence, installed language +binding integration, hostile UID/egress isolation nor PostgreSQL durability. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index be0cbc349..995761695 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1378,6 +1378,61 @@ closure regeneration passed after that correction (one artifact-generation test) execution or hosted CI observation ran. No A01–A22 case is closed. AP073 remains untouched; full installed process/adapters/UI and AP070 owner cutover remain. +## Native call authoring and complete CLI process composition checkpoint + +- Based on `189bb1ea`. The preceding user turn was a status-only response, not + implementation progress; this continuation revalidated the clean worktree and + performed the next implementation/evidence step. No AP073 files or agents used. +- Native `content_authorization_call` uses the existing bounded duplicate-free + JSON parser and `ContentReadTarget` against the installed connection. Native + `disclosure_authorization_call` uses `DisclosureTarget` from retained source + provenance. CLI `effect-content-call` and `effect-disclosure-call` save native + canonical calls to new absolute 0600 files. No duplicate contract/hash, proof, + approval, reservation, custody lease or transport authority is introduced. +- `content_journey.rs` generates `content-process-journey.json` through actual + production CLI/daemon processes, native signed proofs/exact approvals, local + file custody/journal and a counting loopback HTTP double. Test-only fixed-key + trust authoring explicitly admits a bounded same-service tool set; each signed + action/grant retains a single permission and undergoes native verification. +- The journey acquires content, authenticates a recipient CLI, saves exact bytes + and canonical ACK in 0600 files, confirms durable ACK, kills/restarts the daemon + and proves history replay produces neither new output files nor provider reads. + A second native recipient process receives bytes and retains ACK without sending + it; both peers are killed. Reopen reports unknown with one delivery/32 bytes + retained. Replay returns history without delivery; exact late ACK refines the + same charged journal, and repeated ACK is idempotent. +- The same daemon then performs an exactly approved write and a separately + authorized recovery GET. The provider echo produces native `observed-by-provider` + evidence, distinct from state-match evidence and the original HTTP response. + Three total provider requests are asserted. Write/recovery replay adds none. + A separate operator process disables the connection before another approved + disclosure; it refuses with no content/ACK output. Historical ACK remains visible. +- Public control results exclude content/credential sentinels. Resource authoring + rejects duplicate, extra, nonobject and 65,537-byte inputs, accepts the 65,536-byte + boundary and preserves existing output files. The native recipient trust channel + remains a test fixture, not an authenticated human UI or isolated hostile agent. +- Artifact generation initially caught fixture API/import mistakes, the query's + expected percent encoding, and an incorrect test expectation that echo-linked + observation also sets state-match. The final assertions retain the native + distinction; production verification/reducer predicates were not weakened. +- Executed artifact command: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --features testkit-harness,loopback-provider --test content_journey -- --exact native_content_process_journey_fixture_is_current`. + Final complete process/crash/resource-boundary generation passed one test in + 3.08 seconds (one subprocess helper filtered from the parent run and invoked + explicitly as a separate recipient process inside the journey). +- Required exact native content compilation, candidate compilation, recovery + acquisition and semantic-closure generation passed four tests in 32.62 seconds. + Content/candidate/recovery fixtures stayed byte-for-byte unchanged; the source + closure and embedded digest were refreshed. The final process fixture was + generated after the resource limit and output-preservation assertions landed. + No local broad build/test/lint/formal suite was run. +- This strengthens A07/A08/A22 with real file/process composition; no entire + acceptance row closes. Authenticated UI, installed Python/TypeScript packages, + hostile UID/egress containment, PostgreSQL, remaining crash/race/fault points, + full recovery operations, AP070 ownership removal, differential/formal/performance + and required hosted evidence remain outstanding. No broad local gate or CI + observation was performed. + ## Phase gates | Phase | State | Outstanding gate | @@ -1385,8 +1440,8 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition/disclosure runtime and application controls wired | Native call-authoring CLI, full installed recipient/binding/UI journeys; remove AP070 Python semantic owner | -| P4 | Pending | Differential/local journey, installed bindings, formal links, CI | +| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed bindings/authenticated UI, standalone read recipe and AP070 Python owner removal | +| P4 | Partial CLI process journey | Differential, full faults/adapters, installed bindings/UI, formal/performance links and CI | ## Acceptance ledger @@ -1403,7 +1458,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Partial / socket-file corpus / connection disabled after authentication refuses entry | Independent-process revocation and installed journey pending | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / native ACK/reducer and socket-file corpus / actual send/ACK loss, reopen without redelivery and late ACK executed | Independent-process crash and installed runtime journey pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | @@ -1417,7 +1472,7 @@ separate claim. No AP074 acceptance case is currently executed or qualified. | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | | A20 | Generated histories and shipping predicate refinement | Partial / 576 typed stage pairs, ACK histories and Kani source / pure corpus executed | Full generated concurrent histories and source-linked formal artifacts pending | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | -| A22 | Installed single-human/single-agent full journey/UI | Partial / candidate CLI and content application controls / candidate journey and content refusal-socket CLI executed | Full installed read/disclosure/write/observation, recipient CLI and authenticated UI | +| A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 2d45a0f3f..3bb86075f 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -688,3 +688,23 @@ TypeScript carry bounded envelopes and native result bytes; no shared semantic predicate, hash, signature or capacity rule moves into those wrappers. Frame, CLI refusal and native-client/file evidence have explicit narrow scopes. Full installed consumer, reference differential and isolation gates remain required. + + +### Native authoring and process composition evidence + +The content/disclosure authoring commands reuse the native target constructors +and canonical MCP encoding. The existing bounded duplicate-free JSON decoder is +reused only for mechanical parsing; resource meaning remains in the reviewed +recipe capability. No new recipe operation dispatch, hash owner, policy callback +or transition rule is introduced. Test-only trust authoring now accepts an +explicit bounded same-service tool set, while each real signed action/grant has +its exact permission and still passes native verification. + +`content-process-journey.json` adds real CLI/daemon composition over the file +adapter: separate acquisition/release, actual recipient ACK, restart no-redelivery, +crash after recipient receipt before ACK, late evidence, approved write and +independent read-back, and separate-process disable before release. The artifact +records three actual provider requests and redacted native facts. Public fixed +keys simulate actors; neither installed UI/language integration, isolated hostile +agent containment nor PostgreSQL/full fault coverage is inferred. Differential +reference and bounded performance exit gates remain open. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 45484e1fb..3002a188c 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -577,8 +577,29 @@ history and late-ACK methods carry native bytes unchanged; they implement no content projection, commitment, signing, accounting or retry decision. Recipient protocol execution stays in Rust. Native frame/CLI artifacts and socket-client cases are narrower than installed authority/UI/binding/hostile-process evidence; -those full journeys, native call-authoring CLI integration and AP070 cutover remain -required. +authenticated UI/installed binding integration and AP070 cutover remain required. + +Native `effect-content-call` accepts a private resource-argument file and uses +`ContentReadTarget` against the installed connection. It reuses the bounded +65,536-byte duplicate-rejecting JSON leaf; extra fields, nonobjects and invalid +resource values fail closed. `effect-disclosure-call` resolves the retained native +source from its private recipient proposal and uses `DisclosureTarget`. Both save +canonical native calls to new absolute 0600 files; neither creates authority, +approval, reservation, a custody lease or external entry. + +`content-process-journey.json` now executes these commands, private native review, +exact approval, the real daemon dispatcher and recipient CLI. A counting local +HTTP double observes one content GET, one approved PATCH and one independently +authorized observation GET. Restart preserves acquisition/disclosure history and +refuses redelivery. In a second disclosure a separate native recipient process +saves content/ACK but sends no ACK; killing both peers leaves unknown charged +history after reopen, and exact late ACK refines it without another delivery. +A separate operator process disables the connection before a newly approved +release; the recipient receives no content. Public outputs exclude fixture +content/credential sentinels. These are local file/process observations with +public test keys simulating the reviewer, actor and recipient. They do not close +human approval UI, installed language packages, hostile UID/egress containment, +PostgreSQL, every crash boundary or live-provider qualification gates. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 4a906f093..ae9c19932 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"30330e58a09a00d5fb8e5747eee3916c1d638694a907b02872ff4fb277b7b776"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"6489f56bc090b6bc3487da3862b49d8f5f31a7d0e791c1801698d061b3f6bc53"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"28d82d50fe20aee6bbd782d9984f71d98574dbf124eb5fff1c79fff59be20e4b"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"e3e70818b59f314f1d1d718a62e2a320667f19e1a5ab78f7e51daaead76d9901"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"38c1d4ba50a3dfffc492aed1fec179a18602a98bd4cdf43c7f6639570ea43a24"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index e2dade671..583b6cb09 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -279,6 +279,31 @@ mod unix { #[arg(long)] approval: PathBuf, }, + /// Author a native content read call from private resource arguments. + /// No proof, approval, custody lease or provider entry is created. + EffectContentCall { + #[arg(long)] + state_dir: PathBuf, + /// Private JSON object containing only declared resource arguments. + #[arg(long)] + resource_arguments: PathBuf, + #[arg(long)] + operation: String, + #[arg(long)] + call_out: PathBuf, + }, + /// Author a native disclosure call from retained source provenance and + /// a private recipient proposal. Does not reserve or release content. + EffectDisclosureCall { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + target: PathBuf, + #[arg(long)] + operation: String, + #[arg(long)] + call_out: PathBuf, + }, /// Author the exact private call for an independently authorized /// recovery read. No proof, approval, reservation or entry is created. EffectRecoveryCall { @@ -4421,6 +4446,58 @@ mod unix { ) .await } + Command::EffectContentCall { + state_dir, + resource_arguments, + operation, + call_out, + } => { + if !call_out.is_absolute() { + return Err("gateway.state.invalid-path".into()); + } + let metadata = fs::symlink_metadata(&resource_arguments) + .map_err(|_| "gateway.state.invalid-path")?; + if !metadata.file_type().is_file() || metadata.permissions().mode() & 0o077 != 0 { + return Err("gateway.state.invalid-path".into()); + } + let arguments = Zeroizing::new(read_bounded(&resource_arguments, 65_536)?); + let engine = operator_engine(&state_dir).await?; + let call = engine + .content_authorization_call(&arguments, &operation) + .await + .map_err(|_| "gateway.acquisition.binding")?; + let bytes = Zeroizing::new(call.canonical_bytes().map_err(|_| "gateway.output")?); + private_file(&call_out, &bytes)?; + println!( + "private content call saved; native proof and exact approval still required" + ); + Ok(()) + } + Command::EffectDisclosureCall { + state_dir, + target, + operation, + call_out, + } => { + if !call_out.is_absolute() { + return Err("gateway.state.invalid-path".into()); + } + let proposal = read_disclosure_target(&target)?; + let engine = operator_engine(&state_dir).await?; + let target = proposal + .resolve(&engine) + .await + .map_err(|_| "gateway.disclosure.binding")?; + let call = engine + .disclosure_authorization_call(&target, &operation) + .map_err(|_| "gateway.disclosure.binding")?; + let bytes = Zeroizing::new(call.canonical_bytes().map_err(|_| "gateway.output")?); + private_file(&call_out, &bytes)?; + println!( + "private disclosure call saved; native proof and exact approval still required" + ); + Ok(()) + } Command::EffectRecoveryCall { state_dir, source_operation, diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index de7f3cbea..5351c251c 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1279,6 +1279,46 @@ impl GatewayEngine { .map_err(|_| not_entered("gateway.acquisition.binding")) } + /// Authors a private content call from a bounded, duplicate-free JSON object + /// of resource arguments and the installed connection. This is data only: + /// native proof, exact approval and final fenced entry remain required. + /// + /// # Errors + /// Refuses JSON over 65,536 bytes, duplicate members, nonobjects, unsupported + /// resource fields, invalid operation IDs and unavailable installation state. + pub async fn content_authorization_call( + &self, + resource_arguments: &[u8], + operation: &str, + ) -> Result { + let invalid = || not_entered("gateway.acquisition.binding"); + let arguments = crate::recipe::parse_provider_response(resource_arguments) + .and_then(|value| value.as_object().cloned()) + .ok_or_else(invalid)?; + let operation = crate::LogicalOperationId::parse(operation).map_err(|_| invalid())?; + let (loaded, _) = self.effect_compilation_inputs().await?; + crate::effect::ContentReadTarget::new(&self.recipe, loaded.record(), arguments) + .and_then(|target| target.authorization_call(&self.recipe, &operation)) + .map_err(|_| invalid()) + } + + /// Authors a private disclosure call from native retained-content provenance. + /// No socket authentication, reservation or delivery permission is created. + /// + /// # Errors + /// Refuses a mismatched recipe or invalid/reused source operation ID. + pub fn disclosure_authorization_call( + &self, + target: &crate::effect::DisclosureTarget, + operation: &str, + ) -> Result { + let invalid = || not_entered("gateway.disclosure.binding"); + let operation = crate::LogicalOperationId::parse(operation).map_err(|_| invalid())?; + target + .authorization_call(&self.recipe, &operation) + .map_err(|_| invalid()) + } + /// Loads only validated retained provenance and proposes a private recipient /// binding. This authenticates neither a live peer nor release authority. /// diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 8fc333ea8..0ac8629af 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -373,7 +373,7 @@ pub(crate) fn context_with_roots( depth, composition, &[RAW_KEY_V1], - &call(&Map::new())?, + &[call(&Map::new())?], ) } @@ -394,7 +394,7 @@ pub(crate) fn context_accepting( 1, fixture(CompositionRequirement::new(None, 1, 1, 1), "composition")?, methods, - &call(&Map::new())?, + &[call(&Map::new())?], ) } @@ -404,6 +404,15 @@ pub(crate) fn context_for_tool( observer: &PrincipalId, now: u64, tool: &McpToolCall, +) -> Result { + context_for_tools(root, observer, now, std::slice::from_ref(tool)) +} + +pub(crate) fn context_for_tools( + root: &Signer, + observer: &PrincipalId, + now: u64, + tools: &[McpToolCall], ) -> Result { context_for( &[root], @@ -413,7 +422,7 @@ pub(crate) fn context_for_tool( 1, fixture(CompositionRequirement::new(None, 1, 1, 1), "composition")?, &[RAW_KEY_V1], - tool, + tools, ) } @@ -429,8 +438,16 @@ fn context_for( depth: u16, composition: CompositionRequirement, methods: &[&str], - unbound: &McpToolCall, + tools: &[McpToolCall], ) -> Result { + let unbound = tools.first().ok_or(HarnessError::Fixture("tools"))?; + if tools.len() > 16 || tools.iter().any(|tool| tool.service() != unbound.service()) { + return Err(HarnessError::Fixture("tools")); + } + let permissions = tools + .iter() + .map(|tool| fixture(tool.permission(), "permission")) + .collect::, _>>()?; let configuration = match configuration { Some(value) => auths_model::VerifierConfigurationId::new(value), None => fixture(gateway_verifier_configuration(), "configuration")?, @@ -449,10 +466,7 @@ fn context_for( root.principal.clone(), vec![fixture(PrincipalMethodId::parse(RAW_KEY_V1), "method")?], vec![fixture(unbound.profile_ref(), "profile")?], - fixture( - PermissionSet::new(vec![fixture(unbound.permission(), "permission")?]), - "permissions", - )?, + fixture(PermissionSet::new(permissions.clone()), "permissions")?, vec![fixture( ResourceId::parse(&format!("mcp://{}/", unbound.service())), "namespace", diff --git a/product/runtime/auths-gateway/src/harness/authoring.rs b/product/runtime/auths-gateway/src/harness/authoring.rs index f1c9074ee..e6ab31398 100644 --- a/product/runtime/auths-gateway/src/harness/authoring.rs +++ b/product/runtime/auths-gateway/src/harness/authoring.rs @@ -111,3 +111,15 @@ pub fn tool_fixture(call: &McpToolCall, now: u64) -> Result Result, HarnessError> { + let root = Signer::new(0x11); + let observer = Signer::new(0x33); + let context = super::context_for_tools(&root, &observer.principal, now, calls)?; + fixture(encode_verifier_context(&context), "context") +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 8cbb8850c..39d9ed8a3 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "7c9d31da1ca994bda1fc4d8543c22f62f039448dfe0128c0f2dace699afc676f"; + "9661342487c8ed12da75845d812e3f5e0c9de6f29c6d9ad9e0542878eaf165da"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs new file mode 100644 index 000000000..76a5ef97d --- /dev/null +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -0,0 +1,966 @@ +//! Production daemon and client processes with native proof/approval and a real +//! counting HTTP double. Public fixed keys simulate reviewer/agent/recipient; +//! this is not human-presence, UID isolation, installed-language or PostgreSQL evidence. +#![cfg(all(unix, feature = "testkit-harness", feature = "loopback-provider"))] + +use auths_gateway::{ + CompiledRecipe, + app::AppDisclosureTarget, + effect::{ + CONTENT_READ_TOOL, DISCLOSURE_TOOL, EffectApprovalRequest, EffectPolicy, + UnixDisclosurePolicy, + }, + harness::authoring::{tool_fixture, tools_context}, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::TcpListener, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + process::{Child, Command, Output, Stdio}, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + thread::{self, JoinHandle}, + time::{Duration, Instant, SystemTime, UNIX_EPOCH}, +}; + +const SECRET: &[u8] = b"pat_public_content_journey_fixture"; +const CONTENT: &[u8] = b"PRIVATE-CONTENT-PROCESS-SENTINEL"; +const RECORD: &str = "recTEST0000000001"; + +fn private(path: &Path, bytes: &[u8]) { + std::fs::write(path, bytes).expect("write"); + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("mode"); +} +fn path(path: &Path) -> &str { + path.to_str().expect("path") +} +fn command(name: &str, args: &[(&str, &str)], flags: &[&str]) -> Command { + let mut command = Command::new(env!("CARGO_BIN_EXE_auths-gateway")); + command.arg(name); + for (key, value) in args { + command.arg(key).arg(value); + } + command + .args(flags) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + command +} +fn cli(name: &str, args: &[(&str, &str)], flags: &[&str], input: Option<&[u8]>) -> Output { + let mut child = command(name, args, flags).spawn().expect("CLI"); + if let Some(bytes) = input { + child + .stdin + .take() + .expect("stdin") + .write_all(bytes) + .expect("input"); + } else { + drop(child.stdin.take()); + } + let deadline = Instant::now() + Duration::from_secs(30); + while child.try_wait().expect("process status").is_none() { + if Instant::now() >= deadline { + child.kill().expect("kill timed out CLI"); + let output = child.wait_with_output().expect("output"); + panic!( + "{name} timeout: {}", + String::from_utf8_lossy(&output.stderr) + ); + } + thread::sleep(Duration::from_millis(10)); + } + child.wait_with_output().expect("output") +} +fn success(output: Output) -> Vec { + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + output.stdout +} +fn public(output: Output) -> Value { + for bytes in [&output.stdout, &output.stderr] { + for sentinel in [SECRET, CONTENT] { + assert!(!bytes.windows(sentinel.len()).any(|chunk| chunk == sentinel)); + } + } + serde_json::from_slice(&success(output)).expect("public native JSON") +} + +struct Provider { + port: u16, + calls: Arc>>, + stop: Arc, + join: Option>, +} +impl Provider { + fn start() -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("listener"); + let port = listener.local_addr().expect("address").port(); + listener.set_nonblocking(true).expect("nonblocking"); + let calls = Arc::new(Mutex::new(Vec::new())); + let stop = Arc::new(AtomicBool::new(false)); + let captured = calls.clone(); + let finished = stop.clone(); + let join = thread::spawn(move || { + let mut record = json!({"fields":{"DemoStatus":"Pending"}}); + while !finished.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(value) => value, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(5)); + continue; + } + Err(error) => panic!("accept: {error}"), + }; + stream + .set_nonblocking(false) + .expect("blocking accepted socket"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut request = Vec::new(); + while !request.ends_with(b"\r\n\r\n") { + assert!(request.len() < 16_384); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + request.push(byte[0]); + } + let header = String::from_utf8(request).expect("header"); + assert!(header.to_ascii_lowercase().contains(&format!( + "authorization: bearer {}\r\n", + String::from_utf8_lossy(SECRET) + ))); + let line = header.lines().next().expect("request").to_owned(); + let length = header + .lines() + .find_map(|line| { + let (key, value) = line.split_once(':')?; + key.eq_ignore_ascii_case("content-length") + .then(|| value.trim().parse::().expect("length")) + }) + .unwrap_or(0); + assert!(length <= 16_384); + let mut body = vec![0; length]; + stream.read_exact(&mut body).expect("body"); + captured.lock().expect("calls").push(line.clone()); + let (media, response) = if line + == format!("GET /documents/{RECORD}?format=text%2Fplain HTTP/1.1") + { + ("text/plain", CONTENT.to_vec()) + } else if line + == format!("PATCH /v0/appTEST0000000001/tblTEST0000000001/{RECORD} HTTP/1.1") + { + record = serde_json::from_slice(&body).expect("write JSON"); + assert_eq!(record["fields"]["DemoStatus"], "Approved"); + assert_eq!(record["fields"].as_object().expect("fields").len(), 2); + assert!(record["fields"]["auths_echo"].is_string()); + ("application/json", body) + } else if line + == format!("GET /v0/appTEST0000000001/tblTEST0000000001/{RECORD} HTTP/1.1") + { + ( + "application/json", + serde_json::to_vec(&record).expect("record"), + ) + } else { + panic!("unexpected provider request: {line}"); + }; + let headers = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {media}\r\nConnection: close\r\nContent-Length: {}\r\n\r\n", + response.len() + ); + stream.write_all(headers.as_bytes()).expect("headers"); + stream.write_all(&response).expect("response"); + } + }); + Self { + port, + calls, + stop, + join: Some(join), + } + } + fn calls(&self) -> Vec { + self.calls.lock().expect("calls").clone() + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(join) = self.join.take() { + let result = join.join(); + if !thread::panicking() { + result.expect("provider"); + } + } + } +} +struct Daemon(Child); +impl Daemon { + fn start(state: &Path, socket: &Path, port: u16) -> Self { + let child = command( + "serve", + &[ + ("--state-dir", path(state)), + ("--app-socket", path(socket)), + ("--loopback-provider", &port.to_string()), + ], + &[], + ) + .spawn() + .expect("daemon"); + let mut daemon = Self(child); + let deadline = Instant::now() + Duration::from_secs(10); + while !socket.exists() { + assert!( + daemon.0.try_wait().expect("daemon status").is_none(), + "daemon exited" + ); + assert!(Instant::now() < deadline, "daemon startup timeout"); + thread::sleep(Duration::from_millis(10)); + } + daemon + } +} +impl Drop for Daemon { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} +struct Approved { + proof: PathBuf, + action: PathBuf, + approval: PathBuf, + binding: PathBuf, +} +impl Approved { + fn execute( + &self, + name: &str, + socket: &Path, + extra: &[(&str, &str)], + flags: &[&str], + input: Option<&[u8]>, + ) -> Output { + let mut args = vec![ + ("--app-socket", path(socket)), + ("--proof", path(&self.proof)), + ("--action", path(&self.action)), + ("--approval", path(&self.approval)), + ]; + args.extend_from_slice(extra); + cli(name, &args, flags, input) + } +} +#[allow( + clippy::too_many_arguments, + reason = "explicit native review inputs in a process fixture" +)] +fn approve( + state: &Path, + call: &McpToolCall, + operation: &str, + now: u64, + key: &SigningKey, + extra: &[(&str, &str)], + flags: &[&str], +) -> Approved { + let fixture = tool_fixture(call, now).expect("native signed authority"); + let proof = state.join(format!("{operation}.proof")); + let action = state.join(format!("{operation}.action")); + let approval = state.join(format!("{operation}.approval")); + let binding = state.join(format!("{operation}.binding")); + let request = state.join(format!("{operation}.request")); + private(&proof, &fixture.proof); + private(&action, &fixture.action); + let start = (now - 1).to_string(); + let end = (now + 300).to_string(); + let mut args = vec![ + ("--state-dir", path(state)), + ("--proof", path(&proof)), + ("--action", path(&action)), + ("--not-before", &start), + ("--expires-at", &end), + ("--request-out", path(&request)), + ("--binding-out", path(&binding)), + ]; + args.extend_from_slice(extra); + let review: Value = + serde_json::from_slice(&success(cli("effect-review", &args, flags, None))).expect("review"); + assert!( + !review["literal_review"] + .as_str() + .expect("literal") + .is_empty() + ); + let signing = + EffectApprovalRequest::from_private_bytes(&std::fs::read(&request).expect("request")) + .expect("native signing request"); + let message = signing.signing_message().expect("message"); + assert_eq!(review["signing_message_hex"], hex::encode(&message)); + private( + &approval, + &success(cli( + "effect-approval", + &[ + ("--request", path(&request)), + ( + "--signature-hex", + &hex::encode(key.sign(&message).to_bytes()), + ), + ], + &[], + None, + )), + ); + Approved { + proof, + action, + approval, + binding, + } +} +fn call_file(path: &Path) -> McpToolCall { + assert_eq!( + std::fs::metadata(path) + .expect("call metadata") + .permissions() + .mode() + & 0o777, + 0o600 + ); + McpToolCall::from_canonical_bytes(&std::fs::read(path).expect("call")).expect("native call") +} +fn history(socket: &Path, operation: &str) -> Value { + public(cli( + "content-history", + &[("--app-socket", path(socket)), ("--operation", operation)], + &[], + None, + )) +} + +/// Subprocess fixture: uses the shipping native recipient client, retains exact +/// ACK evidence, then waits without sending it so the parent can crash both peers. +#[test] +fn recipient_without_ack_process() { + let Some(root) = std::env::var_os("AUTHS_CONTENT_RECIPIENT_FIXTURE") else { + return; + }; + let root = PathBuf::from(root); + let state = root.join("state"); + use base64ct::{Base64UrlUnpadded, Encoding as _}; + let request = auths_gateway::app::AppDisclosure { + schema: auths_gateway::app::APP_DISCLOSURE_SCHEMA.to_owned(), + target: serde_json::from_slice(&std::fs::read(root.join("target.json")).expect("target")) + .expect("target JSON"), + submission: auths_gateway::app::AppSubmission { + schema: auths_gateway::app::APP_REQUEST_SCHEMA.to_owned(), + proof_b64: Base64UrlUnpadded::encode_string( + &std::fs::read(state.join("lost-ack.proof")).expect("proof"), + ), + action_b64: Base64UrlUnpadded::encode_string( + &std::fs::read(state.join("lost-ack.action")).expect("action"), + ), + approval_b64: Base64UrlUnpadded::encode_string( + &std::fs::read(state.join("lost-ack.approval")).expect("approval"), + ), + }, + }; + let binding = auths_gateway::effect::EffectBinding::from_private_bytes( + &std::fs::read(state.join("lost-ack.binding")).expect("binding"), + ) + .expect("native binding"); + tokio::runtime::Runtime::new() + .expect("runtime") + .block_on(async { + let stream = tokio::net::UnixStream::connect(root.join("app.sock")) + .await + .expect("app socket"); + let key = SigningKey::from_bytes(&[31; 32]); + let received = auths_gateway::app::receive_content_disclosure( + stream, + &request, + &binding, + CONTENT.len() as u64, + &key, + ) + .await + .expect("native recipient"); + let auths_gateway::app::AppDisclosureReception::Received(received) = received else { + panic!("expected delivery"); + }; + assert_eq!(received.content(), CONTENT); + private(&root.join("lost-content"), received.content()); + private( + &root.join("lost-evidence"), + &received + .acknowledgement(&key) + .expect("ACK") + .to_private_bytes() + .expect("canonical ACK"), + ); + for name in ["lost-content", "lost-evidence"] { + std::fs::File::open(root.join(name)) + .expect("file") + .sync_all() + .expect("sync"); + } + std::fs::File::open(&root) + .expect("directory") + .sync_all() + .expect("sync"); + private( + &root.join("recipient-ready"), + b"received-and-ack-retained-not-sent", + ); + tokio::time::sleep(Duration::from_secs(15)).await; + drop(received); + }); +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "ordered real process journey and evidence assertions" +)] +fn native_content_process_journey_fixture_is_current() { + let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let corpus: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("hostile-recipes-v2.json")).expect("recipes"), + ) + .expect("JSON"); + let mut source = corpus["bases"]["airtable"]["recipe"].clone(); + source["content"] = json!({"schema":"auths.gateway-content-read/1", "resource_field":"record_id", + "path":[{"kind":"fixed","value":"documents"},{"kind":"field","name":"record_id"}], + "query":[{"name":"format","value":"text/plain"}], "projection":{"kind":"utf8"}, + "maximum_response_bytes":1024,"maximum_content_bytes":64}); + let source = serde_json::to_vec(&source).expect("source"); + let lock = serde_json::to_vec(&corpus["bases"]["airtable"]["lock"]).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("recipe"); + let service = corpus["bases"]["airtable"]["recipe"]["service"] + .as_str() + .expect("service"); + let mutation_tool = corpus["bases"]["airtable"]["recipe"]["tool"] + .as_str() + .expect("tool"); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock") + .as_secs(); + let calls = [ + CONTENT_READ_TOOL, + DISCLOSURE_TOOL, + mutation_tool, + "auths_gateway_recovery_read_v1", + ] + .map(|tool| McpToolCall::new(service, tool, serde_json::Map::new()).expect("tool")); + let trust = tools_context(&calls, now).expect("explicit multi-tool test trust"); + let reviewer = SigningKey::from_bytes(&[29; 32]); + let recipient = SigningKey::from_bytes(&[31; 32]); + let policy = EffectPolicy::new( + "content-process-journey".to_owned(), + 1, + reviewer.verifying_key().to_bytes(), + ) + .expect("policy"); + let directory = tempfile::Builder::new() + .prefix("ap74-") + .tempdir_in("/tmp") + .expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical directory"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let state = root.join("state"); + let socket = root.join("app.sock"); + for (name, bytes) in [ + ("recipe", source), + ("lock", lock), + ("trust", trust), + ( + "policy", + policy.to_private_bytes().expect("policy").to_vec(), + ), + ] { + private(&root.join(name), &bytes); + } + let provider = Provider::start(); + success(cli( + "install", + &[ + ("--state-dir", path(&state)), + ("--recipe", path(&root.join("recipe"))), + ("--profile-lock", path(&root.join("lock"))), + ("--trusted-context", path(&root.join("trust"))), + ("--effect-policy", path(&root.join("policy"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "airtable"), + ("--alias", "journey"), + ("--account-label", "public-fixture"), + ], + &["--credential-stdin"], + Some(SECRET), + )); + let args = root.join("resource.json"); + let call = root.join("read.call"); + private( + &args, + &serde_json::to_vec(&json!({"record_id":RECORD})).expect("arguments"), + ); + success(cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&args)), + ("--operation", "read"), + ("--call-out", path(&call)), + ], + &[], + None, + )); + let read = approve( + &state, + &call_file(&call), + "read", + now, + &reviewer, + &[], + &["--content"], + ); + for invalid in [ + format!(r#"{{"record_id":"{RECORD}","record_id":"other"}}"#), + format!(r#"{{"record_id":"{RECORD}","url":"https://evil.example"}}"#), + "[]".to_owned(), + " ".repeat(65_537), + ] { + private(&args, invalid.as_bytes()); + let out = root.join("invalid.call"); + assert!( + !cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&args)), + ("--operation", "bad"), + ("--call-out", path(&out)) + ], + &[], + None + ) + .status + .success() + ); + assert!(!out.exists()); + } + let mut at_limit = serde_json::to_vec(&json!({"record_id":RECORD})).expect("arguments"); + at_limit.resize(65_536, b' '); + private(&args, &at_limit); + let boundary_call = root.join("boundary.call"); + success(cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&args)), + ("--operation", "read"), + ("--call-out", path(&boundary_call)), + ], + &[], + None, + )); + assert_eq!( + std::fs::read(&boundary_call).expect("boundary call"), + std::fs::read(&call).expect("original call") + ); + assert!( + !cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&args)), + ("--operation", "replacement"), + ("--call-out", path(&call)) + ], + &[], + None + ) + .status + .success() + ); + assert_eq!( + std::fs::read(&boundary_call).expect("boundary call"), + std::fs::read(&call).expect("unchanged call") + ); + assert!( + provider.calls().is_empty(), + "authoring and review have no provider authority" + ); + let mut daemon = Daemon::start(&state, &socket, provider.port); + let acquired = public(read.execute("content-acquire", &socket, &[], &[], None)); + assert_eq!( + acquired["history"]["snapshot"]["stage"], "response-recorded", + "{acquired}" + ); + assert_eq!(provider.calls().len(), 1); + assert_eq!( + public(read.execute("content-acquire", &socket, &[], &[], None)), + acquired + ); + let uid = rustix::process::geteuid().as_raw(); + let target = root.join("target.json"); + private( + &target, + &serde_json::to_vec(&AppDisclosureTarget { + source_operation: "read".to_owned(), + recipient_key: recipient.verifying_key().to_bytes(), + channel: UnixDisclosurePolicy::new(uid, uid, [5; 32]), + delivery_instance: [6; 32], + }) + .expect("target"), + ); + let release_call = root.join("release.call"); + success(cli( + "effect-disclosure-call", + &[ + ("--state-dir", path(&state)), + ("--target", path(&target)), + ("--operation", "release"), + ("--call-out", path(&release_call)), + ], + &[], + None, + )); + let release = approve( + &state, + &call_file(&release_call), + "release", + now, + &reviewer, + &[("--disclosure", path(&target))], + &[], + ); + let content = root.join("content"); + let ack = root.join("ack"); + let length = CONTENT.len().to_string(); + let receive = |content: &Path, ack: &Path| { + release.execute( + "disclosure-receive", + &socket, + &[ + ("--target", path(&target)), + ("--expected-binding", path(&release.binding)), + ("--expected-bytes", &length), + ("--content-out", path(content)), + ("--acknowledgement-out", path(ack)), + ], + &["--recipient-seed-stdin"], + Some(&[31; 32]), + ) + }; + assert_eq!( + public(receive(&content, &ack))["outcome"], + "recipient-ack-sent" + ); + assert_eq!(std::fs::read(&content).expect("received bytes"), CONTENT); + for path in [&content, &ack] { + assert_eq!( + std::fs::metadata(path) + .expect("private file") + .permissions() + .mode() + & 0o777, + 0o600 + ); + } + let deadline = Instant::now() + Duration::from_secs(5); + let disclosed = loop { + let value = history(&socket, "release"); + if value["history"]["snapshot"]["stage"] == "acknowledged" { + break value; + } + assert!( + Instant::now() < deadline, + "ACK was not durably recorded: {value}" + ); + thread::sleep(Duration::from_millis(10)); + }; + assert_eq!(provider.calls().len(), 1, "disclosure never refetches"); + // A real daemon restart must retain both journals and must not remint a send. + drop(daemon); + std::fs::remove_file(&socket).expect("old app socket"); + std::fs::remove_file(state.join("admin.sock")).expect("old admin socket"); + daemon = Daemon::start(&state, &socket, provider.port); + assert_eq!(history(&socket, "read"), acquired); + assert_eq!(history(&socket, "release"), disclosed); + let replay_content = root.join("replay-content"); + let replay_ack = root.join("replay-ack"); + assert_eq!(public(receive(&replay_content, &replay_ack)), disclosed); + assert!(!replay_content.exists() && !replay_ack.exists()); + assert_eq!( + public(cli( + "disclosure-acknowledge", + &[ + ("--app-socket", path(&socket)), + ("--operation", "release"), + ("--acknowledgement", path(&ack)) + ], + &[], + None + )), + disclosed + ); + // The recipient confirms actual receipt privately but never sends its ACK. + // Crash the daemon while it waits, then crash the separate recipient process. + let loss_call = root.join("loss.call"); + success(cli( + "effect-disclosure-call", + &[ + ("--state-dir", path(&state)), + ("--target", path(&target)), + ("--operation", "lost-ack"), + ("--call-out", path(&loss_call)), + ], + &[], + None, + )); + let lost = approve( + &state, + &call_file(&loss_call), + "lost-ack", + now, + &reviewer, + &[("--disclosure", path(&target))], + &[], + ); + let mut receiver = Command::new(std::env::current_exe().expect("test executable")) + .args(["--exact", "recipient_without_ack_process", "--nocapture"]) + .env("AUTHS_CONTENT_RECIPIENT_FIXTURE", &root) + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("recipient process"); + let deadline = Instant::now() + Duration::from_secs(10); + while !root.join("recipient-ready").exists() { + if receiver.try_wait().expect("recipient status").is_some() || Instant::now() >= deadline { + let _ = receiver.kill(); + let output = receiver.wait_with_output().expect("recipient output"); + panic!( + "recipient did not receive: {}", + String::from_utf8_lossy(&output.stderr) + ); + } + thread::sleep(Duration::from_millis(5)); + } + drop(daemon); + receiver.kill().expect("crash recipient"); + receiver.wait().expect("wait recipient"); + std::fs::remove_file(&socket).expect("old app socket"); + std::fs::remove_file(state.join("admin.sock")).expect("old admin socket"); + daemon = Daemon::start(&state, &socket, provider.port); + let unknown = history(&socket, "lost-ack"); + assert_eq!(unknown["history"]["snapshot"]["stage"], "unknown"); + assert_eq!(unknown["history"]["snapshot"]["reserved_deliveries"], 1); + assert_eq!( + unknown["history"]["snapshot"]["reserved_bytes"], + CONTENT.len() + ); + let loss_retry_content = root.join("loss-retry-content"); + let loss_retry_ack = root.join("loss-retry-ack"); + let loss_replay = public(lost.execute( + "disclosure-receive", + &socket, + &[ + ("--target", path(&target)), + ("--expected-binding", path(&lost.binding)), + ("--expected-bytes", &length), + ("--content-out", path(&loss_retry_content)), + ("--acknowledgement-out", path(&loss_retry_ack)), + ], + &["--recipient-seed-stdin"], + Some(&[31; 32]), + )); + assert_eq!(loss_replay, unknown); + assert!(!loss_retry_content.exists() && !loss_retry_ack.exists()); + let late_ack = public(cli( + "disclosure-acknowledge", + &[ + ("--app-socket", path(&socket)), + ("--operation", "lost-ack"), + ("--acknowledgement", path(&root.join("lost-evidence"))), + ], + &[], + None, + )); + assert_eq!(late_ack["history"]["snapshot"]["stage"], "acknowledged"); + assert_eq!( + late_ack["history"]["snapshot"]["reserved_bytes"], + CONTENT.len() + ); + assert_eq!( + public(cli( + "disclosure-acknowledge", + &[ + ("--app-socket", path(&socket)), + ("--operation", "lost-ack"), + ("--acknowledgement", path(&root.join("lost-evidence"))) + ], + &[], + None + )), + late_ack + ); + assert_eq!( + provider.calls().len(), + 1, + "lost ACK cannot cause source refetch" + ); + let write_call = McpToolCall::new( + service, + mutation_tool, + json!({"operation_id":"write", + "operator_namespace":recipe.namespace().as_str(),"recipe_digest":recipe.digest_hex(), + "record_id":RECORD,"replacement":"Approved"}) + .as_object() + .expect("arguments") + .clone(), + ) + .expect("write call"); + let write = approve(&state, &write_call, "write", now, &reviewer, &[], &[]); + let written = public(write.execute("submit", &socket, &[], &[], None)); + assert_eq!(written["outcome"], "response-recorded", "{written}"); + assert_eq!(provider.calls().len(), 2); + let recovery_call = McpToolCall::from_canonical_bytes(&success(cli( + "effect-recovery-call", + &[ + ("--state-dir", path(&state)), + ("--source-operation", "write"), + ("--recovery-operation", "observe"), + ], + &[], + None, + ))) + .expect("recovery call"); + let recovery = approve( + &state, + &recovery_call, + "observe", + now, + &reviewer, + &[("--recovery-of", "write")], + &[], + ); + let mut observed = public(recovery.execute( + "app-recover", + &socket, + &[("--source-operation", "write")], + &[], + None, + )); + assert_eq!(observed["outcome"], "recovery-report", "{observed}"); + assert!( + observed["report"]["source"]["observation_match"].is_null(), + "{observed}" + ); + assert_eq!( + observed["report"]["source"]["provider_linked"], true, + "{observed}" + ); + assert_eq!(observed["report"]["disposition"], "recorded"); + assert_eq!(provider.calls().len(), 3); + public(write.execute("submit", &socket, &[], &[], None)); + public(recovery.execute( + "app-recover", + &socket, + &[("--source-operation", "write")], + &[], + None, + )); + assert_eq!( + provider.calls().len(), + 3, + "history never authorizes resend/refetch" + ); + // Author one more release before independently committing disable. + let revoked_call = root.join("revoked.call"); + success(cli( + "effect-disclosure-call", + &[ + ("--state-dir", path(&state)), + ("--target", path(&target)), + ("--operation", "revoked"), + ("--call-out", path(&revoked_call)), + ], + &[], + None, + )); + let revoked = approve( + &state, + &call_file(&revoked_call), + "revoked", + now, + &reviewer, + &[("--disclosure", path(&target))], + &[], + ); + success(cli( + "disable", + &[("--state-dir", path(&state))], + &["--store-only"], + None, + )); + let refused_content = root.join("refused-content"); + let refused_ack = root.join("refused-ack"); + let refused = public(revoked.execute( + "disclosure-receive", + &socket, + &[ + ("--target", path(&target)), + ("--expected-binding", path(&revoked.binding)), + ("--expected-bytes", &length), + ("--content-out", path(&refused_content)), + ("--acknowledgement-out", path(&refused_ack)), + ], + &["--recipient-seed-stdin"], + Some(&[31; 32]), + )); + assert_eq!(refused["outcome"], "refused"); + assert!(!refused_content.exists() && !refused_ack.exists()); + assert_eq!( + history(&socket, "release"), + disclosed, + "disable does not erase legitimate evidence" + ); + assert_eq!(provider.calls().len(), 3); + drop(daemon); + // The real receipt time was checked above; exclude ambient time from the frozen artifact. + assert!( + observed["report"]["source"]["recovery_received_at"] + .as_u64() + .is_some_and(|time| time >= now) + ); + observed["report"]["source"]["recovery_received_at"] = json!("actual-runtime-time-checked"); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.content-process-journey/1", + "scope":"production CLI and daemon processes, native proofs/exact approval, real file custody/journal and counting loopback HTTP; public fixed signing keys simulate reviewer, actor and recipient; no human presence, UID containment, installed language package, power loss or PostgreSQL claim", + "provider_requests":provider.calls(),"acquisition":acquired,"disclosure":disclosed,"mutation":written,"observation":observed, + "revoked_disclosure":refused,"restart_replay_no_redelivery":true, "crash_after_receipt_before_ack":unknown, "late_ack_after_crash":late_ack,"late_ack_idempotent":true, + "private_recipient_outputs_mode": "0600", "resource_authoring_rejects_duplicate_extra_nonobject_oversize":true, "resource_limit_accepted_and_existing_call_not_overwritten":true, + "public_results_exclude_sentinel_content_and_credential":true})).expect("artifact"); + let output = fixtures.join("content-process-journey.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &artifact).expect("write fixture"); + } + assert_eq!(std::fs::read(output).expect("fixture"), artifact); +} From cfaa8596079920c5d69786684e3fab47fe73c225 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:11:04 +0000 Subject: [PATCH 057/136] feat(gateway)!: support content-only recipe installations BREAKING CHANGE: recipe review method and mutation recovery APIs return Option for content-only recipes. --- .../gateway/content-only/profile.lock.json | 35 +++ .../fixtures/gateway/content-only/recipe.json | 48 ++++ .../fixtures/gateway/content-only/review.json | 69 ++++++ .../gateway/read-only-process-journey.json | 123 +++++++++ .../fixtures/gateway/read-only-recipe.json | 196 +++++++++++++++ compliance.toml | 4 + ...017-bound-effect-and-recovery-ownership.md | 27 ++ .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 17 ++ docs/plans/0074-implementation-status.md | 47 +++- .../0009-bound-effect-and-recovery.md | 20 ++ ...ound-effects-and-recovery-state-machine.md | 22 ++ .../corpus/target_gateway_recipe/content-only | Bin 0 -> 1975 bytes .../fuzz_targets/target_gateway_recipe.rs | 6 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/audit.rs | 5 +- product/runtime/auths-gateway/src/recipe.rs | 45 +++- .../auths-gateway/src/recipe/content.rs | 4 + .../runtime/auths-gateway/src/recipe/lower.rs | 39 +-- .../auths-gateway/src/recipe/review.rs | 68 ++--- .../auths-gateway/src/recipe/runtime.rs | 2 +- .../auths-gateway/src/recipe/source.rs | 3 +- .../runtime/auths-gateway/src/recipe/tests.rs | 167 ++++++++++++- .../auths-gateway/src/recipe/validate.rs | 36 ++- .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/content_journey.rs | 234 ++++++++++++++++++ 25 files changed, 1145 insertions(+), 76 deletions(-) create mode 100644 bindings/fixtures/gateway/content-only/profile.lock.json create mode 100644 bindings/fixtures/gateway/content-only/recipe.json create mode 100644 bindings/fixtures/gateway/content-only/review.json create mode 100644 bindings/fixtures/gateway/read-only-process-journey.json create mode 100644 bindings/fixtures/gateway/read-only-recipe.json create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/content-only diff --git a/bindings/fixtures/gateway/content-only/profile.lock.json b/bindings/fixtures/gateway/content-only/profile.lock.json new file mode 100644 index 000000000..a0652d8e7 --- /dev/null +++ b/bindings/fixtures/gateway/content-only/profile.lock.json @@ -0,0 +1,35 @@ +{ + "command_schema": { + "fields": { + "operation_id": { + "kind": "string", + "maximum": 128, + "minimum": 1 + }, + "operator_namespace": { + "type": "enum", + "variants": [ + "airtable-demo" + ] + }, + "recipe_digest": { + "kind": "string", + "maximum": 64, + "minimum": 64 + }, + "record_id": { + "kind": "string", + "maximum": 43, + "minimum": 17 + } + }, + "kind": "object" + }, + "generator_format": 2, + "profile": "airtable-gateway-record-update", + "schema": "auths.self-hosted-profile-lock/1", + "schema_digest": "3dba7f501f17177fb10cf5562d01e09ee43de37e3546e37c8c5d59087eb05076", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "version": 1 +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/content-only/recipe.json b/bindings/fixtures/gateway/content-only/recipe.json new file mode 100644 index 000000000..164333307 --- /dev/null +++ b/bindings/fixtures/gateway/content-only/recipe.json @@ -0,0 +1,48 @@ +{ + "schema": "auths.gateway-recipe-source/3", + "profile_schema_digest": "3dba7f501f17177fb10cf5562d01e09ee43de37e3546e37c8c5d59087eb05076", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "operator_namespace": "airtable-demo", + "credential": { + "kind": "bearer" + }, + "origin": "https://api.airtable.com", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + } + } + }, + "content": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "documents" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [ + { + "name": "format", + "value": "text/plain" + } + ], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 64 + } +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/content-only/review.json b/bindings/fixtures/gateway/content-only/review.json new file mode 100644 index 000000000..da7774c24 --- /dev/null +++ b/bindings/fixtures/gateway/content-only/review.json @@ -0,0 +1,69 @@ +{ + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + } + } + }, + "digest": "6d29e30719ce5210c214b99117d2e8bcc0bf93a07688cff2e303a07e6cc663a9", + "operator_namespace": "airtable-demo", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "origin": "https://api.airtable.com", + "method": null, + "path": [], + "credential": { + "kind": "bearer" + }, + "maximum_body_bytes": 0, + "has_observation": false, + "sends_idempotency_key": false, + "echo": null, + "preconditions": null, + "recovery": null, + "write_is_conditional": false, + "provider_headers": null, + "credential_guard": null, + "content_acquisition": { + "declaration": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "documents" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [ + { + "name": "format", + "value": "text/plain" + } + ], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 64 + }, + "method": "GET", + "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry" + }, + "idempotency": null, + "observation": null, + "pre_entry": null, + "account_scope": null, + "relative_ceiling": null, + "bounds": null +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/read-only-process-journey.json b/bindings/fixtures/gateway/read-only-process-journey.json new file mode 100644 index 000000000..b6ce843d3 --- /dev/null +++ b/bindings/fixtures/gateway/read-only-process-journey.json @@ -0,0 +1,123 @@ +{ + "schema": "auths.read-only-process-journey/1", + "scope": "production local CLI/daemon processes, file custody/journal, native read/release-only grants and public fixed test approval keys; no Google metadata, UI, language package, hostile UID isolation or PostgreSQL claim", + "recipe_digest": "6d29e30719ce5210c214b99117d2e8bcc0bf93a07688cff2e303a07e6cc663a9", + "operator_review": { + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + } + } + }, + "digest": "6d29e30719ce5210c214b99117d2e8bcc0bf93a07688cff2e303a07e6cc663a9", + "operator_namespace": "airtable-demo", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "origin": "https://api.airtable.com", + "method": null, + "path": [], + "credential": { + "kind": "bearer" + }, + "maximum_body_bytes": 0, + "has_observation": false, + "sends_idempotency_key": false, + "echo": null, + "preconditions": null, + "recovery": null, + "write_is_conditional": false, + "provider_headers": null, + "credential_guard": null, + "content_acquisition": { + "declaration": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "documents" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [ + { + "name": "format", + "value": "text/plain" + } + ], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 64 + }, + "method": "GET", + "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry" + }, + "idempotency": null, + "observation": null, + "pre_entry": null, + "account_scope": null, + "relative_ceiling": null, + "bounds": null, + "recipe_digest": "6d29e30719ce5210c214b99117d2e8bcc0bf93a07688cff2e303a07e6cc663a9", + "verifier_configuration": "4438003caabb21ef7848726c143782b3cb4c26adac7f609c70b23917613ef035", + "profile_policy": "mcp-arguments-v1", + "bounded_policy_extension": "bounded-policy-commitment-v1" + }, + "provider_requests": [ + "GET /documents/recTEST0000000001?format=text%2Fplain HTTP/1.1" + ], + "mutation_refusal": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + }, + "mutation_review_refused": true, + "acquisition": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 32, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 32 + } + } + } + }, + "disclosure": { + "outcome": "history", + "history": { + "kind": "disclosure", + "snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 32, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + }, + "content_source_cannot_be_mutation_recovery_source": true, + "no_mutation_permission_or_plan_installed": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/read-only-recipe.json b/bindings/fixtures/gateway/read-only-recipe.json new file mode 100644 index 000000000..3e3097896 --- /dev/null +++ b/bindings/fixtures/gateway/read-only-recipe.json @@ -0,0 +1,196 @@ +{ + "schema": "auths.read-only-recipe/1", + "source": { + "schema": "auths.gateway-recipe-source/3", + "profile_schema_digest": "3dba7f501f17177fb10cf5562d01e09ee43de37e3546e37c8c5d59087eb05076", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "operator_namespace": "airtable-demo", + "credential": { + "kind": "bearer" + }, + "origin": "https://api.airtable.com", + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + } + } + }, + "content": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "documents" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [ + { + "name": "format", + "value": "text/plain" + } + ], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 64 + } + }, + "lock": { + "command_schema": { + "fields": { + "operation_id": { + "kind": "string", + "maximum": 128, + "minimum": 1 + }, + "operator_namespace": { + "type": "enum", + "variants": [ + "airtable-demo" + ] + }, + "recipe_digest": { + "kind": "string", + "maximum": 64, + "minimum": 64 + }, + "record_id": { + "kind": "string", + "maximum": 43, + "minimum": 17 + } + }, + "kind": "object" + }, + "generator_format": 2, + "profile": "airtable-gateway-record-update", + "schema": "auths.self-hosted-profile-lock/1", + "schema_digest": "3dba7f501f17177fb10cf5562d01e09ee43de37e3546e37c8c5d59087eb05076", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "version": 1 + }, + "review": { + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + } + } + }, + "digest": "6d29e30719ce5210c214b99117d2e8bcc0bf93a07688cff2e303a07e6cc663a9", + "operator_namespace": "airtable-demo", + "service": "airtable-gateway-demo", + "tool": "auths_gateway_content_read_v1", + "origin": "https://api.airtable.com", + "method": null, + "path": [], + "credential": { + "kind": "bearer" + }, + "maximum_body_bytes": 0, + "has_observation": false, + "sends_idempotency_key": false, + "echo": null, + "preconditions": null, + "recovery": null, + "write_is_conditional": false, + "provider_headers": null, + "credential_guard": null, + "content_acquisition": { + "declaration": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "documents" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [ + { + "name": "format", + "value": "text/plain" + } + ], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 64 + }, + "method": "GET", + "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry" + }, + "idempotency": null, + "observation": null, + "pre_entry": null, + "account_scope": null, + "relative_ceiling": null, + "bounds": null + }, + "negative_sources": [ + { + "case": "observation", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "echo", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "pre_entry", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "preconditions", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "relative_ceiling", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "bounds", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "missing-or-wrong-content", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "missing-or-wrong-tool", + "code": "gateway.recipe.invalid-source" + }, + { + "case": "write-with-reserved-read-tool", + "code": "gateway.recipe.invalid-source" + } + ], + "mutation_plan_absent": true, + "mutation_construction_refused": true, + "scope": "native compilation and closed request construction; process transport and installed binding evidence are separate" +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index f0e4eb08e..125b2dc83 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1619,6 +1619,10 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] +content-only-installation = [ + "product/runtime/auths-gateway/src/recipe/tests.rs#native_read_only_recipe_fixture_is_current", + "product/runtime/auths-gateway/tests/content_journey.rs#native_read_only_process_journey_fixture_is_current", +] content-process-composition = [ "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_journey_fixture_is_current", ] diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 4dc09864e..d6b5e7adf 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1065,3 +1065,30 @@ histories use the shared file adapter and public fixed test signing keys. Authenticated UI, installed language packages, complete fault/concurrency tests, PostgreSQL and hostile process isolation remain distinct incomplete obligations. No production transition predicate or wire schema changed in this increment. + + +## Standalone read-only recipe decision + +A source `/3` with no `write` declaration is a content-only installation. It must +name the reserved native content tool and declare content; mutation-specific +observation, echo, pre-entry, precondition, relative-ceiling and spend-sum fields +are refused. Its profile lock names only the existing binding fields, resource +and optional account field. Existing credential guards and registered headers +retain their owners. No fake write URL, body or mutation permission is installed. + +The compiler lowers this into a closed `ContentOnly` execution alternative, +which contains no `WritePlan`. Mutation request construction rejects that +alternative before constructing a request. Content acquisition, candidate reads, +release, approval and journaling remain existing native paths. Wire parsing may +represent an absent write, but one compiler validates the relation and the sealed +compiled execution kind is authoritative. This is an extension of source `/3`, +not an old-schema reader or parallel runtime mode. Existing mutation canonical +bytes and semantics must stay unchanged. Operator review represents no mutation +with null method/mutation recovery, empty write path and zero write-body bound, while rendering +the complete declared content GET separately. No `GET` is added to write methods. + +The required evidence is a bounded source/lock negative corpus, native +mutation-refusal and real read-only install/acquisition/disclosure process +journey. Google metadata semantics, token refresh custody and AP070's Python +owner removal remain separate required cutovers; supporting a content-only recipe +does not establish those provider capabilities or their equivalence. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index b5a9e752e..f6d19fd56 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -428,3 +428,20 @@ ACK-loss crash/reopen/no-redelivery/late ACK, an exact write and independent observation, plus separate-process disable before release. Public fixed keys simulate signing. This establishes neither human presence, installed language binding integration, hostile UID/egress isolation nor PostgreSQL durability. + + +A standalone content installation can omit `write` from recipe source `/3`. +Its source and profile lock must name `auths_gateway_content_read_v1`, and the +source must declare `content`. Include only binding/resource/account fields; +mutation observation, echo, pre-entry, preconditions, relative ceilings and spend +bounds are refused. The native review explicitly shows no mutation method or +recovery capability, an empty write path and zero body allowance, alongside the +content GET declaration. Do not interpret its null method as an unspecified +method or substitute a default write. `RecipeReview::method` and mutation +`recovery` return `Option` in Rust; JSON consumers receive native null values. + +The generated `bindings/fixtures/gateway/content-only/` files are a synthetic +local recipe example. `read-only-process-journey.json` proves real installation, +read-only authority, mutation refusal, one GET and separate recipient disclosure. +It is not a Google integration or a replacement for AP070's pending metadata, +credential-custody and Python state-owner cutover. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 995761695..c89e58cff 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1433,6 +1433,49 @@ closure regeneration passed after that correction (one artifact-generation test) and required hosted evidence remain outstanding. No broad local gate or CI observation was performed. +## Standalone content-only installation checkpoint + +- Based on pushed `c80902ab`, the previous process-composition increment. This + continuation implements the missing read-only installation needed before AP070 + can move its managed reads to the native owner. +- Source `/3` may omit `write` only with the reserved native content tool and a + valid required content capability. The compiler rejects mutation observation, + echo, pre-entry/preconditions, relative ceiling and spend bounds in that case. + Its lock admits binding/resource/account fields only; existing credential and + registered-header validation remain authoritative. +- Lowering now has a closed `Mutation(Box) | ContentOnly` alternative. + ContentOnly has no write plan, and mutation construction refuses it before + request/custody/transport. Native acquisition, disclosure, candidate credential + checks and the journal/reducer are reused. No dummy write URL/body, GET write + method, second read executor or provider dispatch was added. +- Rust review method and mutation recovery APIs now return Option. Content-only + review/audit render absent mutation method/recovery rather than an imaginary + recorded-write capability, with empty write path and zero body allowance. The + content GET declaration remains explicit. All affected Rust/fuzz callers were + cut over directly; existing mutation JSON/source identities are unchanged. +- `native_read_only_recipe_fixture_is_current` writes source/lock/review under + `bindings/fixtures/gateway/content-only`, a negative read-only corpus and native + fuzz seed. It covers missing content, custom tool, mutation adjuncts and write + injection under the reserved read tool, plus absence of a native write plan. +- `native_read_only_process_journey_fixture_is_current` installs the real daemon + with read/release-only native trust, refuses mutation review/submission and + mutation recovery from acquired content, then performs exactly one counted + provider GET and separate authenticated recipient disclosure/ACK. +- Final required artifact generation passed six exact native tests in 32.17 + seconds: read-only source, existing review contract, content/candidate/recovery + compilation and semantic closure. Existing mutation review, content compilation, + candidate and recovery artifacts remained byte-for-byte unchanged. The final + read-only and mixed read/write process generators passed two tests in 3.05 + seconds; the previous mixed process artifact also remained unchanged. No broad + local test/build/lint/formal suite was run. +- The user's subsequent explicit request to investigate/fix CI authorizes earlier + CI triage. A CI subagent works only in an isolated checkout and reports commits + for integration after this increment; it does not modify the main worktree. + Final required hosted verification on the completed specification remains open. +- No complete A01–A22 case closes. Google metadata/reference parity, refresh + custody, AP070 Python state-owner removal, installed language/UI, hostile + containment and complete adapter/fault/formal/performance evidence still remain. + ## Phase gates | Phase | State | Outstanding gate | @@ -1440,14 +1483,14 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed bindings/authenticated UI, standalone read recipe and AP070 Python owner removal | +| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed bindings/authenticated UI, Google metadata/refresh and AP070 Python owner removal | | P4 | Partial CLI process journey | Differential, full faults/adapters, installed bindings/UI, formal/performance links and CI | ## Acceptance ledger `Authored` means scenario source exists, not that it passed. `Executed` requires the exact tested revision and a reproducible result. External qualification is a -separate claim. No AP074 acceptance case is currently executed or qualified. +separate claim. No complete AP074 acceptance gate is currently closed or externally qualified. | Case | Required evidence | Implementation / authored / executed | Limitation or next work | | --- | --- | --- | --- | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 3bb86075f..c82bd0547 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -708,3 +708,23 @@ records three actual provider requests and redacted native facts. Public fixed keys simulate actors; neither installed UI/language integration, isolated hostile agent containment nor PostgreSQL/full fault coverage is inferred. Differential reference and bounded performance exit gates remain open. + + +### Content-only installation + +The absence of a mutation declaration is now represented by a closed compiled +`ContentOnly` alternative containing no `WritePlan`. It shares existing source +credential/header/resource validation and native content compilation; it does +not derive a read from a dummy write or add a provider operation branch. Only the +reserved native read tool is accepted, content is required, and all mutation +adjuncts are refused. Mutation construction is impossible for this compiled kind. +Review/audit expose absent mutation method/recovery rather than a fictitious +recorded-write capability. Existing mutation canonical source/review identities +are preserved by the native artifact comparisons. + +A generated negative corpus and real local CLI/daemon install/read/disclosure +journey establish the narrow capability and its mutation refusal. The installed +trust in that journey contains only read/release permissions. Existing mixed +read/write process composition still passes. No new provider capability, Google +metadata interpretation, AP070 policy semantics, formal theorem or adapter +assumption is extracted by this change; those complete gates remain pending. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 3002a188c..25042012c 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -368,6 +368,28 @@ same native binding, review renderer and approval machinery serve both types. This compilation contract does not itself implement read admission, an entry permit, observation evidence or disclosure. +A standalone read-only recipe uses source `/3` with no `write` declaration, +the reserved `auths_gateway_content_read_v1` tool and a required content capability. +It cannot declare mutation observation, echo, pre-entry, precondition, +relative-ceiling or spend-sum configuration. Its profile lock has only the +existing binding fields, exact resource field and optional account scope. +The native compiler lowers this to `ContentOnly`, which contains no mutation +plan. Mutation request construction fails before custody or transport. Candidate +credential reads, content acquisition and disclosure continue through the existing +native owners. Operator review has null mutation method/recovery, empty write path +and zero write-body allowance; its content GET declaration is rendered separately. +Rust review method/recovery APIs return explicit absence for this case. Existing +mutation source/review bytes remain unchanged. No GET write method, fake write +endpoint or separate read executor is introduced. + +The native read-only corpus freezes source/lock/review and rejects mutation +adjuncts, missing content, custom tools and write injection under the reserved +read tool. A real CLI/daemon fixture installs it under read/release-only native +trust, refuses mutation submission/review and mutation recovery from acquired +content, and performs exactly one content GET plus authenticated disclosure. +This supports standalone native reads; Google metadata gating, credential refresh, +AP070 owner removal, authenticated UI and installed language evidence remain open. + Explicit content acquisition is a versioned opt-in recipe capability, `content.schema = auths.gateway-content-read/1`, within recipe source `/3`. It is included in the recipe digest and operator review; absence permits no diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/content-only b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_recipe/content-only new file mode 100644 index 0000000000000000000000000000000000000000..1c805b1e13f548fe9c2208534d3fd15f031b9508 GIT binary patch literal 1975 zcmd5-%Wm5+5bU9+dO5mjQEXQ{%OSf3*sM9MOIR11E&j6|D|m66?MkS# zA}hBZUW1wh14l+EL+cjO$cIBG{VgM9d*)k(^NPvdKyNAqlvh*kugU=wHBwbQ?LZIo z1@?@|6mZNI)FNA5u-SXjb6ckdsz4qs;ixAfqtckBoK6-5PZ1j2SiiY! zg4vUf=DL};YysJTkfz>`^`ZP3J5(Q*7g z(V6H5ED@VOk8d>1&gZ#tAnA@iiEixh>FL3GwyKZDSvJpBn;>bt6J~P0vfbFZ-kfY1 zbbQy*o`>~vE`G&g{$V4-H(jQU68-+N|3Cp@^VRM`^G@`ZzKusY;%Rbqfka7=u{jQI zUeF^z%)>IvoWExju2*YCVxFKWhj^j?SCpt~zNH|W&1u`oJh z`j5x@UXjiEqT{(pUdC?Re{@NtEo*Bo>mYZM?4b`!I#~9OtSoN)*r0^TS+@8!@T}8u s;JCq@@UOOjhPFu$QXAlD_->`GWcOhcg!{9?|LZqw0;T;^%x_MA0hoR(!2kdN literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_recipe.rs b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_recipe.rs index 147d8ae15..22af7b374 100644 --- a/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_recipe.rs +++ b/product/runtime/auths-gateway/fuzz/fuzz_targets/target_gateway_recipe.rs @@ -28,7 +28,11 @@ fuzz_target!(|data: &[u8]| { let review = recipe.review(); let _ = recipe.review_document(); assert_eq!(review.recovery(), recipe.recovery()); - assert!(!recipe.recovery().write_is_conditional); + assert!( + recipe + .recovery() + .is_none_or(|capability| !capability.write_is_conditional) + ); let Ok(value) = serde_json::from_slice::(source) else { panic!("an accepted source is JSON"); }; diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index ae9c19932..b819fff65 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"56f3098c5423a6b45a81de526bd673e82ec9c119ec4b4851be53bd942f274217"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"38c1d4ba50a3dfffc492aed1fec179a18602a98bd4cdf43c7f6639570ea43a24"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"9ee4beb8cf106549c154bd2b226253cb64872e662017f68c63ab1a1ae1f9640a"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"d0807cc6a85f4da8b3503a55044ade060fe64134d57e711b554404a7a6b1b70b"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"e4d843d26e90782df3e55e2ec40e02b9def724b87ab9e7be49a17625b22be470"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"21d78694cdbf64ae4b63ace13d490e1a3e12af61453fe7baef47d62fbf279a29"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"900661c5a1e696f9e39a70dda86a12e80c8e1f88bb66ca48a2a5743938658488"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"67b5c3b0d684eb9dbb1143f939ac9269429e0a5e6594cd927798f8f33d1f654f"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"ce76407c361b899b9fe6bd3bfb1e99740b088e81db5f75808a873d6350e24dd4"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c6d308916e3e016a07fca24fa6dc443a4da624990432f9d221b91d5ce2b80018"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"38c1d4ba50a3dfffc492aed1fec179a18602a98bd4cdf43c7f6639570ea43a24"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/audit.rs b/product/runtime/auths-gateway/src/audit.rs index 5b1b48c4e..b36758027 100644 --- a/product/runtime/auths-gateway/src/audit.rs +++ b/product/runtime/auths-gateway/src/audit.rs @@ -440,7 +440,10 @@ pub fn audit_bundle(bytes: &[u8], pins: &AuditPins) -> Result !matches!( source.tool.as_str(), crate::effect::RECOVERY_READ_TOOL | crate::effect::CANDIDATE_CHECK_TOOL | crate::effect::CONTENT_READ_TOOL | crate::effect::DISCLOSURE_TOOL - ) - { + ), + None => source.tool == crate::effect::CONTENT_READ_TOOL, + }; + if source.schema != RECIPE_SOURCE_SCHEMA || !valid_tool { return Err(GatewayRecipeError::InvalidSource); } validate_lock(&lock)?; @@ -613,10 +615,16 @@ impl CompiledRecipe { &self.namespace } - /// What this recipe can prove after an ambiguous write. + /// What a mutation recipe can prove after an ambiguous write. Content-only + /// recipes have no mutation recovery capability. #[must_use] - pub fn recovery(&self) -> RecoveryCapability { - recovery_capability(self.recovery_declarations()) + pub fn recovery(&self) -> Option { + match self.plans.execution { + lower::ExecutionPlan::Mutation(_) => { + Some(recovery_capability(self.recovery_declarations())) + } + lower::ExecutionPlan::ContentOnly => None, + } } fn recovery_declarations(&self) -> RecoveryDeclarations { @@ -632,7 +640,12 @@ impl CompiledRecipe { } Some(_) => StateObservation::VerifiedLocator, }; - let idempotency = match &self.source.write.idempotency { + let idempotency = match self + .source + .write + .as_ref() + .and_then(|write| write.idempotency.as_ref()) + { None => LostClaimReentry::None, Some(IdempotencySource::DerivedHeader { retention_seconds }) => { LostClaimReentry::Declared { @@ -751,6 +764,14 @@ impl CompiledRecipe { arguments: &Map, action_commitment: [u8; 32], ) -> Result { + let lower::ExecutionPlan::Mutation(plan) = &self.plans.execution else { + return Err(GatewayRecipeError::ActionMismatch); + }; + let write = self + .source + .write + .as_ref() + .ok_or(GatewayRecipeError::InvalidSource)?; let values = self.argument_values(arguments)?; let operation_id = arguments .get("operation_id") @@ -763,18 +784,18 @@ impl CompiledRecipe { .as_ref() .map(|_| echo_token(&self.namespace, &operation_id, &action_commitment)); let key = matches!( - self.source.write.idempotency, + write.idempotency, Some(IdempotencySource::DerivedHeader { .. }) ) .then(|| idempotency_key(&self.namespace, &operation_id)); let built = construct::construct_write( - &self.plans.write, + plan, &values, echo.as_deref().unwrap_or_default().as_bytes(), key.as_deref().unwrap_or_default().as_bytes(), ) .map_err(GatewayRecipeError::from_construct)?; - let content_type = match self.plans.write.body { + let content_type = match plan.body { construct::BodyPlan::Json(_) => "application/json", construct::BodyPlan::Form(_) => "application/x-www-form-urlencoded", }; @@ -809,7 +830,7 @@ impl CompiledRecipe { action_commitment, echo, idempotency_key: key, - method: self.source.write.method, + method: write.method, url: ascii(built.url)?, content_type, body: built.body, diff --git a/product/runtime/auths-gateway/src/recipe/content.rs b/product/runtime/auths-gateway/src/recipe/content.rs index f4a181af1..8c336c789 100644 --- a/product/runtime/auths-gateway/src/recipe/content.rs +++ b/product/runtime/auths-gateway/src/recipe/content.rs @@ -83,6 +83,10 @@ enum ContentProjection { } impl ContentSource { + pub(super) fn resource_field(&self) -> &str { + &self.resource_field + } + pub(super) fn validate( &self, fields: &BTreeMap, diff --git a/product/runtime/auths-gateway/src/recipe/lower.rs b/product/runtime/auths-gateway/src/recipe/lower.rs index b16d99bec..fbdf95198 100644 --- a/product/runtime/auths-gateway/src/recipe/lower.rs +++ b/product/runtime/auths-gateway/src/recipe/lower.rs @@ -25,7 +25,7 @@ use std::collections::BTreeMap; /// Every plan of one compiled recipe. #[derive(Clone, Debug)] pub(super) struct Plans { - pub(super) write: WritePlan, + pub(super) execution: ExecutionPlan, /// Present only for a verified-locator observation. pub(super) observation: Option, pub(super) pre_entry: Option, @@ -35,6 +35,13 @@ pub(super) struct Plans { pub(super) denied: Vec, } +/// A content-only installation has no executable mutation plan. +#[derive(Clone, Debug)] +pub(super) enum ExecutionPlan { + Mutation(Box), + ContentOnly, +} + struct Lowering<'a> { fields: &'a BTreeMap, origin: Vec, @@ -349,20 +356,20 @@ pub(super) fn plans( origin: source.origin.as_bytes().to_vec(), headers: header_plan(source, fields)?, }; - let write = WritePlan { - method: method(source.write.method), - origin: lowering.origin.clone(), - path: lowering.path(&source.write.path)?, - headers: lowering.headers.clone(), - idempotency_header: matches!( - source.write.idempotency, - Some(IdempotencySource::DerivedHeader { .. }) - ) - .then(|| IDEMPOTENCY_HEADER.as_bytes().to_vec()), - body: lowering.body( - &source.write.body, - source.echo.as_ref().map(|echo| &echo.write), - )?, + let execution = match &source.write { + None => ExecutionPlan::ContentOnly, + Some(write) => ExecutionPlan::Mutation(Box::new(WritePlan { + method: method(write.method), + origin: lowering.origin.clone(), + path: lowering.path(&write.path)?, + headers: lowering.headers.clone(), + idempotency_header: matches!( + write.idempotency, + Some(IdempotencySource::DerivedHeader { .. }) + ) + .then(|| IDEMPOTENCY_HEADER.as_bytes().to_vec()), + body: lowering.body(&write.body, source.echo.as_ref().map(|echo| &echo.write))?, + })), }; let observation = source .observation @@ -408,7 +415,7 @@ pub(super) fn plans( }) .collect::>()?; Ok(Plans { - write, + execution, observation, pre_entry, relative_ceiling, diff --git a/product/runtime/auths-gateway/src/recipe/review.rs b/product/runtime/auths-gateway/src/recipe/review.rs index 81969df1c..40f0a1066 100644 --- a/product/runtime/auths-gateway/src/recipe/review.rs +++ b/product/runtime/auths-gateway/src/recipe/review.rs @@ -33,7 +33,7 @@ pub struct RecipeReview { service: String, tool: String, origin: String, - method: WriteMethod, + method: Option, path: Vec, credential: CredentialRequirement, maximum_body_bytes: usize, @@ -41,7 +41,7 @@ pub struct RecipeReview { sends_idempotency_key: bool, echo: Option, preconditions: Option, - recovery: RecoveryCapability, + recovery: Option, } /// Operator review of the verified arguments the request never renders. @@ -116,9 +116,9 @@ impl RecipeReview { pub fn origin(&self) -> &str { &self.origin } - /// Returns the fixed write method. + /// Returns the fixed write method, or `None` for a content-only recipe. #[must_use] - pub const fn method(&self) -> WriteMethod { + pub const fn method(&self) -> Option { self.method } /// Returns fixed and typed path segments for operator review. @@ -158,9 +158,9 @@ impl RecipeReview { pub const fn preconditions(&self) -> Option<&RecipePreconditionReview> { self.preconditions.as_ref() } - /// Returns what the recipe can prove after an ambiguous write. + /// Returns mutation recovery capability, absent for content-only recipes. #[must_use] - pub const fn recovery(&self) -> RecoveryCapability { + pub const fn recovery(&self) -> Option { self.recovery } } @@ -242,21 +242,28 @@ impl CompiledRecipe { service: source.service.clone(), tool: source.tool.clone(), origin: source.origin.clone(), - method: source.write.method, + method: source.write.as_ref().map(|write| write.method), path: source .write - .path .iter() + .flat_map(|write| &write.path) .map(|segment| match segment_review(segment) { Value::String(text) => text, _ => String::new(), }) .collect(), credential: super::credential_requirement(&source.credential), - maximum_body_bytes: MAX_BODY_BYTES, + maximum_body_bytes: if source.write.is_some() { + MAX_BODY_BYTES + } else { + 0 + }, has_observation: source.observation.is_some(), sends_idempotency_key: matches!( - source.write.idempotency, + source + .write + .as_ref() + .and_then(|write| write.idempotency.as_ref()), Some(IdempotencySource::DerivedHeader { .. }) ), echo: source.echo.as_ref().map(|echo| { @@ -295,7 +302,7 @@ impl CompiledRecipe { "service": review.service(), "tool": review.tool(), "origin": review.origin(), - "method": review.method().as_str(), + "method": review.method().map(WriteMethod::as_str), "path": review.path(), "credential": review.credential(), "maximum_body_bytes": review.maximum_body_bytes(), @@ -312,7 +319,7 @@ impl CompiledRecipe { "verified": preconditions.verified(), "disclosure": preconditions.disclosure(), })), - "recovery": recovery_document(&review.recovery()), + "recovery": review.recovery().as_ref().map(recovery_document), "write_is_conditional": false, }); document["provider_headers"] = @@ -339,31 +346,30 @@ impl CompiledRecipe { "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry", }); } - document["idempotency"] = - source - .write - .idempotency - .as_ref() - .map_or(Value::Null, |idempotency| { - let mut value = json!({ - "kind": match idempotency { - IdempotencySource::DerivedHeader { .. } => "derived-header", - IdempotencySource::OperationIdField { .. } => "operation-id-field", - }, - "retention_seconds": idempotency.retention_seconds(), - "disclosure": IDEMPOTENCY_DISCLOSURE, - }); - if let IdempotencySource::OperationIdField { location, .. } = idempotency { - value["location"] = serde_json::to_value(location).unwrap_or(Value::Null); - } - value + document["idempotency"] = source + .write + .as_ref() + .and_then(|write| write.idempotency.as_ref()) + .map_or(Value::Null, |idempotency| { + let mut value = json!({ + "kind": match idempotency { + IdempotencySource::DerivedHeader { .. } => "derived-header", + IdempotencySource::OperationIdField { .. } => "operation-id-field", + }, + "retention_seconds": idempotency.retention_seconds(), + "disclosure": IDEMPOTENCY_DISCLOSURE, }); + if let IdempotencySource::OperationIdField { location, .. } = idempotency { + value["location"] = serde_json::to_value(location).unwrap_or(Value::Null); + } + value + }); document["observation"] = source .observation .as_ref() .map_or(Value::Null, |observation| { json!({ - "locator": observation_name(review.recovery().state_observation), + "locator": observation_name(review.recovery().map_or(StateObservation::None, |capability| capability.state_observation)), "path": path_review(&observation.path), "json_pointer": observation.json_pointer, "expected_field": observation.expected_field, diff --git a/product/runtime/auths-gateway/src/recipe/runtime.rs b/product/runtime/auths-gateway/src/recipe/runtime.rs index c11873e70..ed137ad0b 100644 --- a/product/runtime/auths-gateway/src/recipe/runtime.rs +++ b/product/runtime/auths-gateway/src/recipe/runtime.rs @@ -377,8 +377,8 @@ impl CompiledRecipe { pub(crate) fn idempotency_retention(&self) -> Option { self.source .write - .idempotency .as_ref() + .and_then(|write| write.idempotency.as_ref()) .map(IdempotencySource::retention_seconds) } diff --git a/product/runtime/auths-gateway/src/recipe/source.rs b/product/runtime/auths-gateway/src/recipe/source.rs index c341df0dc..1c4ca07db 100644 --- a/product/runtime/auths-gateway/src/recipe/source.rs +++ b/product/runtime/auths-gateway/src/recipe/source.rs @@ -29,7 +29,8 @@ pub(super) struct RecipeSource { pub(super) bounds: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) relative_ceiling: Option, - pub(super) write: WriteSource, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub(super) write: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) content: Option, #[serde(default, skip_serializing_if = "Option::is_none")] diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index 0d3bdaf13..3048ccf14 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -1275,7 +1275,11 @@ fn oracle_request(recipe: &CompiledRecipe, arguments: &Map, commi .map(|echo| (&echo.write, request.echo_token().expect("token"))); assert_eq!( request.body(), - oracle::body(&recipe.source.write.body, echo, arguments), + oracle::body( + &recipe.source.write.as_ref().expect("mutation recipe").body, + echo, + arguments + ), "body" ); assert_eq!( @@ -1283,7 +1287,10 @@ fn oracle_request(recipe: &CompiledRecipe, arguments: &Map, commi format!( "{}{}", recipe.source.origin, - oracle::path(&recipe.source.write.path, arguments) + oracle::path( + &recipe.source.write.as_ref().expect("mutation recipe").path, + arguments + ) ), "url" ); @@ -1534,3 +1541,159 @@ fn native_review_contract_fixture_is_current() { assert_eq!(std::fs::read(path).expect("seed"), seed); } } + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one standalone read recipe and negative source corpus" +)] +fn native_read_only_recipe_fixture_is_current() { + let (source, lock) = fixture("airtable"); + let mut source: Value = serde_json::from_slice(source).expect("source"); + let mut lock: Value = serde_json::from_slice(lock).expect("lock"); + for field in [ + "write", + "observation", + "echo", + "pre_entry", + "preconditions", + "relative_ceiling", + "bounds", + ] { + source.as_object_mut().expect("source").remove(field); + } + source["tool"] = json!(crate::effect::CONTENT_READ_TOOL); + lock["tool"] = source["tool"].clone(); + lock["command_schema"]["fields"] + .as_object_mut() + .expect("fields") + .remove("replacement"); + let schema = serde_json_canonicalizer::to_vec(&lock["command_schema"]).expect("schema"); + lock["schema_digest"] = json!(hex::encode(Sha256::digest(&schema))); + source["profile_schema_digest"] = lock["schema_digest"].clone(); + source["review"]["fields"] + .as_object_mut() + .expect("review fields") + .remove("replacement"); + source["review"]["consequences"] = json!([ + "Acquire the displayed resource as private content. Disclosure requires separate authorization; no provider mutation is available." + ]); + source["content"] = json!({"schema":"auths.gateway-content-read/1", "resource_field":"record_id", + "path":[{"kind":"fixed","value":"documents"},{"kind":"field","name":"record_id"}], + "query":[{"name":"format","value":"text/plain"}],"projection":{"kind":"utf8"}, + "maximum_response_bytes":1024,"maximum_content_bytes":64}); + let source_bytes = serde_json::to_vec_pretty(&source).expect("source"); + let lock_bytes = serde_json::to_vec_pretty(&lock).expect("lock"); + let recipe = CompiledRecipe::compile(&source_bytes, &lock_bytes).expect("read-only recipe"); + assert!(matches!( + recipe.plans.execution, + lower::ExecutionPlan::ContentOnly + )); + assert_eq!(recipe.review().method(), None); + assert_eq!(recipe.recovery(), None); + assert!(recipe.review_document()["recovery"].is_null()); + assert!(recipe.review().path().is_empty()); + assert_eq!(recipe.review().maximum_body_bytes(), 0); + assert!(!recipe.review().has_observation()); + assert!(recipe.credential_reads().expect("reads").is_empty()); + let resource = json!({"record_id":"recTEST0000000001"}) + .as_object() + .expect("resource") + .clone(); + assert!(recipe.content_read(&resource).is_ok()); + let args = arguments( + &recipe, + &json!({"operation_id":"write","record_id":"recTEST0000000001"}), + ); + assert_eq!( + recipe.closed_request_from_arguments(&args, [0; 32]).err(), + Some(GatewayRecipeError::ActionMismatch) + ); + let mut negatives = Vec::new(); + for field in [ + "observation", + "echo", + "pre_entry", + "preconditions", + "relative_ceiling", + "bounds", + ] { + let mut hostile = source.clone(); + hostile[field] = match field { + "observation" => { + json!({"path":[{"kind":"field","name":"record_id"}],"json_pointer":"/value","expected_field":"record_id","maximum_response_bytes":64}) + } + "echo" => json!({"write":{"kind":"json-pointer","pointer":"/echo"},"observe":"/echo"}), + "pre_entry" => { + json!({"path":[{"kind":"field","name":"record_id"}],"pointers":["/value"],"maximum_response_bytes":64}) + } + "preconditions" => json!({"verified":["record_id"]}), + "relative_ceiling" => { + json!({"argument":"record_id","basis_points":100,"path":[{"kind":"field","name":"record_id"}],"json_pointer":"/value","maximum_response_bytes":64}) + } + "bounds" => json!({}), + _ => unreachable!(), + }; + let error = + CompiledRecipe::compile(&serde_json::to_vec(&hostile).expect("hostile"), &lock_bytes) + .expect_err("mutation adjunct refused"); + assert_eq!(error, GatewayRecipeError::InvalidSource); + negatives.push(json!({"case":field,"code":error.code()})); + } + for field in ["content", "tool"] { + let mut hostile = source.clone(); + if field == "content" { + hostile.as_object_mut().expect("object").remove(field); + } else { + hostile[field] = json!("unbound_custom_read"); + } + let error = + CompiledRecipe::compile(&serde_json::to_vec(&hostile).expect("hostile"), &lock_bytes) + .expect_err("missing protocol"); + assert_eq!(error, GatewayRecipeError::InvalidSource); + negatives.push(json!({"case":format!("missing-or-wrong-{field}"),"code":error.code()})); + } + let mut smuggled = source.clone(); + let mutation: Value = serde_json::from_slice(fixture("airtable").0).expect("mutation"); + smuggled["write"] = mutation["write"].clone(); + assert_eq!( + CompiledRecipe::compile(&serde_json::to_vec(&smuggled).expect("source"), &lock_bytes).err(), + Some(GatewayRecipeError::InvalidSource) + ); + negatives.push( + json!({"case":"write-with-reserved-read-tool","code":"gateway.recipe.invalid-source"}), + ); + let directory = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let mut seed = u32::try_from(source_bytes.len()) + .expect("bounded source") + .to_be_bytes() + .to_vec(); + seed.extend_from_slice(&source_bytes); + seed.extend_from_slice(&lock_bytes); + let seed_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("fuzz/corpus/target_gateway_recipe/content-only"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&seed_path, &seed).expect("seed"); + } + assert_eq!(std::fs::read(seed_path).expect("seed"), seed); + let review = serde_json::to_vec_pretty(&recipe.review_document()).expect("review"); + let corpus = serde_json::to_vec_pretty(&json!({"schema":"auths.read-only-recipe/1", + "source":source,"lock":lock,"review":recipe.review_document(),"negative_sources":negatives, + "mutation_plan_absent":true,"mutation_construction_refused":true, + "scope":"native compilation and closed request construction; process transport and installed binding evidence are separate"})).expect("corpus"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::create_dir_all(directory.join("content-only")).expect("directory"); + } + for (name, bytes) in [ + ("content-only/recipe.json", source_bytes), + ("content-only/profile.lock.json", lock_bytes), + ("content-only/review.json", review), + ("read-only-recipe.json", corpus), + ] { + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(directory.join(name), &bytes).expect("write"); + } + assert_eq!(std::fs::read(directory.join(name)).expect("fixture"), bytes); + } +} diff --git a/product/runtime/auths-gateway/src/recipe/validate.rs b/product/runtime/auths-gateway/src/recipe/validate.rs index 11927cdac..84730ff89 100644 --- a/product/runtime/auths-gateway/src/recipe/validate.rs +++ b/product/runtime/auths-gateway/src/recipe/validate.rs @@ -1,4 +1,4 @@ -//! The compile rules of recipe source `/2`. +//! The compile rules of recipe source `/3`. //! //! Each rule refuses with its stable code. The rules are independent: a //! source that breaks exactly one rule fails with that rule's code whatever @@ -731,7 +731,7 @@ pub(super) fn validate_guard( return Ok(()); }; let declared = [ - Some(source.write.path.as_slice()), + source.write.as_ref().map(|write| write.path.as_slice()), source .observation .as_ref() @@ -761,10 +761,28 @@ pub(super) fn validate_source( fields, consumed: Consumption::default(), }; - rules.path(&source.write.path, PathRole::Write)?; - rules.body(&source.write.body)?; - if let Some(idempotency) = &source.write.idempotency { - Rules::idempotency(idempotency, &source.write.body)?; + if let Some(write) = &source.write { + rules.path(&write.path, PathRole::Write)?; + rules.body(&write.body)?; + if let Some(idempotency) = &write.idempotency { + Rules::idempotency(idempotency, &write.body)?; + } + } else { + let content = source + .content + .as_ref() + .ok_or(GatewayRecipeError::InvalidSource)?; + if source.observation.is_some() + || source.echo.is_some() + || source.pre_entry.is_some() + || source.preconditions.is_some() + || source.relative_ceiling.is_some() + || source.bounds.is_some() + { + return Err(GatewayRecipeError::InvalidSource); + } + content.validate(fields)?; + rules.consume(content.resource_field()); } if let Some(observation) = &source.observation { rules.observation(observation)?; @@ -774,7 +792,11 @@ pub(super) fn validate_source( .observation .as_ref() .ok_or(GatewayRecipeError::EchoWithoutObservation)?; - validate_echo(echo, &source.write.body, observation)?; + let write = source + .write + .as_ref() + .ok_or(GatewayRecipeError::InvalidSource)?; + validate_echo(echo, &write.body, observation)?; } if let Some(pre_entry) = &source.pre_entry { rules.pre_entry(pre_entry)?; diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 39d9ed8a3..c9af781bb 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9661342487c8ed12da75845d812e3f5e0c9de6f29c6d9ad9e0542878eaf165da"; + "856af179ec2cc4cab68212505cc4455fa2497daf491293a20a6d3f8afe946f8e"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index 76a5ef97d..953acd86b 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -964,3 +964,237 @@ fn native_content_process_journey_fixture_is_current() { } assert_eq!(std::fs::read(output).expect("fixture"), artifact); } + +#[test] +#[allow( + clippy::too_many_lines, + reason = "read-only installation and external-call assertions" +)] +fn native_read_only_process_journey_fixture_is_current() { + let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let source = std::fs::read(fixtures.join("content-only/recipe.json")).expect("source"); + let lock = std::fs::read(fixtures.join("content-only/profile.lock.json")).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("read-only recipe"); + assert!(recipe.review().method().is_none()); + assert!(recipe.recovery().is_none()); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock") + .as_secs(); + let tools = [CONTENT_READ_TOOL, DISCLOSURE_TOOL].map(|tool| { + McpToolCall::new(recipe.review().service(), tool, serde_json::Map::new()).expect("tool") + }); + let trust = tools_context(&tools, now).expect("read/release-only native trust"); + let reviewer = SigningKey::from_bytes(&[29; 32]); + let recipient = SigningKey::from_bytes(&[31; 32]); + let policy = EffectPolicy::new( + "readonly-process-journey".to_owned(), + 1, + reviewer.verifying_key().to_bytes(), + ) + .expect("policy"); + let directory = tempfile::Builder::new() + .prefix("ap74-ro-") + .tempdir_in("/tmp") + .expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let state = root.join("state"); + let socket = root.join("app.sock"); + for (name, bytes) in [ + ("recipe", source), + ("lock", lock), + ("trust", trust), + ( + "policy", + policy.to_private_bytes().expect("policy").to_vec(), + ), + ] { + private(&root.join(name), &bytes); + } + let provider = Provider::start(); + let review: Value = serde_json::from_slice(&success(cli( + "review", + &[ + ("--recipe", path(&root.join("recipe"))), + ("--profile-lock", path(&root.join("lock"))), + ], + &[], + None, + ))) + .expect("operator review"); + assert!(review["method"].is_null()); + assert!(review["recovery"].is_null()); + assert_eq!(review["maximum_body_bytes"], 0); + assert_eq!(review["path"], json!([])); + assert_eq!(review["content_acquisition"]["method"], "GET"); + success(cli( + "install", + &[ + ("--state-dir", path(&state)), + ("--recipe", path(&root.join("recipe"))), + ("--profile-lock", path(&root.join("lock"))), + ("--trusted-context", path(&root.join("trust"))), + ("--effect-policy", path(&root.join("policy"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "airtable"), + ("--alias", "read-only"), + ("--account-label", "public-readonly-fixture"), + ], + &["--credential-stdin"], + Some(SECRET), + )); + let arguments = root.join("resource.json"); + let call = root.join("read.call"); + private( + &arguments, + &serde_json::to_vec(&json!({"record_id":RECORD})).expect("arguments"), + ); + success(cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&arguments)), + ("--operation", "read"), + ("--call-out", path(&call)), + ], + &[], + None, + )); + let read = approve( + &state, + &call_file(&call), + "read", + now, + &reviewer, + &[], + &["--content"], + ); + let invalid_review = root.join("invalid-review"); + assert!( + !cli( + "effect-review", + &[ + ("--state-dir", path(&state)), + ("--proof", path(&read.proof)), + ("--action", path(&read.action)), + ("--not-before", &(now - 1).to_string()), + ("--expires-at", &(now + 300).to_string()), + ("--request-out", path(&invalid_review)) + ], + &[], + None + ) + .status + .success() + ); + assert!(!invalid_review.exists()); + assert!(provider.calls().is_empty()); + let daemon = Daemon::start(&state, &socket, provider.port); + let rejected_mutation = public(read.execute("submit", &socket, &[], &[], None)); + assert_eq!( + rejected_mutation["outcome"], "not-entered", + "{rejected_mutation}" + ); + assert!( + provider.calls().is_empty(), + "native read authority and approval cannot enter mutation" + ); + let acquired = public(read.execute("content-acquire", &socket, &[], &[], None)); + assert_eq!( + acquired["history"]["snapshot"]["stage"], "response-recorded", + "{acquired}" + ); + let uid = rustix::process::geteuid().as_raw(); + let target = root.join("target.json"); + private( + &target, + &serde_json::to_vec(&AppDisclosureTarget { + source_operation: "read".to_owned(), + recipient_key: recipient.verifying_key().to_bytes(), + channel: UnixDisclosurePolicy::new(uid, uid, [7; 32]), + delivery_instance: [8; 32], + }) + .expect("target"), + ); + let call = root.join("release.call"); + success(cli( + "effect-disclosure-call", + &[ + ("--state-dir", path(&state)), + ("--target", path(&target)), + ("--operation", "release"), + ("--call-out", path(&call)), + ], + &[], + None, + )); + let release = approve( + &state, + &call_file(&call), + "release", + now, + &reviewer, + &[("--disclosure", path(&target))], + &[], + ); + let received = root.join("content"); + let ack = root.join("ack"); + assert_eq!( + public(release.execute( + "disclosure-receive", + &socket, + &[ + ("--target", path(&target)), + ("--expected-binding", path(&release.binding)), + ("--expected-bytes", &CONTENT.len().to_string()), + ("--content-out", path(&received)), + ("--acknowledgement-out", path(&ack)) + ], + &["--recipient-seed-stdin"], + Some(&[31; 32]) + ))["outcome"], + "recipient-ack-sent" + ); + assert_eq!(std::fs::read(&received).expect("content"), CONTENT); + let deadline = Instant::now() + Duration::from_secs(5); + let disclosed = loop { + let value = history(&socket, "release"); + if value["history"]["snapshot"]["stage"] == "acknowledged" { + break value; + } + assert!(Instant::now() < deadline, "ACK persistence: {value}"); + thread::sleep(Duration::from_millis(10)); + }; + assert!( + !cli( + "effect-recovery-call", + &[ + ("--state-dir", path(&state)), + ("--source-operation", "read"), + ("--recovery-operation", "fake-mutation") + ], + &[], + None + ) + .status + .success() + ); + assert_eq!( + provider.calls(), + [format!( + "GET /documents/{RECORD}?format=text%2Fplain HTTP/1.1" + )] + ); + drop(daemon); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.read-only-process-journey/1", + "scope":"production local CLI/daemon processes, file custody/journal, native read/release-only grants and public fixed test approval keys; no Google metadata, UI, language package, hostile UID isolation or PostgreSQL claim", + "recipe_digest":recipe.digest_hex(),"operator_review":review,"provider_requests":provider.calls(), + "mutation_refusal":rejected_mutation,"mutation_review_refused":true,"acquisition":acquired,"disclosure":disclosed, + "content_source_cannot_be_mutation_recovery_source":true,"no_mutation_permission_or_plan_installed":true})).expect("artifact"); + let output = fixtures.join("read-only-process-journey.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &artifact).expect("write"); + } + assert_eq!(std::fs::read(output).expect("fixture"), artifact); +} From 9c9390362ec534c41485c8cc82031e012f4f6643 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:09:46 +0000 Subject: [PATCH 058/136] fix(ci): refresh AP074 inventories and preserve Python 3.9 runners --- .github/workflows/python-sdk.yml | 10 +++++----- bindings/python/tests/test_public_api_v2.py | 4 ++-- bindings/typescript/api/public-api.txt | 2 +- .../families/airtable-record-update-v1/contract.json | 2 +- .../airtable-record-update-v1/corpus-manifest.json | 2 +- .../families/stripe-platform-refund-v1/contract.json | 2 +- .../stripe-platform-refund-v1/corpus-manifest.json | 2 +- 7 files changed, 12 insertions(+), 12 deletions(-) diff --git a/.github/workflows/python-sdk.yml b/.github/workflows/python-sdk.yml index 022cc1701..05322fdf8 100644 --- a/.github/workflows/python-sdk.yml +++ b/.github/workflows/python-sdk.yml @@ -136,7 +136,7 @@ jobs: strategy: fail-fast: true matrix: - os: [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-24.04, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 @@ -168,7 +168,7 @@ jobs: strategy: fail-fast: true matrix: - os: [ubuntu-latest, macos-latest, windows-latest] + os: [ubuntu-24.04, macos-latest, windows-latest] python: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"] runs-on: ${{ matrix.os }} steps: @@ -241,14 +241,14 @@ jobs: typing-and-api: name: installed typing and API contract needs: [consumer-contract, wheel-build] - runs-on: ubuntu-latest + runs-on: ubuntu-24.04 steps: - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 with: python-version: "3.9" - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-wheel-ubuntu-latest-${{ github.run_id }}-${{ github.run_attempt }} + name: python-wheel-ubuntu-24.04-${{ github.run_id }}-${{ github.run_attempt }} path: wheelhouse - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: @@ -285,7 +285,7 @@ jobs: strategy: fail-fast: true matrix: - os: [ubuntu-latest, macos-latest] + os: [ubuntu-24.04, macos-latest] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 diff --git a/bindings/python/tests/test_public_api_v2.py b/bindings/python/tests/test_public_api_v2.py index f23d25646..6e42048b0 100644 --- a/bindings/python/tests/test_public_api_v2.py +++ b/bindings/python/tests/test_public_api_v2.py @@ -27,7 +27,7 @@ "auths.authoring": 24, "auths.attempts": 5, "auths.execution": 11, - "auths.gateway": 17, + "auths.gateway": 18, "auths.self_hosted": 28, "auths.identity": 11, "auths.identity.adapters": 14, @@ -48,7 +48,7 @@ def test_exact_public_inventory() -> None: assert len(exported) == expected assert len(set(exported)) == expected assert all(hasattr(module, value) for value in exported) - assert sum(EXPECTED_EXPORTS.values()) == 189 + assert sum(EXPECTED_EXPORTS.values()) == 190 def test_product_root_is_small_and_removed_names_are_absent() -> None: diff --git a/bindings/typescript/api/public-api.txt b/bindings/typescript/api/public-api.txt index 6630922f4..36b991cf0 100644 --- a/bindings/typescript/api/public-api.txt +++ b/bindings/typescript/api/public-api.txt @@ -1,5 +1,5 @@ # Installed @auths-dev/sdk public API v1 -# declaration-sha256 d707ad9eaf70b6b5fec7d602e7133b6c9635081c6b931ed9d398aea9e8adc424 +# declaration-sha256 bf0244c80c841728705313102efac0d9aa671e066729617e055b3348d59a68e5 . AuthsError value+type . AuthsIssue type . EffectState type diff --git a/qualification/families/airtable-record-update-v1/contract.json b/qualification/families/airtable-record-update-v1/contract.json index 73749c6dd..51622f4f2 100644 --- a/qualification/families/airtable-record-update-v1/contract.json +++ b/qualification/families/airtable-record-update-v1/contract.json @@ -1 +1 @@ -{"api_release":"web-api-v0-reviewed-2026-10-07","corpus_manifest_sha256":"47f191e58efd16b0de63082484f7df56367c9f4842b9110a7cb2a7a1a5fe38e2","declarations":{"idempotency_sha256":"74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b","observation_sha256":"9dd79dd204fa13a2df3c667d106c66c0526d174a2c018631e2b2f6b897eaf311","recovery_sha256":"7081a92b4cd2d13dab5e7c30e640675a252b62bca20d340e14d62d9c8c048eca","retention_sha256":"4a4b5048c97b16e041af55b032c0b8ac20f5142c4bbcbf31b31c6674770a70d0"},"environment_class":"disposable-live-resources","manual_assumptions":["Airtable supplies no idempotency key for this PATCH; durable gateway admission prevents a second entry.","Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only a fresh GET with the exact replacement and echo can reconcile a lost response.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths.","The reviewed fixed Airtable base and table contain only owner-authorized disposable qualification records."],"oracle_version":"auths-reviewed-reference-v2","provider":"airtable","schema":"auths.provider-contract/1"} \ No newline at end of file +{"api_release":"web-api-v0-reviewed-2026-10-07","corpus_manifest_sha256":"e1ebcc5aa0c7eef12cf3ee185150abe7bc0727cb200e05f9bd789314f31ebd40","declarations":{"idempotency_sha256":"74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b","observation_sha256":"9dd79dd204fa13a2df3c667d106c66c0526d174a2c018631e2b2f6b897eaf311","recovery_sha256":"7081a92b4cd2d13dab5e7c30e640675a252b62bca20d340e14d62d9c8c048eca","retention_sha256":"4a4b5048c97b16e041af55b032c0b8ac20f5142c4bbcbf31b31c6674770a70d0"},"environment_class":"disposable-live-resources","manual_assumptions":["Airtable supplies no idempotency key for this PATCH; durable gateway admission prevents a second entry.","Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only a fresh GET with the exact replacement and echo can reconcile a lost response.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths.","The reviewed fixed Airtable base and table contain only owner-authorized disposable qualification records."],"oracle_version":"auths-reviewed-reference-v2","provider":"airtable","schema":"auths.provider-contract/1"} \ No newline at end of file diff --git a/qualification/families/airtable-record-update-v1/corpus-manifest.json b/qualification/families/airtable-record-update-v1/corpus-manifest.json index 2e8ea18b1..7de57c1cb 100644 --- a/qualification/families/airtable-record-update-v1/corpus-manifest.json +++ b/qualification/families/airtable-record-update-v1/corpus-manifest.json @@ -1 +1 @@ -{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"32241d9b4811a55abcdd224ef567df3857dbec34d761ef7a35d1044cdfa52d9f","family":"airtable-record-update-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"af7f984509ab11a3676cacc85eda2fa638c25bf91f7bfedf3ff3c119e47f3c41","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"f3c66e5f6636bfdf317dc87915255f22a97466a34cbb5053b55cdf6e05d6921f","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"f5e95620a1bb3fccc733be13c6ab68b6e84c0b134a6b54252766e4e57410907f","expand.py":"892cf7b04c3847336f150926bfbf3e82665e9e2bc1b154be42e4f57d1922b816","family_corpus.py":"a3662539a9a130f5272cbd8b3750be3ebb46d4ad903aba7afa10880f99a2f601","family_harness.py":"0e0a42be6cf75dfb3f674b26cbdfbb4c473edea71083dfaad89ecb40dec039ba","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"580fa1db01a6fa7691d618f123f9117ce39b25e6478460ceac46c1e650d6b454","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"cf993ba17ba40bd528a08d446bfc7c2e8cf0291f3e202337bcfdafa4ab269a7c","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"db7f6dc7f0fdc1b5acff1339cdf5bf7f11f3ba826aeca626a76d761bec0121a8","production_setup.py":"eac6cda2c2bff17364e72512b70ecfc3b6dad8c70088c1fe83d59f4ebaa395a0","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"c0f21ff1d3c8e344fee20a9a0c25bb14a264417ed53418ad536789a6096fb16e"} \ No newline at end of file +{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"32241d9b4811a55abcdd224ef567df3857dbec34d761ef7a35d1044cdfa52d9f","family":"airtable-record-update-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"af7f984509ab11a3676cacc85eda2fa638c25bf91f7bfedf3ff3c119e47f3c41","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"bd8a01adb7a0a6f58bf1ff5f7cd7d0894515c0858b4b8b894d084454d1418df1","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"445a0db1b151e12e8ea235b097acd15d6156195d408d39b7d3095820c127c5a6","expand.py":"9b6dea7793241a767065ac0456bfef5c01cfce3f1121278240eb77fc42ea7e54","family_corpus.py":"41c267688f5a03c83548ab97c1fa7a138a511abe8a4b758ac26cc580d81718a6","family_harness.py":"33b28af00a8aa0d71796fd0b92d0601db4922c5a418a2d240acc678fff32f82d","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"cd16fda3865fa6c9ab382c7ff3e4f91713b1d1399a3e89e2123d0fb7a6abb4d1","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"ae63062de1bbcbf26691d8db7bc50926e8af5009b5fa4e3e784e22e896ee78ce","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"89f50f5bc8bccbd1219074b08d59baadf14140374d09656f6b00c3a2faedaa0e","production_setup.py":"84153c0a3bceb4f1c4d3b355c489d1c56a4552052b9fb8fcf66aadf0d65bb053","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"176ad3ca2c90650fe8b59aed7e3996428c8c9b853cd421794bb04920936f7583"} \ No newline at end of file diff --git a/qualification/families/stripe-platform-refund-v1/contract.json b/qualification/families/stripe-platform-refund-v1/contract.json index a75c721e4..bbab72093 100644 --- a/qualification/families/stripe-platform-refund-v1/contract.json +++ b/qualification/families/stripe-platform-refund-v1/contract.json @@ -1 +1 @@ -{"api_release":"2025-03-31.basil","corpus_manifest_sha256":"5b55fc440715d9f18993910f9680d679371512f31748321b019c88f1e3b5de79","declarations":{"idempotency_sha256":"425a0dca2f279765debfc847c4a01bff60fea5be68dd9d761ae6bb60ce0b8a7b","observation_sha256":"d0ce5a34d987821c69c0a839d9ed66805c625f8324dd42031fcccf0752a8821e","recovery_sha256":"bf2303abce165c175360ac975586431bbc4cf03167489ea317a27de2f0b04abb","retention_sha256":"846c2164e26d1144d9aa146034b4f7ea4dc305136a59ffd94f999d19f2c360ee"},"environment_class":"provider-test-mode","manual_assumptions":["Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","Stripe idempotency is tested only inside the declared 86400-second retention interval.","Stripe test mode and the installed platform are checked by the declared guard on each lease.","The 50-percent payment basis is a read, not an atomic provider balance reservation.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths."],"oracle_version":"auths-reviewed-reference-v2","provider":"stripe","schema":"auths.provider-contract/1"} \ No newline at end of file +{"api_release":"2025-03-31.basil","corpus_manifest_sha256":"93ed44d2649c10d19bff36f05f727eada6793ee37f15a18ae5df4c243ce99e24","declarations":{"idempotency_sha256":"425a0dca2f279765debfc847c4a01bff60fea5be68dd9d761ae6bb60ce0b8a7b","observation_sha256":"d0ce5a34d987821c69c0a839d9ed66805c625f8324dd42031fcccf0752a8821e","recovery_sha256":"bf2303abce165c175360ac975586431bbc4cf03167489ea317a27de2f0b04abb","retention_sha256":"846c2164e26d1144d9aa146034b4f7ea4dc305136a59ffd94f999d19f2c360ee"},"environment_class":"provider-test-mode","manual_assumptions":["Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","Stripe idempotency is tested only inside the declared 86400-second retention interval.","Stripe test mode and the installed platform are checked by the declared guard on each lease.","The 50-percent payment basis is a read, not an atomic provider balance reservation.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths."],"oracle_version":"auths-reviewed-reference-v2","provider":"stripe","schema":"auths.provider-contract/1"} \ No newline at end of file diff --git a/qualification/families/stripe-platform-refund-v1/corpus-manifest.json b/qualification/families/stripe-platform-refund-v1/corpus-manifest.json index f41d69523..6fce2a03a 100644 --- a/qualification/families/stripe-platform-refund-v1/corpus-manifest.json +++ b/qualification/families/stripe-platform-refund-v1/corpus-manifest.json @@ -1 +1 @@ -{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"a72c557b69103a52eb477deb8364ded53cd58407b9ba7ab33ccbda74389fec1e","family":"stripe-platform-refund-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"99901e36cb7c4f5882897603c874698d582e859b5d6b08d53cd80975e89aa01c","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"f3c66e5f6636bfdf317dc87915255f22a97466a34cbb5053b55cdf6e05d6921f","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"f5e95620a1bb3fccc733be13c6ab68b6e84c0b134a6b54252766e4e57410907f","expand.py":"892cf7b04c3847336f150926bfbf3e82665e9e2bc1b154be42e4f57d1922b816","family_corpus.py":"a3662539a9a130f5272cbd8b3750be3ebb46d4ad903aba7afa10880f99a2f601","family_harness.py":"0e0a42be6cf75dfb3f674b26cbdfbb4c473edea71083dfaad89ecb40dec039ba","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"580fa1db01a6fa7691d618f123f9117ce39b25e6478460ceac46c1e650d6b454","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"cf993ba17ba40bd528a08d446bfc7c2e8cf0291f3e202337bcfdafa4ab269a7c","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"db7f6dc7f0fdc1b5acff1339cdf5bf7f11f3ba826aeca626a76d761bec0121a8","production_setup.py":"eac6cda2c2bff17364e72512b70ecfc3b6dad8c70088c1fe83d59f4ebaa395a0","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"b1972d556f28433932a449636755077f7ee485ef90cca412f153bc7f18881368"} \ No newline at end of file +{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"a72c557b69103a52eb477deb8364ded53cd58407b9ba7ab33ccbda74389fec1e","family":"stripe-platform-refund-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"99901e36cb7c4f5882897603c874698d582e859b5d6b08d53cd80975e89aa01c","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"bd8a01adb7a0a6f58bf1ff5f7cd7d0894515c0858b4b8b894d084454d1418df1","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"445a0db1b151e12e8ea235b097acd15d6156195d408d39b7d3095820c127c5a6","expand.py":"9b6dea7793241a767065ac0456bfef5c01cfce3f1121278240eb77fc42ea7e54","family_corpus.py":"41c267688f5a03c83548ab97c1fa7a138a511abe8a4b758ac26cc580d81718a6","family_harness.py":"33b28af00a8aa0d71796fd0b92d0601db4922c5a418a2d240acc678fff32f82d","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"cd16fda3865fa6c9ab382c7ff3e4f91713b1d1399a3e89e2123d0fb7a6abb4d1","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"ae63062de1bbcbf26691d8db7bc50926e8af5009b5fa4e3e784e22e896ee78ce","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"89f50f5bc8bccbd1219074b08d59baadf14140374d09656f6b00c3a2faedaa0e","production_setup.py":"84153c0a3bceb4f1c4d3b355c489d1c56a4552052b9fb8fcf66aadf0d65bb053","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"b7f54a3261de95c8a74ff327a53ae965bfff8156297e2020d66170bf64c35ced"} \ No newline at end of file From 1ccfc09ab769069d86dc739f0709d26b64a0631e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:16:05 +0000 Subject: [PATCH 059/136] fix(release): refresh AP074 semantic freeze identities --- docs/plans/0074-implementation-status.md | 28 +++++++++++++++-- release/semantic-freeze-versions.toml | 20 ++++++------ release/semantic-freeze.json | 40 ++++++++++++------------ 3 files changed, 56 insertions(+), 32 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c89e58cff..bdf947916 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1476,6 +1476,30 @@ closure regeneration passed after that correction (one artifact-generation test) custody, AP070 Python state-owner removal, installed language/UI, hostile containment and complete adapter/fault/formal/performance evidence still remain. +## User-requested CI triage and inventory correction checkpoint + +- After the explicit user request to delegate CI failures, an isolated CI agent + inspected hosted failures at `c80902ab`. Main implementation continued without + shared-file edits. The first isolated fix `991c223d` was reviewed and integrated + as `9c939036` after the read-only increment `cfaa8596` was committed. +- That fix updates the Python gateway export inventory from 17 to 18 (total190), + the TypeScript declaration digest, Python3.9 runner matrices/artifact names to + Ubuntu24.04, and both qualification family corpus/contract source hashes. + Qualification assumptions and declarations were preserved. The agent reports + the API snapshot check and six focused qualification tests passing; exact + commands/hosted job links are to be recorded with its completed report. +- Hosted preflight also found the semantic freeze stale. Required artifact + construction `cargo xtask semantic-freeze --update` identified nine changed + subjects. Freeze391 and only those subject versions were advanced; regeneration + succeeded. The current formal source closure did not change. This refresh is + not a formal proof execution or a completed hosted gate. +- Remaining reported CI roots include stale native/installed tests expecting + implicit observation, obsolete raw re-observation simulation calls, and demos + lacking exact native effect approval/installation policy. CI fixes must use + actual native authorization/recovery or truthful response-only expectations; + tests/approvals may not be bypassed. Investigation continues in the isolated + checkout, with deeper maintained demo integration still part of AP074. + ## Phase gates | Phase | State | Outstanding gate | @@ -1498,9 +1522,9 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission, prerequisite and managed read charge fixtures | Full adapter concurrency and all units pending | -| A05 | Crash at every persistence/transport boundary | Pending / no / no | Process failpoint journey | +| A05 | Crash at every persistence/transport boundary | Partial / real daemon/recipient crash after receipt before ACK / charged unknown and exact late ACK executed | Remaining persistence/send boundaries and PostgreSQL | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | -| A07 | Revoke between acquisition and disclosure | Partial / socket-file corpus / connection disabled after authentication refuses entry | Independent-process revocation and installed journey pending | +| A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index ca6774d84..3ae0eb254 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 390 +freeze_version = 391 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -7,7 +7,7 @@ freeze_version = 390 # converge. This file is a reviewed release input, never an automatic output. [entries] "auths.core.protocol" = 36 -"auths.frozen-bytes/architecture/dependency-graph.json" = 79 +"auths.frozen-bytes/architecture/dependency-graph.json" = 80 "auths.frozen-bytes/bindings/wasm/auths-proof-wasm/identity-abi-v1.json" = 4 "auths.frozen-bytes/bounded-domains.toml" = 2 "auths.frozen-bytes/core/conformance/v1/manifest.json" = 2 @@ -19,7 +19,7 @@ freeze_version = 390 "auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 60 "auths.frozen-bytes/formal/qualification/aeneas/generated" = 19 "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 16 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 101 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 102 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -45,9 +45,9 @@ freeze_version = 390 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 136 +"auths.identity.protocol" = 137 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 123 +"auths.portable-abi-bindings" = 124 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -56,15 +56,15 @@ freeze_version = 390 "auths.product.external-custody" = 5 "auths.product.facade" = 26 "auths.product.github-issue-address-v2" = 4 -"auths.product.lifecycle" = 16 +"auths.product.lifecycle" = 17 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 133 +"auths.product.public-sdk-contract" = 134 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 -"auths.product.vocabulary" = 26 +"auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 -"auths.release.evolution-contract" = 80 -"auths.release.public-surface" = 390 +"auths.release.evolution-contract" = 81 +"auths.release.public-surface" = 391 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 3de6ab24e..0c2db0488 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 390, + "freezeVersion": 391, "publicSurface": { "rustRoots": [ "auths", @@ -94,7 +94,7 @@ }, { "id": "auths.frozen-bytes/architecture/dependency-graph.json", - "version": 79, + "version": 80, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -102,7 +102,7 @@ "owners": [ "architecture/dependency-graph.json" ], - "sha256": "83fed3f0d16736b93df13412e43e500f91840effd660aa17fb07ad79974c3d8f" + "sha256": "03f3ca98e9dfe0d8aea4e278e84c1398125a4105127a0aec2a035d7d0ae9e6dd" }, { "id": "auths.frozen-bytes/bindings/wasm/auths-proof-wasm/identity-abi-v1.json", @@ -238,7 +238,7 @@ }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 101, + "version": 102, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "915f8024bf84eee17874b1950b71357e2f88027c99b9e0415f3e5a302994bc1f" + "sha256": "e0d7b1b305ab8377a2126ac68c3271a07c8a17b960114e6a428d3a3c67b4c2ee" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 136, + "version": 137, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "e2ea0a25cb7cb7e1f7df12519068b4927846f955d28bf539b08ff84ee9245f14" + "sha256": "ddc32c606618475be1e7d9ef6bbf6b47119c17fd72d2df268f5e473674ecc220" }, { "id": "auths.modular-components", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 123, + "version": 124, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "eb0becad395d73a2365a5e58c05e5f699010e998912e65f004b335cb8f87c9a5" + "sha256": "51fed0f1e4dd7d44df657588052b6790615b917307c8cd8ae13fd9f073640bde" }, { "id": "auths.product.bounded-domains", @@ -784,7 +784,7 @@ }, { "id": "auths.product.lifecycle", - "version": 16, + "version": 17, "classification": "frozen-meaning", "categories": [ "reservation-state", @@ -796,12 +796,12 @@ "owners": [ "product/fixtures/v1/lifecycle/registry.toml", "product/runtime/auths-lifecycle/src", - "product/stores/auths-stores/migrations/postgres_lifecycle_v6.sql", + "product/stores/auths-stores/migrations/postgres_lifecycle_v8.sql", "product/stores/auths-stores/src/lifecycle.rs", "product/stores/auths-stores/tests/postgres_lifecycle.rs", "product/stores/auths-stores/tests/postgres_tls" ], - "sha256": "c331eb406c523401d940e8c67fce96200465720920fc74196b2cdbfa11b345d0" + "sha256": "c820ceb9640850fb52d9afe5b08fd8cfe1d81fd96dc0356f70a1c8a26ce23a36" }, { "id": "auths.product.mcp-closed-execution", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 133, + "version": 134, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "db870f5442115d2e11aa3d5df062ac1c790b87a1a721a79bde0a658577577a73" + "sha256": "d8fa5528cf5f966837c08a1905440b6410f697b2be02ac16793a34aa23930b3e" }, { "id": "auths.product.receipts", @@ -947,7 +947,7 @@ }, { "id": "auths.product.vocabulary", - "version": 26, + "version": 27, "classification": "frozen-meaning", "categories": [ "customer-vocabulary", @@ -965,7 +965,7 @@ "product/sdk/auths-sdk/Cargo.toml", "xtask/src/sdk_vocabulary.rs" ], - "sha256": "f40e2656eed0d34ce4914753a92e4d67806d40b6b20bb7693cf13d36bb01575f" + "sha256": "479285a6ee17be76f01fde6b88f2b3e75eea73bf4a37084f080e7c43650c0dde" }, { "id": "auths.release.benchmark-contract", @@ -986,7 +986,7 @@ }, { "id": "auths.release.evolution-contract", - "version": 80, + "version": 81, "classification": "frozen-meaning", "categories": [ "version-axes", @@ -1007,11 +1007,11 @@ "release/fixtures/evolution", "xtask/src/evolution_policy.rs" ], - "sha256": "81b3b9de3f851312b50603809a810d465f041d32a945feee9f65d9930955e85e" + "sha256": "03adbcadcbbc9426f3be6add48e7be41e1ea12a2feed62bfa67befc3b2e899fc" }, { "id": "auths.release.public-surface", - "version": 390, + "version": 391, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "e626e377115d1ac26a3645c4f2722de232c316658b8ca8975481de59acfce2c9" + "sha256": "5b9e0b3ef2ba88cbc049260e56c294d50fe071ff3c5689929361543002ce7714" } ] } From fb5c5a0ac8ce36a4d1789a90558bcaa4cf64de97 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:22:30 +0000 Subject: [PATCH 060/136] refactor(demo): freeze concrete Drive metadata reference --- compliance.toml | 1 + .../src/employee_read_demo/google_drive.py | 39 +-- .../src/employee_read_demo/google_metadata.py | 61 +++++ .../tests/test_google_metadata_reference.py | 91 +++++++ .../examples/google-metadata-reference.json | 229 ++++++++++++++++++ docs/plans/0074-implementation-status.md | 32 ++- .../0009-bound-effect-and-recovery.md | 22 ++ ...ound-effects-and-recovery-state-machine.md | 10 + 8 files changed, 449 insertions(+), 36 deletions(-) create mode 100644 demos/google-employee-delegation/broker/src/employee_read_demo/google_metadata.py create mode 100644 demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py create mode 100644 demos/google-employee-delegation/contracts/examples/google-metadata-reference.json diff --git a/compliance.toml b/compliance.toml index 125b2dc83..0e448ba17 100644 --- a/compliance.toml +++ b/compliance.toml @@ -2166,6 +2166,7 @@ configuration_inputs = ["operator-pins", "trusted-context-template", "demo-co-ex security_state = ["task-ledger", "challenge-ledger", "provider-attempt-ledger", "release-commitment", "broker-runtime-lock", "encrypted-employee-credentials", "company-scoped-browser-sessions"] [packages.auths-google-employee-delegation-demo.claims] +metadata-domain-reference = ["demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py#test_metadata_reference_fixture_is_current"] demo-conformance-fixture = ["demos/google-employee-delegation/broker/tests/test_demo_co_contract.py#test_local_fixture_is_valid_but_never_imported_as_live"] runtime-enforcement-boundary = ["demos/google-employee-delegation/broker/tests/test_admission.py#test_replay_and_release_after_revocation_are_denied", "demos/google-employee-delegation/broker/tests/test_admission.py#test_two_processes_share_atomic_capacity_and_provider_byte_reservations", "demos/google-employee-delegation/broker/tests/test_admission.py#test_crashed_broker_reopens_slot_without_refunding_charges", "demos/google-employee-delegation/broker/tests/test_google_drive.py#test_deadline_interrupts_a_trickling_header_parser", "demos/google-employee-delegation/broker/tests/test_oauth_custody.py#test_offboarding_closes_admission_and_token_custody", "demos/google-employee-delegation/broker/tests/test_workbench.py#test_other_company_browser_cookie_cannot_authorize_this_workbench"] receipt-producer-consumer = ["demos/google-employee-delegation/broker/tests/test_task_authority.py#test_real_chain_and_exact_action_pass_read_boundary", "demos/google-employee-delegation/broker/tests/test_admission.py#test_receipt_write_failure_rolls_back_release_commitment"] diff --git a/demos/google-employee-delegation/broker/src/employee_read_demo/google_drive.py b/demos/google-employee-delegation/broker/src/employee_read_demo/google_drive.py index b9aa907a3..723b3972b 100644 --- a/demos/google-employee-delegation/broker/src/employee_read_demo/google_drive.py +++ b/demos/google-employee-delegation/broker/src/employee_read_demo/google_drive.py @@ -4,7 +4,6 @@ import http.client import ipaddress -import json import queue import socket import ssl @@ -18,23 +17,16 @@ from .contracts import MAX_METADATA_BYTES, ReadCommand, TaskDescriptor from .token_store import TokenVault +from .google_metadata import ( + DriveRepresentation, GoogleDenied, GoogleUnavailable, validate_metadata, +) HOST = "www.googleapis.com" -DOC_MIME = "application/vnd.google-apps.document" -TEXT_MIME = "text/plain" METADATA_LIMIT = MAX_METADATA_BYTES REQUEST_DEADLINE_SECONDS = 15 _DNS_SLOTS = threading.BoundedSemaphore(4) -class GoogleDenied(PermissionError): - """Provider refusal; no private file detail is included.""" - - -class GoogleUnavailable(RuntimeError): - """Transport or malformed provider result; retry needs fresh admission.""" - - @dataclass class ProviderTrace: """Observed Drive GETs and body bytes; capacity is reserved separately.""" @@ -217,7 +209,7 @@ def __init__(self, task: TaskDescriptor, tokens: TokenVault) -> None: def set_attempt_observer(self, observer: ProviderAttemptObserver) -> None: self.trace.observer = observer - def _metadata(self, command: ReadCommand) -> tuple[dict, str]: + def _metadata(self, command: ReadCommand) -> tuple[DriveRepresentation, str]: if command not in self.task.calls(): raise GoogleDenied("document is outside approved task") if int(time.time()) >= self.task.expires_at: @@ -232,23 +224,7 @@ def _metadata(self, command: ReadCommand) -> tuple[dict, str]: raise GoogleDenied("Google refused document metadata") if status != 200 or "application/json" not in content_type: raise GoogleUnavailable("Google metadata request was unsuccessful") - try: - metadata = json.loads(body) - except (ValueError, UnicodeDecodeError) as error: - raise GoogleUnavailable("Google metadata is malformed") from error - if not isinstance(metadata, dict) or metadata.get("id") != command.file_id or metadata.get("trashed") is True: - raise GoogleDenied("Google document metadata did not match") - capabilities = metadata.get("capabilities") - if not isinstance(capabilities, dict) or capabilities.get("canDownload") is not True: - raise GoogleDenied("Google does not permit download") - mime = metadata.get("mimeType") - if mime not in {DOC_MIME, TEXT_MIME}: - raise GoogleDenied("unsupported Google document type") - if mime == TEXT_MIME: - size = metadata.get("size") - if size is not None and (not str(size).isdecimal() or int(size) > command.max_bytes): - raise GoogleDenied("document exceeds approved byte limit") - return metadata, lease.access_token + return validate_metadata(body, command), lease.access_token def inspect_exact(self, command: ReadCommand) -> None: """Check employee-readable metadata without fetching document content.""" @@ -259,10 +235,9 @@ def inspect_exact(self, command: ReadCommand) -> None: def read_exact(self, command: ReadCommand) -> bytes: self.trace = ProviderTrace(observer=self.trace.observer, task_expires_at=self.task.expires_at) - metadata, access_token = self._metadata(command) + representation, access_token = self._metadata(command) file_id = quote(command.file_id, safe="") - mime = metadata["mimeType"] - if mime == DOC_MIME: + if representation is DriveRepresentation.GOOGLE_DOCUMENT: path = f"/drive/v3/files/{file_id}/export?mimeType=text%2Fplain" else: path = f"/drive/v3/files/{file_id}?alt=media" diff --git a/demos/google-employee-delegation/broker/src/employee_read_demo/google_metadata.py b/demos/google-employee-delegation/broker/src/employee_read_demo/google_metadata.py new file mode 100644 index 000000000..950206f4e --- /dev/null +++ b/demos/google-employee-delegation/broker/src/employee_read_demo/google_metadata.py @@ -0,0 +1,61 @@ +"""Concrete Drive metadata reference, separate from transport and admission. + +This application-owned domain reference grants no read, custody or disclosure +capability. AP074's native recipe cutover must compare against its corpus and +explicitly document stricter decoding instead of importing this code at runtime. +""" + +from __future__ import annotations + +from enum import Enum +import json + +from .contracts import MAX_METADATA_BYTES, ReadCommand + + +class GoogleDenied(PermissionError): + """Provider refusal; no private file detail is included.""" + + +class GoogleUnavailable(RuntimeError): + """Transport or malformed result; no retry authority is created.""" + + +class DriveRepresentation(Enum): + GOOGLE_DOCUMENT = "application/vnd.google-apps.document" + PLAIN_TEXT = "text/plain" + + +def validate_metadata(body: bytes, command: ReadCommand) -> DriveRepresentation: + """Validate one bounded transport response against the exact read resource. + + The caller owns status/media/time checks; the finite byte cap is rechecked. This reference preserves the + existing optional size/trashed behavior and Python JSON duplicate handling. + Native gateway decoding must additionally reject duplicate members. + """ + if len(body) > MAX_METADATA_BYTES: + raise GoogleUnavailable("Google metadata exceeds byte limit") + try: + metadata = json.loads(body) + except (ValueError, UnicodeDecodeError) as error: + raise GoogleUnavailable("Google metadata is malformed") from error + if (not isinstance(metadata, dict) or metadata.get("id") != command.file_id + or metadata.get("trashed") is True): + raise GoogleDenied("Google document metadata did not match") + capabilities = metadata.get("capabilities") + if not isinstance(capabilities, dict) or capabilities.get("canDownload") is not True: + raise GoogleDenied("Google does not permit download") + try: + representation = DriveRepresentation(metadata.get("mimeType")) + except (ValueError, TypeError) as error: + raise GoogleDenied("unsupported Google document type") from error + if representation is DriveRepresentation.PLAIN_TEXT: + size = metadata.get("size") + if size is not None: + try: + permitted = str(size).isdecimal() and int(size) <= command.max_bytes + except ValueError: + permitted = False + if not permitted: + raise GoogleDenied("document exceeds approved byte limit") + return representation diff --git a/demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py b/demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py new file mode 100644 index 000000000..5713172cf --- /dev/null +++ b/demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py @@ -0,0 +1,91 @@ +"""Freeze the concrete AP070 metadata reference before native capability extraction.""" +from __future__ import annotations + +import json +import os +from pathlib import Path +import unittest + +from employee_read_demo.contracts import MAX_METADATA_BYTES, ReadCommand +from employee_read_demo.google_metadata import ( + DriveRepresentation, GoogleDenied, GoogleUnavailable, validate_metadata, +) + + +class GoogleMetadataReferenceTests(unittest.TestCase): + def test_metadata_reference_fixture_is_current(self) -> None: + command = ReadCommand("google-drive-document-read/v1", "atlas", "instance", "task", + "a" * 64, "connection", 1, "file-A", "text", 1024) + command.validate() + base = {"id": "file-A", "mimeType": DriveRepresentation.PLAIN_TEXT.value, + "capabilities": {"canDownload": True}} + cases = [] + declarations = [ + ("plain-no-size", {}, "plain-text"), + ("size-at-limit", {"size": "1024"}, "plain-text"), + ("size-integer", {"size": 1024}, "plain-text"), + ("size-zero", {"size": "0"}, "plain-text"), + ("size-leading-zero", {"size": "01024"}, "plain-text"), + ("size-unicode-decimal", {"size": "١٠٢٤"}, "plain-text"), + ("size-null", {"size": None}, "plain-text"), + ("size-over-limit", {"size": "1025"}, "denied"), + ("size-negative", {"size": -1}, "denied"), + ("size-float", {"size": 1.0}, "denied"), + ("size-boolean", {"size": True}, "denied"), + ("size-plus", {"size": "+1"}, "denied"), + ("size-decimal-overflow", {"size": "9" * 5000}, "denied"), + ("trashed", {"trashed": True}, "denied"), + ("trashed-false", {"trashed": False}, "plain-text"), + ("trashed-null", {"trashed": None}, "plain-text"), + ("trashed-nonboolean", {"trashed": "true"}, "plain-text"), + ("different-resource", {"id": "file-B"}, "denied"), + ("numeric-resource", {"id": 1}, "denied"), + ("download-denied", {"capabilities": {"canDownload": False}}, "denied"), + ("download-number", {"capabilities": {"canDownload": 1}}, "denied"), + ("download-absent", {"capabilities": {}}, "denied"), + ("capabilities-null", {"capabilities": None}, "denied"), + ("document", {"mimeType": DriveRepresentation.GOOGLE_DOCUMENT.value}, "google-document"), + ("document-size-not-content-bound", {"mimeType": DriveRepresentation.GOOGLE_DOCUMENT.value, "size": "1025"}, "google-document"), + ("unsupported-mime", {"mimeType": "application/pdf"}, "denied"), + ("mime-null", {"mimeType": None}, "denied"), + ("mime-array", {"mimeType": []}, "denied"), + ] + encoded = [(name, json.dumps({**base, **change}, ensure_ascii=False).encode(), expected) + for name, change, expected in declarations] + encoded.extend([ + ("nonobject", b"[]", "denied"), + ("missing-identity", b'{}', "denied"), + ("invalid-json", b"{", "unavailable"), + ("invalid-utf8", b"\xff", "unavailable"), + ("utf16-reference", json.dumps(base).encode("utf-16-le"), "plain-text"), + ("metadata-limit", json.dumps(base).encode().ljust(MAX_METADATA_BYTES, b" "), "plain-text"), + ("metadata-limit-plus-one", json.dumps(base).encode().ljust(MAX_METADATA_BYTES+1, b" "), "unavailable"), + ("duplicate-last-wins-reference", b'{"id":"file-B","id":"file-A","mimeType":"text/plain","capabilities":{"canDownload":true}}', "plain-text"), + ]) + for name, body, expected in encoded: + with self.subTest(name=name): + try: + result = validate_metadata(body, command) + actual = "google-document" if result is DriveRepresentation.GOOGLE_DOCUMENT else "plain-text" + except GoogleDenied: + actual = "denied" + except GoogleUnavailable: + actual = "unavailable" + self.assertEqual(actual, expected) + cases.append({"case": name, "metadata_hex": body.hex(), "reference_result": actual, + "native_stricter_decode_required": name in {"duplicate-last-wins-reference", "utf16-reference", "trashed-nonboolean", "size-unicode-decimal"}}) + artifact = json.dumps({"schema": "auths.google-drive-metadata-reference/1", + "scope": "pure concrete AP070 metadata reference; no transport, authority, state, native equivalence or live-provider claim", + "file_id": command.file_id, "maximum_content_bytes": command.max_bytes, + "hardening": ["Native bounded UTF-8 JSON must reject duplicate members, alternate encodings, nonboolean trash flags and non-ASCII decimal sizes even when this reference accepts them.", + "Non-string MIME values and oversized decimal conversions produce typed denial instead of Python runtime errors.", + "Status/media/transport limits and post-metadata freshness remain separate prerequisites."], + "cases": cases}, indent=2, ensure_ascii=False).encode()+b"\n" + destination = Path(__file__).resolve().parents[2]/"contracts"/"examples"/"google-metadata-reference.json" + if os.environ.get("AUTHS_UPDATE_FIXTURES"): + destination.write_bytes(artifact) + self.assertEqual(destination.read_bytes(), artifact) + + +if __name__ == "__main__": + unittest.main() diff --git a/demos/google-employee-delegation/contracts/examples/google-metadata-reference.json b/demos/google-employee-delegation/contracts/examples/google-metadata-reference.json new file mode 100644 index 000000000..73af20f34 --- /dev/null +++ b/demos/google-employee-delegation/contracts/examples/google-metadata-reference.json @@ -0,0 +1,229 @@ +{ + "schema": "auths.google-drive-metadata-reference/1", + "scope": "pure concrete AP070 metadata reference; no transport, authority, state, native equivalence or live-provider claim", + "file_id": "file-A", + "maximum_content_bytes": 1024, + "hardening": [ + "Native bounded UTF-8 JSON must reject duplicate members, alternate encodings, nonboolean trash flags and non-ASCII decimal sizes even when this reference accepts them.", + "Non-string MIME values and oversized decimal conversions produce typed denial instead of Python runtime errors.", + "Status/media/transport limits and post-metadata freshness remain separate prerequisites." + ], + "cases": [ + { + "case": "plain-no-size", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-at-limit", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a202231303234227d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-integer", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20313032347d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-zero", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a202230227d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-leading-zero", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20223031303234227d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-unicode-decimal", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a2022d9a1d9a0d9a2d9a4227d", + "reference_result": "plain-text", + "native_stricter_decode_required": true + }, + { + "case": "size-null", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a206e756c6c7d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "size-over-limit", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a202231303235227d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "size-negative", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a202d317d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "size-float", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20312e307d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "size-boolean", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20747275657d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "size-plus", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20222b31227d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "size-decimal-overflow", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a20223939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939393939227d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "trashed", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202274726173686564223a20747275657d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "trashed-false", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202274726173686564223a2066616c73657d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "trashed-null", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202274726173686564223a206e756c6c7d", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "trashed-nonboolean", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202274726173686564223a202274727565227d", + "reference_result": "plain-text", + "native_stricter_decode_required": true + }, + { + "case": "different-resource", + "metadata_hex": "7b226964223a202266696c652d42222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "numeric-resource", + "metadata_hex": "7b226964223a20312c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "download-denied", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a2066616c73657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "download-number", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20317d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "download-absent", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a207b7d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "capabilities-null", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a2022746578742f706c61696e222c20226361706162696c6974696573223a206e756c6c7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "document", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a20226170706c69636174696f6e2f766e642e676f6f676c652d617070732e646f63756d656e74222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "google-document", + "native_stricter_decode_required": false + }, + { + "case": "document-size-not-content-bound", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a20226170706c69636174696f6e2f766e642e676f6f676c652d617070732e646f63756d656e74222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d2c202273697a65223a202231303235227d", + "reference_result": "google-document", + "native_stricter_decode_required": false + }, + { + "case": "unsupported-mime", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a20226170706c69636174696f6e2f706466222c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "mime-null", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a206e756c6c2c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "mime-array", + "metadata_hex": "7b226964223a202266696c652d41222c20226d696d6554797065223a205b5d2c20226361706162696c6974696573223a207b2263616e446f776e6c6f6164223a20747275657d7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "nonobject", + "metadata_hex": "5b5d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "missing-identity", + "metadata_hex": "7b7d", + "reference_result": "denied", + "native_stricter_decode_required": false + }, + { + "case": "invalid-json", + "metadata_hex": "7b", + "reference_result": "unavailable", + "native_stricter_decode_required": false + }, + { + "case": "invalid-utf8", + "metadata_hex": "ff", + "reference_result": "unavailable", + "native_stricter_decode_required": false + }, + { + "case": "utf16-reference", + "metadata_hex": "7b0022006900640022003a0020002200660069006c0065002d00410022002c00200022006d0069006d006500540079007000650022003a002000220074006500780074002f0070006c00610069006e0022002c00200022006300610070006100620069006c006900740069006500730022003a0020007b002200630061006e0044006f0077006e006c006f006100640022003a00200074007200750065007d007d00", + "reference_result": "plain-text", + "native_stricter_decode_required": true + }, + { + "case": "metadata-limit", + "metadata_hex": "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", + "reference_result": "plain-text", + "native_stricter_decode_required": false + }, + { + "case": "metadata-limit-plus-one", + "metadata_hex": "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", + "reference_result": "unavailable", + "native_stricter_decode_required": false + }, + { + "case": "duplicate-last-wins-reference", + "metadata_hex": "7b226964223a2266696c652d42222c226964223a2266696c652d41222c226d696d6554797065223a22746578742f706c61696e222c226361706162696c6974696573223a7b2263616e446f776e6c6f6164223a747275657d7d", + "reference_result": "plain-text", + "native_stricter_decode_required": true + } + ] +} diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index bdf947916..f3835cafd 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1482,15 +1482,15 @@ closure regeneration passed after that correction (one artifact-generation test) inspected hosted failures at `c80902ab`. Main implementation continued without shared-file edits. The first isolated fix `991c223d` was reviewed and integrated as `9c939036` after the read-only increment `cfaa8596` was committed. -- That fix updates the Python gateway export inventory from 17 to 18 (total190), - the TypeScript declaration digest, Python3.9 runner matrices/artifact names to - Ubuntu24.04, and both qualification family corpus/contract source hashes. +- That fix updates the Python gateway export inventory from 17 to 18 (total 190), + the TypeScript declaration digest, Python 3.9 runner matrices/artifact names to + Ubuntu 24.04, and both qualification family corpus/contract source hashes. Qualification assumptions and declarations were preserved. The agent reports the API snapshot check and six focused qualification tests passing; exact commands/hosted job links are to be recorded with its completed report. - Hosted preflight also found the semantic freeze stale. Required artifact construction `cargo xtask semantic-freeze --update` identified nine changed - subjects. Freeze391 and only those subject versions were advanced; regeneration + subjects. Freeze 391 and only those subject versions were advanced; regeneration succeeded. The current formal source closure did not change. This refresh is not a formal proof execution or a completed hosted gate. - Remaining reported CI roots include stale native/installed tests expecting @@ -1500,6 +1500,30 @@ closure regeneration passed after that correction (one artifact-generation test) tests/approvals may not be bypassed. Investigation continues in the isolated checkout, with deeper maintained demo integration still part of AP074. +## AP070 concrete metadata reference checkpoint + +- Based on pushed `1ccfc09a`. The native content-only installation is available; + the next provider-specific gap is the metadata gate preceding a Drive content + GET. Current AP070 Python admission/release still remains to be removed. +- The Drive reader now calls one pure concrete metadata validator returning a + closed document/plain-text representation. Custody, transport, status/media, + task checks and state decisions remain outside that validator. Existing request + selection uses the typed result. The existing 16 KiB bound is checked again; + malformed MIME and excessive decimal conversions return typed refusal. +- A deterministic domain corpus freezes identity, download restriction, MIME, + optional size/trashed semantics, malformed/nonobject inputs and byte boundaries. + It explicitly labels historical duplicate/alternate-encoding, nonboolean trash + and Unicode decimal acceptance as cases requiring stricter native refusal. + Matching a weak historical parser is not a native acceptance requirement. +- Required artifact construction: + `PYTHONPATH=demos/google-employee-delegation/broker/src AUTHS_UPDATE_FIXTURES=1 python3 demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py` + passed one generator in 0.002 seconds. It imports only the pure domain contract; + no native package, Google credential, provider call or cloud account is used. +- This is concrete reference evidence ahead of extraction, not a completed native + metadata gate or AP070 cutover. Full native/compiler/journal/freshness parity, + both supported content paths, token refresh custody, bindings/UI and removal of + the competing Python shared state owner remain open. No A01–A22 gate closes. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index c82bd0547..95a6bd5c5 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -728,3 +728,25 @@ trust in that journey contains only read/release permissions. Existing mixed read/write process composition still passes. No new provider capability, Google metadata interpretation, AP070 policy semantics, formal theorem or adapter assumption is extracted by this change; those complete gates remain pending. + + +### Concrete Drive metadata reference before extraction + +The AP070 Drive reference now separates bounded metadata validation from token +custody, transport, admission and release. The existing reader invokes that same +pure domain function and selects its existing export/media path from a closed +representation enum. No native capability, account approval, budget rule or +provider callback is inferred. Missing/mismatched identity, download restriction, +MIME selection and optional size/trashed behavior are frozen in +`demos/google-employee-delegation/contracts/examples/google-metadata-reference.json`. +The pure function rechecks the existing 16 KiB bound and returns typed denial for +malformed MIME values or decimal conversion overflow rather than runtime errors. + +The reference records historical last-member-wins JSON, alternate encoding, +nonboolean trashed values and Unicode decimal acceptance as explicit divergences: +native bounded UTF-8/typed decoding must refuse them. It does not authorize +weakening native parsing to match a weaker historical reference. Status/media, +lease, native resource authority, prerequisite freshness and actual content entry +remain separate gates. Native metadata capability/refinement, request selection, +refresh custody and AP070's Python journal removal are still required; this +provider reference is an extraction input, not proof of their implementation. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 25042012c..b21e30da1 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -623,6 +623,16 @@ public test keys simulating the reviewer, actor and recipient. They do not close human approval UI, installed language packages, hostile UID/egress containment, PostgreSQL, every crash boundary or live-provider qualification gates. +The AP070 concrete Drive metadata reference is frozen separately from native +acquisition in `google-metadata-reference.json`. It exercises exact file identity, +required download capability, document/plain-text selection, optional size and +trashed semantics, malformed input and the existing 16 KiB bound. The reference +reader uses one typed domain validator; malformed MIME/decimal inputs deny. +Historical duplicate, alternate-encoding, nonboolean-trash and Unicode-size +acceptance are explicitly marked for stricter native refusal. This corpus is an +input to the required native metadata capability/differential extraction; it does +not complete that capability, token refresh or Python journal cutover. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization From 4bbff153dbf2edd44f354a7083633c4f2bacd2f6 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:22:54 +0000 Subject: [PATCH 061/136] fix(gateway): exercise native approvals and explicit recovery in CI harnesses --- .../external/gateway_observation_consumer.py | 22 +- .../packed-gateway-observation.test.js | 17 +- .../gateway/tools/operator-simulation.py | 7 +- .../runtime/auths-gateway/src/audit_tests.rs | 5 +- .../runtime/auths-gateway/src/bounds_tests.rs | 17 +- product/runtime/auths-gateway/src/effect.rs | 6 +- .../auths-gateway/src/effect/prerequisite.rs | 2 +- product/runtime/auths-gateway/src/harness.rs | 153 ++++++++++-- .../auths-gateway/src/observed_tests.rs | 217 +++++++++++++++--- 9 files changed, 371 insertions(+), 75 deletions(-) diff --git a/bindings/python/external/gateway_observation_consumer.py b/bindings/python/external/gateway_observation_consumer.py index a0a2c7a9a..3500759fe 100644 --- a/bindings/python/external/gateway_observation_consumer.py +++ b/bindings/python/external/gateway_observation_consumer.py @@ -48,7 +48,7 @@ GatewayDenied, GatewayEndpoint, GatewayIndeterminate, - GatewayObservedByProvider, + GatewayResponseRecorded, GatewayResult, GatewaySignedObservation, ) @@ -142,6 +142,7 @@ async def _control(socket: Path, request: dict[str, object]) -> dict[str, int]: class Journey: def __init__(self, setup: dict[str, object], signer: AgentSigner) -> None: + self.approval = b"" self.setup = setup self.signer = signer self.control = Path(cast(str, setup["control_socket"])) @@ -232,7 +233,7 @@ async def refused_before_lease( raise AssertionError("the SDK authored a refused replacement") before = await self.counts() proof, action = self.author_unchecked(command, observation, now) - result = await self.client.submit(proof=proof, action=action) + result = await self.client.submit(proof=proof, action=action, approval=self.approval) assert result == expected, result assert await self.counts() == before, "no write and no credential lease" @@ -257,11 +258,18 @@ async def journey(harness: Path, state: Path) -> None: proof, action = await run.author( run.command("journey-1", "Pending", "Approved"), observed, NOW, ) - written = await run.client.submit(proof=proof, action=action) - assert isinstance(written, GatewayObservedByProvider), written + # Only the private test control plane issues this fixed-key native oracle approval. + response = await _control_response(run.control, { + "command": "reference-approval", + "proof_b64": base64.urlsafe_b64encode(proof).decode().rstrip("="), + "action_b64": base64.urlsafe_b64encode(action).decode().rstrip("="), + }) + run.approval = _bytes(cast(str, response["approval_b64"])) + written = await run.client.submit(proof=proof, action=action, approval=run.approval) + assert isinstance(written, GatewayResponseRecorded), written assert written.status == 200 - assert await run.counts() == (1, 3), ( - "one write; the observation, the write, and its read-back each lease" + assert await run.counts() == (1, 2), ( + "one explicit pre-read and one write; no implicit post-write read-back" ) await _control(run.control, { @@ -279,7 +287,7 @@ async def journey(harness: Path, state: Path) -> None: run.command("journey-3", "Pending", "Approved"), changed, aged, GatewayIndeterminate("observation-missing"), ) - assert await run.counts() == (1, 4), "only the second read-back leased again" + assert await run.counts() == (1, 3), "only the second read-back leased again" finally: process.kill() process.wait() diff --git a/bindings/typescript/test/gateway/packed-gateway-observation.test.js b/bindings/typescript/test/gateway/packed-gateway-observation.test.js index a081ea854..240f1e530 100644 --- a/bindings/typescript/test/gateway/packed-gateway-observation.test.js +++ b/bindings/typescript/test/gateway/packed-gateway-observation.test.js @@ -137,6 +137,7 @@ try { builder.bindActionEvidence(actorEvidence.type, actorEvidence.mediaType, actorEvidence.bytes); return { proof: builder.finish(signed, prepared.action, context).proofCbor, action: prepared.action }; }; + let approval; const refusedBeforeLease = async (value, observation, now, expected) => { try { await author(value, observation, now); @@ -145,7 +146,7 @@ try { if (!(error instanceof AuthoringUnsuccessful) || error.code !== expected.code) throw error; } const before = await counts(); - const result = await client.submit(await authorUnchecked(value, observation, now)); + const result = await client.submit({ ...await authorUnchecked(value, observation, now), approval }); if (JSON.stringify(result) !== JSON.stringify(expected)) { throw new Error("gateway result " + JSON.stringify(result)); } @@ -157,7 +158,13 @@ try { const observed = await readBack(); const first = await author(command("journey-1", "Pending", "Approved"), observed, NOW); - const written = await client.submit({ proof: first.proof, action: first.action }); + // The isolated test control plane signs a native fixed-key oracle approval. + // Reuse it for denied proofs to prove verification still refuses before entry. + approval = bytes((await control({ command: "reference-approval", + proof_b64: Buffer.from(first.proof).toString("base64url"), + action_b64: Buffer.from(first.action).toString("base64url"), + })).approval_b64); + const written = await client.submit({ proof: first.proof, action: first.action, approval }); const afterWrite = await counts(); await control({ command: "set-record", record_id: record.record_id, status: "Pending" }); const changed = await readBack(); @@ -186,11 +193,11 @@ test("packed npm consumer attaches a gateway read-back and is refused once it is const output = execFileSync(process.execPath, ["consumer.mjs", harness, vectors], { cwd: directory, encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] }); assert.deepEqual(JSON.parse(output), { - written: { outcome: "observed-by-provider", status: 200 }, - afterWrite: [1, 3], + written: { outcome: "response-recorded", status: 200 }, + afterWrite: [1, 2], conditionFalse: { outcome: "denied", code: "observation-condition-false" }, stale: { outcome: "indeterminate", code: "observation-missing" }, - final: [1, 4], + final: [1, 3], }); } finally { await rm(directory, { recursive: true, force: true }); diff --git a/deployment/gateway/tools/operator-simulation.py b/deployment/gateway/tools/operator-simulation.py index a1d80bcba..418aec295 100644 --- a/deployment/gateway/tools/operator-simulation.py +++ b/deployment/gateway/tools/operator-simulation.py @@ -231,8 +231,11 @@ def exercise(self): and one["credential_held"] and two["credential_held"], "simulation.rotation-diverged") self.json("redacted-support", ["support-bundle", "--state-dir", first], env={"AUTHS_SIMULATION_CANARY": self.secret.decode()}) - self.admin(first, "reobserve", extra=["--operation-id", "simulation-no-such-operation"], - success=False, code="gateway.reobserve.not-observable") + # AP074 removed raw re-observation. An operator must author and approve + # an independent recovery effect; the obsolete command stays unavailable. + self.run("refuse-obsolete-reobserve", ["reobserve", "--state-dir", first, + "--operation-id", "simulation-no-such-operation"], success=False, + code="unrecognized subcommand 'reobserve'") tuple_bytes = self.run("deployment-tuple", ["qualification-status", "--state-dir", first, "--tuple"]) tuple_path = self.work / "tuple.json" tuple_path.write_bytes(tuple_bytes) diff --git a/product/runtime/auths-gateway/src/audit_tests.rs b/product/runtime/auths-gateway/src/audit_tests.rs index 30c2c198e..e34a582f8 100644 --- a/product/runtime/auths-gateway/src/audit_tests.rs +++ b/product/runtime/auths-gateway/src/audit_tests.rs @@ -355,7 +355,10 @@ async fn audit_checks_the_pre_entry_observations() { let submission = harness.sign(Some(read_back_requirement()), &arguments, &[observation]); let result = harness.submit(&submission, NOW + 30).await; assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "{result:?}" ); let outcome = signed_bytes(harness.outcome("pre-entry", NOW + 31).await); diff --git a/product/runtime/auths-gateway/src/bounds_tests.rs b/product/runtime/auths-gateway/src/bounds_tests.rs index 776091195..448851446 100644 --- a/product/runtime/auths-gateway/src/bounds_tests.rs +++ b/product/runtime/auths-gateway/src/bounds_tests.rs @@ -400,7 +400,7 @@ async fn delegates_share_their_parent_counter() { let (writes, _reads, leases) = principals.harness.provider.counts(); assert_eq!( (writes, leases), - (2, 4), + (2, 2), "the exhausted action never leases" ); } @@ -423,9 +423,8 @@ async fn bounded_hostile_suite(backend: Backend) { case.id ); assert_eq!( - leases, - 2 * case.provider_entries, - "{}: leases only for an entered write and its read-back", + leases, case.provider_entries, + "{}: leases only for an entered write; no implicit read-back", case.id ); } @@ -797,8 +796,8 @@ async fn bounded_agent_needs_two_managers_and_stays_inside_its_bound() { let (writes, _reads, leases) = quorum.harness.provider.counts(); assert_eq!( (writes, leases), - (1, 2), - "refused refunds never lease; the entered one leases for its write and read-back" + (1, 1), + "refused refunds never lease; the entered one leases only for its write" ); } @@ -817,7 +816,7 @@ async fn an_unbounded_actor_is_admitted_without_a_count() { assert_eq!(verdict(&result), ("entered", None), "{operation}"); } let (writes, _reads, leases) = quorum.harness.provider.counts(); - assert_eq!((writes, leases), (2, 4), "no bound, no ceiling, no count"); + assert_eq!((writes, leases), (2, 2), "no bound, no ceiling, no count"); } #[tokio::test] @@ -856,7 +855,7 @@ async fn one_bounded_branch_is_admitted_and_counted_against_its_actor() { "another agent's count is separate" ); let (writes, _reads, leases) = quorum.harness.provider.counts(); - assert_eq!((writes, leases), (2, 4)); + assert_eq!((writes, leases), (2, 2)); } #[tokio::test] @@ -1040,7 +1039,7 @@ async fn offline_audit_reproduces_every_gateway_decision() { .provider_result .as_ref() .expect("provider result"); - assert_eq!(result.stage, "observed-by-provider"); + assert_eq!(result.stage, "response-recorded"); assert_eq!(result.http_status, Some(200)); assert_eq!( report.entries[3] diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 9214f947a..3844994eb 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -227,7 +227,7 @@ pub(crate) fn approve_driver_fixture( ) } -#[cfg(any(test, feature = "testkit-harness"))] +#[cfg(test)] pub(crate) fn approve_recipe_fixture( command: VerifiedCommand, recipe: &CompiledRecipe, @@ -240,7 +240,7 @@ pub(crate) fn approve_recipe_fixture( approve_driver_with_plan(command, *recipe.digest(), now, approval, prerequisites) } -#[cfg(any(test, feature = "testkit-harness"))] +#[cfg(test)] fn approve_driver_with_plan( command: VerifiedCommand, recipe_digest: [u8; 32], @@ -326,7 +326,7 @@ pub(crate) fn fixture_policy() -> Result { } /// Store/driver reference data only; never an installed authorization path. -#[cfg(any(test, feature = "testkit-harness"))] +#[cfg(test)] pub(crate) fn store_binding_fixture( request: &ClosedProviderRequest, recipe_digest: [u8; 32], diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index b24d61437..0460d7429 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -134,7 +134,7 @@ impl Prerequisites { /// Synthetic store/driver oracles have no installed recipe/connection and /// make no claim that they bind or authorize actual prerequisite reads. - #[cfg(any(test, feature = "testkit-harness"))] + #[cfg(test)] pub(super) const fn oracle_empty() -> Self { Self(Vec::new()) } diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 0ac8629af..00dd4bfbc 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -14,7 +14,6 @@ pub mod authoring; use crate::engine::{ GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult, VerifiedCommand, gateway_verifier_configuration, observe_outcome, observe_pre_entry, observe_read_back, - verify_detailed, }; use crate::observer::{OUTCOME_SCHEMA, READ_BACK_SCHEMA}; use crate::recipe::GuardChecks; @@ -697,6 +696,16 @@ impl CountingProvider { url.rsplit('/').next().unwrap_or_default().to_owned() } + /// Test recovery still needs a journal-issued one-use read permit. + #[cfg(test)] + pub(crate) async fn acquire_leased( + &self, + permit: crate::store::AcquisitionEntryPermit, + ) -> Option { + self.leases.fetch_add(1, Ordering::SeqCst); + self.acquire(permit).await + } + pub(crate) fn counts(&self) -> (usize, usize, usize) { ( self.writes.load(Ordering::SeqCst), @@ -763,6 +772,50 @@ impl ProviderPort for CountingProvider { } } +/// Native connection descriptor shared by the fixed-key submission and recovery +/// tests. This is not an installed operator credential or production authority. +pub(crate) fn fixture_connection( + recipe: &CompiledRecipe, +) -> Result { + use auths_connections::{ + ConnectionAlias, ConnectionId, ConnectionProfile, ConnectionRecord, ConnectionState, + ProviderKind, SemanticId, + }; + let descriptor = fixture( + crate::GatewayConnectionDescriptor::approve(recipe, "Authorization"), + "descriptor", + )?; + fixture( + ConnectionRecord::new( + fixture(ProviderKind::parse("airtable"), "provider")?, + fixture(ConnectionAlias::parse("synthetic"), "alias")?, + fixture( + ConnectionId::parse("conn_AAAAAAAAAAAAAAAAAAAAAA"), + "connection", + )?, + fixture(SemanticId::parse("auths.gateway-operation/1"), "contract")?, + fixture( + SemanticId::parse("auths.gateway-connection-descriptor/1"), + "schema", + )?, + fixture(descriptor.to_bytes(), "descriptor bytes")?, + crate::submit::account_commitment("acct_TESTHARNESS01"), + [5; 32], + std::num::NonZeroU64::MIN, + ConnectionState::Active, + vec!["gateway".to_owned()], + vec![fixture( + ConnectionProfile::new(fixture(SemanticId::parse("auths.mcp"), "profile")?, 2), + "profile", + )?], + 0, + 0, + None, + ), + "connection", + ) +} + /// The harness's submission I/O: verification at the harness clock and the /// counting provider under a counted lease. struct HarnessIo<'a> { @@ -791,21 +844,37 @@ impl SubmitIo for HarnessIo<'_> { now: u64, recipe: &CompiledRecipe, ) -> Result { - let command = verify_detailed( - &self.harness.recipe, - &self.harness.context, - now, - self.proof, - self.action, - )?; - crate::effect::approve_recipe_fixture( - command, + let invalid = || crate::engine::not_entered("test.effect.fixture-invalid"); + let connection = fixture_connection(recipe).map_err(|_| invalid())?; + let policy = crate::effect::fixture_policy().map_err(|_| invalid())?; + let installed = policy.installation( recipe, - self.account_commitment() - .ok_or_else(|| crate::engine::not_entered("test.account"))?, - now, - self.approval.clone(), - ) + &self.harness.context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = + crate::effect::compile_mutation_effect(&installed, now, self.proof, self.action)?; + let key = SigningKey::from_bytes(&[29; 32]); + let approval = match &self.approval { + Some(approval) => approval.clone(), + None => { + let request = effect + .approval_request( + now, + now.saturating_add(crate::effect::MAX_EFFECT_APPROVAL_SECONDS), + ) + .map_err(|_| invalid())?; + let signature = key + .sign(&request.signing_message().map_err(|_| invalid())?) + .to_bytes(); + request.with_signature(signature) + } + }; + effect + .approve(approval, &key.verifying_key().to_bytes(), now) + .map_err(|_| invalid()) } fn revalidate( @@ -813,12 +882,21 @@ impl SubmitIo for HarnessIo<'_> { effect: &crate::effect::ApprovedEffect, now: u64, ) -> Result<(), GatewaySubmitResult> { - let public = ed25519_dalek::SigningKey::from_bytes(&[29; 32]) - .verifying_key() - .to_bytes(); + let invalid = || crate::engine::not_entered("test.effect.approval"); + let connection = fixture_connection(&self.harness.recipe).map_err(|_| invalid())?; + let policy = crate::effect::fixture_policy().map_err(|_| invalid())?; effect - .validate_approval(&public, now) - .map_err(|_| crate::engine::not_entered("test.effect.approval")) + .validate_for_entry( + &policy.installation( + &self.harness.recipe, + &self.harness.context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ), + now, + ) + .map_err(|_| invalid()) } fn bind_scope(&self, verified: &VerifiedCommand) -> Result<(), &'static str> { @@ -851,7 +929,7 @@ impl SubmitIo for HarnessIo<'_> { } fn account_commitment(&self) -> Option<[u8; 32]> { - None + Some(crate::submit::account_commitment("acct_TESTHARNESS01")) } fn within_entry_deadline(&self, evaluated_at: u64) -> bool { @@ -1081,6 +1159,11 @@ mod process { seconds: u64, }, Counts, + /// Fixed-key native approval for this synthetic reference, never a human approval. + ReferenceApproval { + proof_b64: String, + action_b64: String, + }, /// Synthetic reference only, isolated from the application protocol. ReferenceReadBack { record_id: String, @@ -1096,6 +1179,8 @@ mod process { leases: usize, #[serde(skip_serializing_if = "Option::is_none")] observation: Option, + #[serde(skip_serializing_if = "Option::is_none")] + approval_b64: Option, } struct Application { @@ -1155,6 +1240,7 @@ mod process { async fn control(&self, bytes: &[u8]) -> ControlResponse { let mut observation = None; + let mut approval_b64 = None; let ok = match serde_json::from_slice::(bytes) { Ok(Control::SetRecord { record_id, status }) => { matches!(status.as_str(), "Approved" | "Pending") @@ -1170,6 +1256,30 @@ mod process { .is_ok() } Ok(Control::Counts) => true, + Ok(Control::ReferenceApproval { + proof_b64, + action_b64, + }) => { + // The private harness control plane uses the same native + // verifier, compiler and fixed-key approval as Rust tests. + // It cannot turn this oracle into production authority. + approval_b64 = (|| { + let proof = Base64UrlUnpadded::decode_vec(&proof_b64).ok()?; + let action = Base64UrlUnpadded::decode_vec(&action_b64).ok()?; + let now = self.clock.load(Ordering::SeqCst); + let io = super::HarnessIo { + harness: &self.harness, + proof: &proof, + action: &action, + now, + approval: None, + }; + let effect = + crate::submit::SubmitIo::verify(&io, now, &self.harness.recipe).ok()?; + Some(encode(&effect.approval().to_private_bytes().ok()?)) + })(); + approval_b64.is_some() + } Ok(Control::ReferenceReadBack { record_id }) => { let arguments = serde_json::Map::from_iter([( "record_id".to_owned(), @@ -1192,6 +1302,7 @@ mod process { reads: counts.reads, leases: counts.leases, observation, + approval_b64, } } } diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 893936749..00f5636e9 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -496,17 +496,14 @@ async fn fresh_matching_read_back_authorizes_the_replacement_write(backend: Back assert!( matches!( result, - GatewaySubmitResult::ObservedByProvider { - status: Some(200), - .. - } + GatewaySubmitResult::ResponseRecorded { status: 200 } ), "{result:?}" ); assert_eq!( harness.provider.counts(), - (1, 2, 3), - "one write; the pre-read and the post-write read-back, each under its own lease" + (1, 1, 2), + "one explicit pre-read and one write; submission performs no implicit read-back" ); } @@ -584,14 +581,37 @@ async fn replaced_in_between_is_authorized_inside_the_documented_window(backend: let signed = harness.sign(Some(read_back_requirement()), &arguments, &[observation]); let result = harness.submit(&signed, NOW + 5).await; assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "the fact held at observed_at, not at execution: {result:?}" ); assert_eq!(harness.provider.counts().0, 1); } async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backend: Backend) { - let harness = Harness::open(chained_recipe(), backend); + let root = signer(h::ROOT_SEED); + let observer = GatewayObserver::from_test_seed(h::OBSERVER_SEED); + // Both exact tool permissions are installed before the source enters. No + // trust rewrite or inherited write authority is used to authorize recovery. + let recovery_tool = McpToolCall::new(h::SERVICE, crate::effect::RECOVERY_READ_TOOL, Map::new()) + .expect("recovery tool"); + let trust = h::context_for_tools( + &root, + observer.principal(), + NOW, + &[call(&Map::new()), recovery_tool], + ) + .expect("write and recovery trust"); + let harness = Harness::with( + chained_recipe(), + trust, + observer, + root, + signer(0x22), + backend, + ); let first = harness.sign( None, &harness.arguments( @@ -644,10 +664,22 @@ async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backe "step 2 has not entered the provider" ); harness.provider.set_delivery(Delivery::Respond); - assert!(matches!( + let counts = harness.provider.counts(); + assert_eq!( harness.submit(&first, NOW + 30).await, - GatewaySubmitResult::ObservedByProvider { status: None, .. } - )); + GatewaySubmitResult::Unknown + ); + assert_eq!( + harness.provider.counts(), + counts, + "replay performs no recovery read" + ); + recover_chain_source(&harness, "step-1", "recover-step-1", NOW + 31).await; + assert_eq!( + harness.provider.counts(), + (1, 1, 2), + "independently admitted recovery reads once" + ); let bound = signed_bytes(harness.outcome("step-1", NOW + 40).await); assert_eq!(stage_of(&bound), "observed-by-provider"); assert_eq!( @@ -664,14 +696,147 @@ async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backe harness .submit(&second(&[bound], &commitment), NOW + 50) .await, - GatewaySubmitResult::ObservedByProvider { - status: Some(200), - .. - } + GatewaySubmitResult::ResponseRecorded { status: 200 } )); assert_eq!(harness.provider.counts().0, 2, "one entry per step"); } +fn approve_chain_recovery( + harness: &Harness, + target: &crate::effect::RecoveryReadTarget, + operation: &LogicalOperationId, + now: u64, +) -> std::sync::Arc { + use crate::effect::{compile_recovery_acquisition, fixture_policy}; + use ed25519_dalek::{Signer as _, SigningKey}; + use std::sync::Arc; + let call = target + .authorization_call(&harness.recipe, operation) + .expect("exact recovery call"); + let reader = signer(0x44); + let grant = h::grant_for_tool( + &harness.root, + &reader.principal, + None, + window(now - 1, now + 100), + &call, + ) + .expect("independent recovery grant"); + let signed = submission_for_call_during( + &harness.root, + &reader, + &grant, + &call, + &[], + window(now, now + 60), + ); + let connection = h::fixture_connection(&harness.recipe).expect("connection"); + let policy = fixture_policy().expect("policy"); + let installed = policy.installation( + &harness.recipe, + &harness.context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let effect = + compile_recovery_acquisition(&installed, target, now, &signed.proof, &signed.action) + .expect("native recovery authority"); + let key = SigningKey::from_bytes(&[29; 32]); + let request = effect + .approval_request(now, now + 60) + .expect("exact recovery approval request"); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approved = Arc::new( + effect + .approve( + request.with_signature(signature), + &key.verifying_key().to_bytes(), + now, + ) + .expect("native recovery approval"), + ); + approved + .validate_for_entry(&installed, now) + .expect("fresh native recovery revalidation"); + approved +} + +/// Native signed recovery, exact approval and the real acquisition journal. +/// Only the final-entry clock/configuration fence uses the existing test oracle; +/// provider I/O consumes a real permit and refinement retains source attribution. +async fn recover_chain_source(harness: &Harness, source: &str, operation: &str, now: u64) { + use crate::entry::EntryValidation::Oracle; + use std::sync::Arc; + let source = LogicalOperationId::parse(source).expect("source"); + let operation = LogicalOperationId::parse(operation).expect("recovery"); + let target = harness + .store + .retained_recovery_target( + harness.recipe.namespace(), + &source, + *harness.recipe.digest(), + ) + .await + .expect("retained native source"); + let approved = approve_chain_recovery(harness, &target, &operation, now); + let crate::AcquisitionClaim::Reserved(reserved) = harness + .store + .claim_recovery(&approved, now, Oracle { now }) + .await + .expect("durable recovery reservation") + else { + panic!("expected new recovery reservation"); + }; + let (granted, permit) = reserved + .grant_entry(approved.clone(), Oracle { now }, now) + .await + .expect("durable recovery entry"); + let response = harness + .provider + .acquire_leased(permit) + .await + .expect("provider read"); + granted + .record_response(response.status, response.version_ok, &response.body, now) + .await + .expect("recorded provider evidence"); + let gate = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(now))), + auths_recipe_qualification::VerifierState::default(), + )); + let report = harness + .store + .refine_recovery( + harness.recipe.namespace(), + &source, + &operation, + *harness.recipe.digest(), + gate, + ) + .await + .expect("native recovery refinement"); + assert_eq!(report.disposition, crate::RecoveryDisposition::Recorded); + let counts = harness.provider.counts(); + assert!( + matches!( + harness + .store + .claim_recovery(&approved, now, Oracle { now }) + .await + .expect("read replay"), + crate::AcquisitionClaim::Existing(_) + ), + "recovery replay cannot issue another read permit" + ); + assert_eq!(harness.provider.counts(), counts); +} + async fn self_signed_or_forged_observations_never_satisfy(backend: Backend) { let harness = Harness::open(update_recipe(), backend); let arguments = harness.arguments("forged", RECORD, &update_extra(RECORD, "Pending")); @@ -917,13 +1082,7 @@ async fn sdk_action_window_admits_a_later_gateway_clock_and_replay_returns_histo ); let first = harness.submit(&within, NOW + 5).await; assert!( - matches!( - first, - GatewaySubmitResult::ObservedByProvider { - status: Some(200), - .. - } - ), + matches!(first, GatewaySubmitResult::ResponseRecorded { status: 200 }), "the default window covers a gateway clock 5 s later" ); assert_eq!(harness.provider.counts().0, 1); @@ -989,7 +1148,7 @@ async fn sdk_action_window_is_cut_to_the_grant_expiry(backend: Backend) { assert!( matches!( harness.submit(&near, NOW + 5).await, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } ), "a grant expiring 10 s later still authorizes the cut [t, t+10] window" ); @@ -1176,7 +1335,10 @@ async fn two_of_three_root_authorizes_only_with_two_distinct_roots(backend: Back .submit(&submit(operation, &roots, &signing), NOW) .await; assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "{operation}: {result:?}" ); } @@ -1418,7 +1580,10 @@ async fn custody_held_observers_satisfy_requirements(backend: Backend) { let signed = harness.sign(Some(read_back_requirement()), &arguments, &[observation]); let result = harness.submit(&signed, NOW + 1).await; assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "{custody}: {result:?}" ); assert_eq!(harness.provider.counts().0, 1, "{custody}"); @@ -1471,7 +1636,7 @@ async fn custody_observer_passes_custody_conformance() { assert!( matches!( harness.submit(&signed, NOW + 1).await, - GatewaySubmitResult::ObservedByProvider { .. } + GatewaySubmitResult::ResponseRecorded { status: 200 } ), "{case:?}" ); From 40662227e0d945011412b6062cfa8b42a7037d9e Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:24:13 +0000 Subject: [PATCH 062/136] refactor(test): isolate chain trust setup from recovery assertions --- product/runtime/auths-gateway/src/observed_tests.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 00f5636e9..22756567a 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -590,7 +590,7 @@ async fn replaced_in_between_is_authorized_inside_the_documented_window(backend: assert_eq!(harness.provider.counts().0, 1); } -async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backend: Backend) { +fn chain_harness(backend: Backend) -> Harness { let root = signer(h::ROOT_SEED); let observer = GatewayObserver::from_test_seed(h::OBSERVER_SEED); // Both exact tool permissions are installed before the source enters. No @@ -604,14 +604,18 @@ async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backe &[call(&Map::new()), recovery_tool], ) .expect("write and recovery trust"); - let harness = Harness::with( + Harness::with( chained_recipe(), trust, observer, root, signer(0x22), backend, - ); + ) +} + +async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backend: Backend) { + let harness = chain_harness(backend); let first = harness.sign( None, &harness.arguments( From 32eaafeb87c43f6b2d3357148c603de36288dd79 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:32:37 +0000 Subject: [PATCH 063/136] chore(gateway): refresh semantic closure after CI harness cutover --- product/runtime/auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/semantic_closure.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index b819fff65..e72552436 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"990969384a52d75bc2489d9d412a9e7dd814bca1c8f65c701d6205fae62a15d5"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"acf7552858ef8849565d59376c7577fbb78b2cba2f6049c120c7fea1972fd7fa"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"a9d52d100447c5883971a65c4c01f891881a0584b4d1c6f69ce96704319dedfb"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"b710b719298edb24f4dc4a02d6dcc93684e35cadec67ff8acb5df76da729ea3b"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"38c1d4ba50a3dfffc492aed1fec179a18602a98bd4cdf43c7f6639570ea43a24"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"5f7581001877e0a0f9e64959c9997b9adb2fc381e49df03fefc2724fb882d219"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c37b065fd0c20d090fb0913c8bdc094a362b7102e105d599014cde2feedffca4"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"d5d7871b284bfed8c1cbc55f5ef31c2a769e3c86ed0e8ec65afd0ad3adacaf68"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"ae791a5213b4b2549692d39d2b7853977f85aa281b04591d781b31258b6905a9"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index c9af781bb..9fb335deb 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "856af179ec2cc4cab68212505cc4455fa2497daf491293a20a6d3f8afe946f8e"; + "79e26cc90a3d81dbe9107f9b0e5c10b08e38528705969a47c31b38ba6144547b"; #[cfg(test)] mod tests { From 7def09e2fb03dff2f185c0950a11946bc2d8e454 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:32:37 +0000 Subject: [PATCH 064/136] docs(spec): retain AP070 as an independent application reference --- ...017-bound-effect-and-recovery-ownership.md | 24 +++- docs/plans/0074-implementation-handoff.md | 27 +++- docs/plans/0074-implementation-status.md | 116 ++++++++++++++---- .../0009-bound-effect-and-recovery.md | 40 +++++- ...ound-effects-and-recovery-state-machine.md | 79 +++++++++--- 5 files changed, 228 insertions(+), 58 deletions(-) diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index d6b5e7adf..381f97f24 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -10,6 +10,24 @@ but its profile states include partial effects and proven non-effect with different recovery semantics. None can be treated as interchangeable merely because each has a journal. +### Scope clarification: independent application-owned references + +The owner's subsequent decision retains AP070 as an independent runnable +application-owned reference. Its Python/SQLite broker is not a second authority +for a managed gateway operation and need not migrate to establish AP074. +Preserve its existing narrower claims and differential value. No managed grant, +credential, permit or native recovery decision may be delegated to it; its +receipts cannot be substituted for gateway evidence. Inventory the distinct +channels, state and credentials and enforce the managed deployment boundary. +Independent external credentials/writers remain an explicitly excluded threat. + +Future managed Google productization requires a reviewed native integration and +one native journal for those managed effects. Google metadata/refresh and AP070 +owner removal are deferred, while every generic native, binding/UI, file and +PostgreSQL concurrency/crash/fault, formal and containment gate remains required. +Historical checkpoints below describe earlier implementation scope; this decision +and the current specification/acceptance ledger govern remaining work. + Keep pure managed transitions in `auths-gateway-kernel::transition`, orchestration in `auths-gateway::submit`, and the logical journal in `auths-gateway::store`. Extend those owners; do not introduce a parallel executor or task ledger. @@ -1089,6 +1107,6 @@ the complete declared content GET separately. No `GET` is added to write methods The required evidence is a bounded source/lock negative corpus, native mutation-refusal and real read-only install/acquisition/disclosure process -journey. Google metadata semantics, token refresh custody and AP070's Python -owner removal remain separate required cutovers; supporting a content-only recipe -does not establish those provider capabilities or their equivalence. +journey. Google metadata, token refresh custody and AP070 owner migration are +deferred integration work. Supporting a content-only recipe establishes neither +those optional provider capabilities nor AP070 equivalence. diff --git a/docs/plans/0074-implementation-handoff.md b/docs/plans/0074-implementation-handoff.md index 3ec819dc1..c4097b504 100644 --- a/docs/plans/0074-implementation-handoff.md +++ b/docs/plans/0074-implementation-handoff.md @@ -1,8 +1,9 @@ # AP-SPEC-074 implementation handoff -This prompt is for a new agent working in the already-created worktree. It is not -an instruction to resume the paused AP073 implementation. The specification is -complete as a handoff document; the implementation described by it has not begun. +This prompt is for an agent continuing the existing AP074 worktree. It is not +an instruction to resume paused AP073 work. Implementation is in progress; +`0074-implementation-status.md` is the authoritative current evidence ledger. +Initial worktree-creation facts below are retained as historical context. ## Copy/paste prompt @@ -44,6 +45,18 @@ ADR and abstraction case, then perform bounded direct cutovers through P1–P4. Centralize shared semantic decisions; do not scatter independent clock, hash, approval, retry or accounting fixes through routes, demos and bindings. +Scope clarification: preserve AP070 as an independently implemented, +application-owned Google broker/reference with its existing narrower claims. +Do not delete, rewrite or migrate its Python/SQLite admission, execution or +receipts as part of AP074. Migration, Google metadata and OAuth refresh are +optional future productization, not AP074 exit gates. Compare retained reference +behavior without making it consume the implementation it tests. Every managed +gateway operation must still have one native authority/journal; never give the +reference managed credentials/permits, use it as an alternate managed route, or +interpret its receipts as managed guarantees. Preserve all native acquisition, +disclosure, installed binding/UI, file/PostgreSQL, fault/concurrency, containment, +formal and A01–A22 requirements. Prioritize those core gates and CI fixes. + The shared model must retain typed differences between acquisition, disclosure and mutation. A provider response, receipt signature, state match and recipient ACK establish different facts. An unknown outcome must never authorize a blind @@ -64,8 +77,10 @@ Record external assumptions and unsupported rollback guarantees precisely. Commit coherent implementation changes along the way using Conventional Commits. Follow the repository's GitHub-first verification policy. Generate required artifacts locally as needed to construct the change; do not duplicate broad local -build/test/lint/formal suites without the policy's justification. Observe CI only -after the spec implementation, fixtures and documentation are complete. Then push +build/test/lint/formal suites without the policy's justification. The user has +explicitly authorized early isolated CI triage; fix actual failures without +weakening contracts. Final hosted verification still requires the completed +implementation, fixtures and documentation on its exact revision. Push explicitly to origin codex/effect-recovery-foundation (never to main), open/update a draft PR against main, observe all required hosted workflows on the exact head, repair failures and repeat. Do not merge or deploy. @@ -81,7 +96,7 @@ removed duplicate paths, and remaining deployment assumptions. Do not resume multi-agent delegation as an automatic follow-on. ``` -## Current handoff facts +## Initial handoff facts (historical) - This worktree was created from freshly fetched `origin/main`, independently of draft PR #212 and its uncommitted changes. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index f3835cafd..2691abdec 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -7,7 +7,9 @@ in this checkout, on `codex/effect-recovery-foundation`. Finish the immutable native bound effect and the gateway's sole recovery/transaction owner, including mutation, bounded acquisition, separate recipient disclosure, exact approval, fresh entry authorization, immutable evidence and truthful native projections. -Cut maintained consumers over directly; remove competing managed decisions. +Cut maintained managed consumers over directly; remove competing decisions for +the same managed operation. Retain AP070 as an independent application-owned +reference with narrower claims; its migration is deferred, not an AP074 gate. Preserve the native verifier, reviewed recipe compiler, conservative recovery, durable adapter guarantees and source-linked formal claims. @@ -17,13 +19,15 @@ formal/refinement links and bounded performance measurements. Commit coherent changes. The user's subsequent instruction on 28 October overrides the initial push timing: commit the current slice, push explicitly to `origin codex/effect-recovery-foundation`, open a new draft PR against main, then -continue with incremental commits. Finish source, fixtures and documentation -before observing required hosted workflows on the exact head. Repair failures; do not +continue with incremental commits. The subsequent explicit CI-triage request +authorizes investigating failures before implementation is complete. Final +required hosted workflows must still pass on the completed head. Repair failures; do not merge or deploy. Local generation needed to construct artifacts is permitted; do not duplicate hosted build/test/lint/formal gates before the first push. Never touch the paused AP073 checkout or import its unfinished implementation. -Do not expand participant trees, federation, token systems or agent delegation. +Do not expand participant trees, federation or token systems. Only the explicitly +requested isolated CI subagent is authorized; this is not delegation product work. No stage is complete merely because types, documentation or a happy path exist. ## Baseline and working record @@ -117,25 +121,52 @@ The checkpoint sections below are historical records; the phase and acceptance ledgers at the end describe current closure. Do not treat earlier "pending" notes as a reason to reimplement a later completed source cutover. -1. Finish independently authorized bounded observation and full native recovery - actions/charge/evidence projections. Public `Reserved` and zero-provider-I/O - application replay are now implemented. Preserve immutable - admission/grant history and the one-use transport boundary already wired. -2. Complete typed acquisition, separate recipient disclosure and exact ACK in - the existing native owners. Bind and account for all credential-bearing - ancillary reads. Remove the competing AP070 Python decision owner and cut - maintained bindings over directly. -3. Finish the installed authenticated review/approval journey. The native - versioned review contract and literal renderer are now wired; frontend - capability, transport/channel authentication and failure evidence remain. -4. Add/complete installed authority expiry/revocation/configuration races, - adapter commit/ack faults and process/transport failpoints, plus differential - and generated-history evidence for A01–A22. Synthetic native fixtures are - deliberately narrower evidence. -5. Regenerate final translated/refinement/performance artifacts and observe - required hosted CI only after implementation, fixtures and documentation are - complete. No hosted results have been observed yet. Full Todoist pinned-input - re-execution remains pending, without blocking other implementation work. +1. Resolve hosted CI failures using the real native approval/recovery contracts. + Preserve tests and scope claims; no fake approvals or weakened gates. +2. Close file/PostgreSQL independent-process capacity, dependency-race, crash and + ambiguous-ack evidence. Prove the final fencing order and managed deployment's + non-bypassability with real transport, counters and restricted processes. +3. Finish native recovery actions/charge/evidence projections and the installed + authenticated human review/approval plus managed binding/UI journey. +4. Complete two mutation recipe and independent read/disclosure differentials, + generated histories, source-linked formal/refinement and bounded performance. +5. Pass all final required hosted checks on the completed revision. Keep AP070's + independently application-owned broker/reference intact. Google metadata, + OAuth refresh and migration are future integration, not completion blockers. + +## Current owner decision: AP070 remains independent + +The user's explicit scope decision supersedes historical checkpoint requirements +below that called for AP070 migration. AP074 owns canonical authorization, +admission, execution and recovery for managed gateway operations. AP070 retains +its own Python/SQLite broker, token custody, routes and narrower claims as an +independent reference. No migration is required for AP074 closure; no native +acquisition/disclosure, adapter, crash/concurrency, binding/UI, containment, +differential, formal/performance or hosted gate is waived or marked complete. + +Prior AP070 work is preserved in `fb5c5a0a`: `google_drive.py` now delegates pure +metadata checks to new `google_metadata.py`, receives a typed MIME representation, +and returns typed denials for malformed MIME/decimal values. A 36-case pure +reference corpus/generator was added. No admission.py, read_executor.py, +receipts.py, token vault, broker routes or SQLite ownership was deleted or +migrated. Only the pure generator ran; no full broker or live Google claim follows. +No further AP070 source changes are authorized by this scope update. + +Source/configuration observations supporting safe deferral: AP070's compose runs +its own broker/relays and SQLite state; its agent transport calls execute_read +and TokenVault. It does not call GatewayClient or a managed application socket; +the gateway does not load the Google adapter. Compliance inventories separate +its application-owned state/protocols from managed gateway state. This is not a +runtime containment proof. Required managed evidence must still establish that +references cannot obtain managed credentials/permits, authorize the same managed +operation, or have their receipts accepted as native entry/recovery facts. +Independent application-held provider credentials/external writers are outside +managed containment and must stay explicit in deployment claims. + +Future managed Google productization requires its own reviewed capability, +metadata/custody evidence and one native journal. AP070 remains useful for +independent comparisons; document divergences rather than rewriting the oracle +to consume the implementation it is meant to test. ## Full-binding journal cutover (in progress) @@ -1524,6 +1555,41 @@ closure regeneration passed after that correction (one artifact-generation test) both supported content paths, token refresh custody, bindings/UI and removal of the competing Python shared state owner remain open. No A01–A22 gate closes. +## Integrated native CI fixes and preserved acceptance scope + +- The isolated CI agent's `e705e05c` and `890b42cd` were reviewed and integrated as + `4bbff153` and `40662227`. The test harness now compiles real native source + effects with a connection descriptor and revalidates them. Its explicitly + private fixed-key control plane supplies test approvals to installed SDK + consumers; it is not a human approval or production endpoint. +- Chained-step recovery installs write/recovery trust before entry, keeps replay + Unknown without a read, and uses an independent reader proof/exact approval, + real reservation/one-use permit and journal refinement. The final-entry fence + remains explicitly a unit-test oracle; installed fencing is separate evidence. + Ordinary write tests assert ResponseRecorded and no implicit observation. +- Agent verification at the isolated source commits: 14 file observed tests, + 15 TLS PostgreSQL observed/bounds tests (isolated project/port 55449, removed + afterward), 19 bounds tests plus 1 expected PostgreSQL ignore, 4 audit tests, + packed Node and Python observation consumers, 4 Python public API tests, API + snapshot check and 6 qualification tests passed. These are focused hosted-failure + reproductions, not a claim that the integrated branch passed final hosted CI. +- Original hosted roots at `c80902ab`: [preflight freeze](https://github.com/auths-dev/auths-proof/actions/runs/40783379364/job/123151257660), + [Python API](https://github.com/auths-dev/auths-proof/actions/runs/40783379255/job/123150389757), + [Python runner](https://github.com/auths-dev/auths-proof/actions/runs/40783379255/job/123150389685), + [TS API](https://github.com/auths-dev/auths-proof/actions/runs/40783379522/job/123151940534), + [installed Node](https://github.com/auths-dev/auths-proof/actions/runs/40783379522/job/123151940374), + [PostgreSQL](https://github.com/auths-dev/auths-proof/actions/runs/40783379447/job/123150390095), + [qualification](https://github.com/auths-dev/auths-proof/actions/runs/40783379390/job/123152045258), + [operator simulation](https://github.com/auths-dev/auths-proof/actions/runs/40783379435/job/123152776374). +- Maintained Stripe/Airtable demos, north-star and scaffold workflows still need + proper effect-policy/exact approval integration. These are managed consumer + requirements and remain required. They cannot be waived by retaining AP070. +- Integrated required artifact generation passed six exact native generators in + 35.57 seconds before the small chain-helper extraction; only source closure + changed. Final closure-only regeneration after that extraction passed one + exact generator in 0.08 seconds. No AP070 migration, test ignore, authorization + bypass or completed A01–A22 claim is made. + ## Phase gates | Phase | State | Outstanding gate | @@ -1531,7 +1597,7 @@ closure regeneration passed after that correction (one artifact-generation test) | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | | P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed bindings/authenticated UI, Google metadata/refresh and AP070 Python owner removal | +| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed managed bindings/authenticated UI and full native read/release evidence; AP070 stays independent | | P4 | Partial CLI process journey | Differential, full faults/adapters, installed bindings/UI, formal/performance links and CI | ## Acceptance ledger @@ -1560,7 +1626,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / no / no | Retained independent references | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / independent references retained / no complete differential corpus | Preserve AP070 reference independence; complete comparable native contracts without broker migration | | A20 | Generated histories and shipping predicate refinement | Partial / 576 typed stage pairs, ACK histories and Kani source / pure corpus executed | Full generated concurrent histories and source-linked formal artifacts pending | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 95a6bd5c5..4535bb843 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -16,10 +16,10 @@ Owner: product gateway/kernel, per [ADR 0017](../../../adr/0017-bound-effect-and | File attempt adapter | Private files, flock, fsync/rename, batch rollback, CAS | Retain durability; add bounded transactional validation/fencing | | PostgreSQL gateway records | Atomic batch, byte CAS, commit acknowledgement | Retain mechanism; extend shared transaction boundary | | Lifecycle `operation` / `sealed` | Preparation commitments, validated store ACK, profile-specific lifecycle | Reference semantics; no second managed gateway owner | -| AP070 `AdmissionStore` / `ProviderAttemptLedger` | SQLite task counters, challenge/release decisions, per-GET records | Remove shared decisions in native cutover | -| AP070 `execute_read` / `ReceiptStore` | Provider-specific fetch, release orchestration, Python receipt claims | Thin consumer of native stages and projections | +| AP070 `AdmissionStore` / `ProviderAttemptLedger` | Application-owned SQLite task counters, challenge/release decisions, per-GET records | Retain independent reference and narrower claims; never authorize managed gateway effects | +| AP070 `execute_read` / `ReceiptStore` | Application-owned fetch, release orchestration and receipt claims | Preserve broker/reference; do not promote its facts to managed entry/recovery evidence | | TS `gateway.ts`, Python native runtime, gateway app/admin | Socket/binding routes and views | Expose native construction and state; no local effect hashes | -| AP070 Drive adapter | Metadata/content GETs and provenance checks | Retain independent provider reference; managed I/O uses closed recipe | +| AP070 Drive adapter | Application-owned metadata/content GETs and provenance checks | Retain independent reference; any future managed Google integration needs separately reviewed native capabilities | | Gateway observer / audit / harness / commissioning | Signed observations, audit facts, local fixtures, bounded operator authority | Update identities and stages atomically; do not bypass commissioning bounds | ## Comparison and extraction classification @@ -101,7 +101,9 @@ unknown keeps charges. Pre-entry refusal only releases declared releasable units Replace affected formats and call sites in one bounded PR. No production compatibility path, migration or dual journal. Reference models remain explicitly -test-only. Formal work must update translated shipping predicates and refinement +test-only or independently application-owned with explicit narrower claims. +They cannot exercise managed credentials or become a second managed authority. +Formal work must update translated shipping predicates and refinement links, not claim a hand-written model proves runtime code. Adapter assumptions include lock/commit durability, clock trust, recipient authentication and provider observation integrity; whole-store rollback without an external anchor is excluded. @@ -748,5 +750,31 @@ native bounded UTF-8/typed decoding must refuse them. It does not authorize weakening native parsing to match a weaker historical reference. Status/media, lease, native resource authority, prerequisite freshness and actual content entry remain separate gates. Native metadata capability/refinement, request selection, -refresh custody and AP070's Python journal removal are still required; this -provider reference is an extraction input, not proof of their implementation. +refresh custody and AP070 migration are deferred future integration. This +provider reference is retained independently, not proof of managed Google access. + + +### Owner decision: retain AP070 independence + +AP074 closes the general-purpose managed gateway contract. Its single-owner +requirement is per managed operation, not a requirement that every independent +application use the gateway. Preserve AP070's Python broker, SQLite journal, +credential custody and narrower receipts as an independent application-owned +reference. Only shared, explicitly comparable contracts participate in +differential evidence; document differences instead of forcing equivalence or +rewriting the oracle to call the implementation it tests. Native read/disclosure +must still have an independent reference corpus; this decision does not waive it. + +The observed source separation is concrete: AP070's compose starts its broker +and relays with its own SQLite state and token vault; its agent transport calls +its own execute_read, not GatewayClient/application sockets. The gateway does not +load the Google adapter. These are source/configuration observations, not proof +of every deployed isolation arrangement. Required managed hostile-process tests +must enforce credential/channel separation and reject alternate managed paths. +Sharing provider credentials, trusting AP070 receipts as native evidence or +letting it authorize the same managed effect would violate the boundary. + +Native acquisition/disclosure, full installed managed journey/UI, two mutation +recipe differentials, every file/PostgreSQL concurrency/crash/fault case and all +formal/performance/hosted gates remain mandatory. Google metadata, OAuth refresh +and migration are deferred until explicitly productizing managed Google access. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index b21e30da1..5b6a1c3d9 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -17,6 +17,36 @@ Implement two architectural changes together: The first complete demonstration is one human authorizing one agent to acquire a bounded resource, receive an authorized disclosure, and perform one exactly approved mutation followed by independent observation. A deterministic provider fixture must exercise actual transport and restart boundaries. Expanding participant enrollment, delegation trees, federation, identity recovery or native resource enforcement is outside this specification. +### Managed boundary and retained AP070 reference + +AP074 establishes one authorization, admission, execution and recovery authority +for each **managed gateway operation**. AP070 remains an independently +implemented, application-owned Google read demonstration with its existing +Python/SQLite decisions, credentials, routes and explicitly narrower claims. +Its migration is deferred until managed Google Drive access is intentionally +productized; it is not an AP074 completion requirement. Preserve the broker and +its independent reference value. Sharing offline native verification does not +make its application admission or receipts managed gateway facts. + +One managed operation MUST NOT have two independently authoritative decision +systems. Consequently the gateway MUST NOT delegate a managed grant to AP070, +load its provider adapter as a runtime callback, give it gateway-managed +credentials/permits, or accept its SQLite decisions/receipts as native entry or +recovery evidence. Inventories and deployment policy must distinguish credentials, +channels, operation namespaces and receipt claims. Independent application-held +credentials or external writers remain outside managed containment; their +existence must not be hidden by a managed guarantee. If an application-owned +reference is reachable by a managed agent, the deployment must still prove that +it cannot exercise managed credentials or authorize the same managed effect. + +Retain independent reference/differential tests and document semantic differences; +do not force an application-owned reference to use the implementation it tests. +A future managed Google integration must use native approved capabilities and one +native journal, with provider-specific metadata/custody evidence reviewed then. +No Google metadata capability, OAuth refresh integration or AP070 Python-owner +removal is required to establish the generic gateway foundation. Native bounded +acquisition/disclosure and all A01–A22 evidence remain mandatory. + This is a prerequisite foundation for those later features. Do not import the AP073 branch wholesale, copy its unfinished task protocol, or make this work depend on its merge. Its findings may inform adversarial cases after independent verification against this baseline. The work must replace competing interpretations, not add another wrapper around them. Completion requires maintained consumers to use the new owner and superseded managed execution paths to be removed. It does not require replacing sound cryptography, the native verifier, established recipes or the whole repository. @@ -34,12 +64,12 @@ This inventory is based on source at the baseline, not a claim of exhaustive rev | [`transition.rs`](../../product/runtime/auths-gateway-kernel/src/transition.rs), [`recovery.rs`](../../product/runtime/auths-gateway-kernel/src/recovery.rs), [`outcome.rs`](../../product/runtime/auths-gateway-kernel/src/outcome.rs) | Attempt transition rules, recovery capability and truthful outcome predicates. | Preserve their invariants and formal links while making reservation, entry and disclosure explicit. | | [`GatewayAttempts`](../../product/runtime/auths-gateway/src/store.rs) | Attempt records, atomic bounded claims, counters, file and PostgreSQL adapters. | Use one logical effect journal and one transaction contract. Do not add an independently authoritative task ledger. | | [`auths-lifecycle`](../../product/runtime/auths-lifecycle/src/lib.rs), especially [`operation.rs`](../../product/runtime/auths-lifecycle/src/operation.rs) and [`sealed.rs`](../../product/runtime/auths-lifecycle/src/sealed.rs) | Versioned identities, preparation commitments, lifecycle relations and store acknowledgements used by reference consumers. | Compare and reuse exact mechanisms. Document why retained reference models are not a second production owner. Do not invent a third lifecycle framework. | -| AP070 [`admission.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/admission.py), [`read_executor.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/read_executor.py) and [`receipts.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/receipts.py) | Demo-owned SQLite read accounting, release decisions and receipt orchestration. | Move shared effect/recovery decisions into the Rust owner; retain presentation and provider-specific reference behavior at the appropriate boundary. | +| AP070 [`admission.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/admission.py), [`read_executor.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/read_executor.py) and [`receipts.py`](../../demos/google-employee-delegation/broker/src/employee_read_demo/receipts.py) | Demo-owned SQLite read accounting, release decisions and receipt orchestration. | Retain as an independently application-owned reference with narrower claims. Compare shared contracts and document differences; do not use its decisions for managed gateway operations. Migration is deferred. | | [`DeploymentClock`](../../product/runtime/auths-gateway/src/qualification.rs) | An existing deployment time/trust boundary. | Strengthen this contract where necessary. Do not introduce clocks in individual handlers or reinterpret signed event time. | Main contains AP070, not the AP071/AP073 native task read/write implementation. This specification must be implementable without files that exist only on those branches. -Before consolidation: +Baseline managed and independent reference paths: ```mermaid flowchart TB @@ -51,6 +81,7 @@ flowchart TB J --> WR[Write outcome projection] S --> RR[Read receipt projection] L[Lifecycle reference contracts] -. separate ownership mapping .-> J + S -. retained independent reference; no managed authority .-> J ``` Target: @@ -69,7 +100,8 @@ flowchart TB X --> E[Typed response, acknowledgement or uncertainty evidence] E --> R J --> V[Native receipt and activity projections] - V --> UI[Thin bindings and UI] + V --> UI[Thin managed bindings and UI] + REF[Independent application-owned AP070 reference] -. differential comparison only .-> R ``` “One” means one semantic owner and one atomic admission authority per partition. It does not mean one global process, one physical database table, one mutable object passed everywhere or a single linear lifecycle for all effect kinds. @@ -92,7 +124,7 @@ Use a closed protocol sum with typed data for **provider acquisition**, **recipi A provider name, arbitrary operation string, callback, runtime plugin or untyped map MUST NOT select hidden authorization or recovery behavior. Provider paths, mappings and supported observations remain reviewed, digest-bound recipe data. A new gateway capability must satisfy the repository abstraction process. -The implementation must write an abstraction case comparing at least the existing mutation path, AP070 acquisition/release path and lifecycle reference model, including divergent semantics. Compare two maintained mutation recipes with different recovery capabilities. If the normal extraction threshold is not met, an ADR must justify the narrowly identical mechanism. This is an implementation deliverable, not permission to skip evidence gates. +The implementation must write an abstraction case comparing at least the existing mutation path, the independently application-owned AP070 acquisition/release reference and lifecycle reference model, including divergent semantics and distinct claim boundaries. Retaining that independence is required; migration is not the comparison gate. Compare two maintained mutation recipes with different recovery capabilities. If the normal extraction threshold is not met, an ADR must justify the narrowly identical mechanism. This is an implementation deliverable, not permission to skip evidence gates. ### 3.3 Direct cutover @@ -387,8 +419,9 @@ adjuncts, missing content, custom tools and write injection under the reserved read tool. A real CLI/daemon fixture installs it under read/release-only native trust, refuses mutation submission/review and mutation recovery from acquired content, and performs exactly one content GET plus authenticated disclosure. -This supports standalone native reads; Google metadata gating, credential refresh, -AP070 owner removal, authenticated UI and installed language evidence remain open. +This supports standalone native reads. Authenticated UI and installed language +evidence remain required. Google metadata, credential refresh and AP070 migration +are deferred provider-integration work outside AP074 completion. Explicit content acquisition is a versioned opt-in recipe capability, `content.schema = auths.gateway-content-read/1`, within recipe source `/3`. @@ -466,8 +499,8 @@ or new provider permit. Unknown/oversized responses retain their full charges. The public acquisition projection reports only `ready { bytes }` or `rejected { code }`, never the private key, content digest, hiding commitment or plaintext. A ready result grants no disclosure authority. Standalone read-only -installation, AP070 metadata predicates and installed -CLI/binding journeys remain required for the cutover. +installation and installed managed CLI/binding journeys remain required. AP070 +metadata and broker integration are separately deferred. The journal's sealed `RetainedContent` is private provenance, with no public plaintext accessor or deserializer. Loading requires the exact namespace, @@ -599,7 +632,8 @@ history and late-ACK methods carry native bytes unchanged; they implement no content projection, commitment, signing, accounting or retry decision. Recipient protocol execution stays in Rust. Native frame/CLI artifacts and socket-client cases are narrower than installed authority/UI/binding/hostile-process evidence; -authenticated UI/installed binding integration and AP070 cutover remain required. +authenticated UI/installed managed binding integration remains required. AP070 +remains an independent application-owned reference; its cutover is deferred. Native `effect-content-call` accepts a private resource-argument file and uses `ContentReadTarget` against the installed connection. It reuses the bounded @@ -630,8 +664,9 @@ trashed semantics, malformed input and the existing 16 KiB bound. The reference reader uses one typed domain validator; malformed MIME/decimal inputs deny. Historical duplicate, alternate-encoding, nonboolean-trash and Unicode-size acceptance are explicitly marked for stricter native refusal. This corpus is an -input to the required native metadata capability/differential extraction; it does -not complete that capability, token refresh or Python journal cutover. +optional input to future managed Google capability/differential extraction. The +existing broker and corpus are preserved; native Google metadata, token refresh +and Python journal migration are deferred rather than AP074 exit gates. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. @@ -859,7 +894,15 @@ The implementation should expose a small set of Rust-owned operations, with exac Centralize clocks, canonicalization, effect comparisons, charge transitions and receipt claims at these owners. Do not scatter fixes across Python presenters, HTTP routes, CLI handlers or recipe branches. UI and SDKs must consume the same native review and state projection, including unknown and not-entered distinctions. -For the AP070 read demonstration, remove independent Python decisions for the shared contract in the same cutover. Provider-specific reference code may remain outside the shared gateway; production managed I/O must use approved data-only capabilities. Inventory every retained weaker application-owned path and label its claim accurately. Do not turn a demo adapter into a runtime callback loaded by the gateway. +Managed gateway consumers must call the native shared owner directly; remove +competing decisions for the same managed operation in that cutover. AP070 is a +retained independently application-owned reference, not such a managed consumer. +Keep its broker and narrower claims intact and use its independent behavior for +comparison where contracts overlap. Inventory retained application-owned paths, +credentials and claims, and prove they cannot bypass the managed deployment's +credential/channel boundary. Do not load a reference adapter into the gateway or +promote its decisions/receipts to managed authority. Future managed Google access +requires its own explicit integration decision and one native admission owner. ## 8. Hard limits and stable failures @@ -929,10 +972,10 @@ All rows require reproducible artifacts, expected journal state, expected extern | A16 | Cross-task, cross-recipe and cross-partition substitutions use otherwise valid proofs and identical resource names. No mixed authority or shared-state aliasing. | | A17 | Capture logs, errors, public receipts and binding output with sentinel secrets/private content. No sensitive bytes or guessable public content commitments escape. | | A18 | Canonical valid, malformed, duplicate, noncanonical and limit/limit-plus-one cases agree across Rust and every affected public binding. | -| A19 | Differential corpus covers two mutation recipes with distinct recovery capabilities, plus acquisition/disclosure, against retained references. No provider-specific branch enters the shared owner. | +| A19 | Differential corpus covers two mutation recipes with distinct recovery capabilities, plus acquisition/disclosure, against independent retained references. Preserve reference independence and document contract differences; AP070 may remain an application-owned reference without migration. No provider-specific branch enters the shared owner. | | A20 | Model-generated event sequences and concurrent histories exercise every transition and illegal edge. Formal/refinement artifacts identify the actual shipping pure predicates and assumptions. | | A21 | Replay retention, terminal tombstones, stale cache/configuration and supported rollback-floor failures cannot resurrect entry authority. Unsupported whole-store rollback is explicitly excluded. | -| A22 | Installed packages and native runtime execute the complete single-human/single-agent read, disclosure, exact write and observation journey; UI distinguishes grant, response, ACK, observation and unknown. | +| A22 | Installed packages and native runtime execute the complete managed single-human/single-agent read, disclosure, exact write and observation journey; UI distinguishes grant, response, ACK, observation and unknown. Use an approved native recipe and real local transport; Google/AP070 integration is not required and an application-owned broker cannot substitute for managed evidence. | The same rows additionally require the following hardening cases; these are part of their exit gates, not optional follow-up work: @@ -943,7 +986,7 @@ part of their exit gates, not optional follow-up work: | A04, A06, A12, A13 | Independent processes race dependency changes against the final grant on both adapters, including state in distinct physical records. Histories satisfy the named fencing mechanism; existing reservations are not charged twice. | | A11, A15, A22 | Exhaust reconciliation attempts/bytes/time; age its evidence; make authority/store unavailable. Retained charges and escalation remain visible; administrative annotations cannot manufacture non-entry or retry authority. | | A16, A20 | Scope/participant and charge inputs cannot create a second admission authority. Exercise the current unscoped/single-agent boundary and reject unsupported delegation representations; no AP073 implementation is required. | -| A17, A21, A22 | Hostile isolated agent exercises the complete interface inventory, obsolete endpoints and alternate credential/transport routes. Assert no unauthorized managed provider calls and document the actual isolation assumptions. | +| A17, A21, A22 | Hostile isolated agent exercises the complete managed interface inventory, obsolete endpoints and alternate credential/transport routes. Assert no unauthorized managed provider calls and document the actual isolation assumptions. Retained application-owned references must not expose managed credentials, permits or an alternate authority for the same managed effect; verify the applicable deployment separation. | Use external call counters and process failpoints, not only mocked return values or tests asserting the implementation's own intermediate flags. Exercise real local sockets, process restart and the maintained PostgreSQL fixture. Provider-specific live qualification remains a separate claim; no cloud credential should be necessary for the local foundation journey. @@ -962,18 +1005,18 @@ Measure native verification, compilation, transaction/lock duration, memory boun | P0: map and decide | Baseline source/consumer inventory; ownership ADR and abstraction case; canonical field, limit and state tables; retain/replace list. | Every existing invariant and production/reference owner accounted for. No implementation built on an unresolved competing owner. | | P1: bind one mutation | Native immutable effect, review/approval, deterministic request compilation and thin binding entry points. | E01–E05 on one maintained mutation path; adversarial binding corpus authored; direct cutover removes duplicate reconstruction. | | P2: central durable mutation | Sole reducer/journal for reservations, entry, response, unknown and observation, with file/PostgreSQL adapters. | R01–R10 for mutation; restart/concurrency/fault evidence implemented; no dual task/attempt authority. | -| P3: acquisition and disclosure | Typed read/release protocol in the same owner, explicit source/recipient binding and ACK handling; thin AP070 consumer. | Independent read/disclosure charges and permissions; ACK loss/revocation/replay cases implemented; Python stops deciding shared transitions. | +| P3: acquisition and disclosure | Typed managed read/release protocol in the same native owner, explicit source/recipient binding and ACK handling; thin managed bindings. | Independent read/disclosure charges and permissions; ACK loss/revocation/replay cases implemented; no managed consumer independently decides shared transitions. AP070 remains an independent reference. | | P4: close integration and evidence | Second recipe differential cases, installed bindings, full local journey, native projections, formal links and final hosted checks. | A01–A22 addressed with exact-revision evidence, documented assumptions and no unsupported claims. | Commit coherent changes along the way. Keep a durable acceptance ledger separating implemented, source-tested, executed, externally qualified and blocked. Do not mark a phase complete merely because its types exist or the happy path works. -Observe CI only after the specification's implementation is complete, as requested by the user. Follow the repository's GitHub-first policy: construct necessary generated artifacts locally; do not run duplicate broad local suites by default. Once implementation, fixtures and documentation are complete, push the finished branch, inspect required hosted workflows on that exact revision, repair failures, and repeat until the required evidence is resolved. Report external blockers rather than weakening checks or pretending a skipped job passed. +Follow the repository's GitHub-first policy: construct necessary generated artifacts locally and avoid duplicate broad local suites by default. The user has explicitly authorized early CI failure triage; this does not replace final verification. Once implementation, fixtures and documentation are complete, push the finished branch, inspect every required hosted workflow on that exact revision, repair failures, and repeat until the required evidence is resolved. Report external blockers rather than weakening checks or pretending a skipped job passed. The foundation is not complete until required behavioral and hosted evidence passes. Delaying CI observation is not a waiver of verification. No merge or deployment is authorized by this spec. ## 13. Completion and handoff boundary -Done means both central contracts own the maintained paths, obsolete managed interpretations are removed, interfaces and bindings are updated, source-linked formal and operational evidence are current, and the acceptance ledger contains actual results. The result must be a reviewable implementation with a concise explanation of changed behavior, tests and remaining deployment assumptions. +Done means both central contracts own the maintained managed paths, obsolete managed interpretations are removed, interfaces and bindings are updated, source-linked formal and operational evidence are current, and the acceptance ledger contains actual results. The result must be a reviewable implementation with a concise explanation of changed behavior, tests and remaining deployment assumptions. Only after this foundation is closed should multi-agent delegation add participant trees and ancestor budget allocation on top. Those features must consume the established effect and recovery contracts instead of creating their own parallel journals, approval identities or retry rules. From 6009de25ec3deefe4bddf75ba3f0eb354c654c33 Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:34:17 +0000 Subject: [PATCH 065/136] fix(release): bind integrated CI consumer contracts in semantic freeze --- docs/plans/0074-implementation-status.md | 5 +++++ release/semantic-freeze-versions.toml | 8 ++++---- release/semantic-freeze.json | 14 +++++++------- 3 files changed, 16 insertions(+), 11 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 2691abdec..e93dd43d1 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1589,6 +1589,11 @@ closure regeneration passed after that correction (one artifact-generation test) changed. Final closure-only regeneration after that extraction passed one exact generator in 0.08 seconds. No AP070 migration, test ignore, authorization bypass or completed A01–A22 claim is made. +- Final semantic-freeze construction after integrating the SDK/harness changes + succeeded at freeze 392. Only the three changed identity/public-SDK/public-surface + subjects reported by the generator advanced, alongside the freeze version. + This refresh does not claim a hosted pass. The CI agent is authorized to push + the exact integrated revision non-forcibly to the existing PR branch. ## Phase gates diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 3ae0eb254..dab2b9c84 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 391 +freeze_version = 392 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 391 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 137 +"auths.identity.protocol" = 138 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 124 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 391 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 134 +"auths.product.public-sdk-contract" = 135 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 81 -"auths.release.public-surface" = 391 +"auths.release.public-surface" = 392 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 0c2db0488..ad74e4ffe 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 391, + "freezeVersion": 392, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 137, + "version": 138, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "ddc32c606618475be1e7d9ef6bbf6b47119c17fd72d2df268f5e473674ecc220" + "sha256": "74036623cbc194bc962b80cdc9a26027202836c51a279ed03f372df42f7cd473" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 134, + "version": 135, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "d8fa5528cf5f966837c08a1905440b6410f697b2be02ac16793a34aa23930b3e" + "sha256": "db2459807340c9aa3d0ea76dafd6018685c30678e1a908b36d73cd10cd31d7a8" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 391, + "version": 392, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "5b9e0b3ef2ba88cbc049260e56c294d50fe071ff3c5689929361543002ce7714" + "sha256": "eb046187abd685bec8238ba3e69f823b5cedb14ab13fdce7a19d2872fd121f2a" } ] } From 7369926a6d5a54285bddc234a916fb2e5608466d Mon Sep 17 00:00:00 2001 From: bordumb Date: Wed, 28 Oct 2026 23:53:12 +0000 Subject: [PATCH 066/136] test(gateway): race independent daemons for final read allocation --- .../gateway/content-process-capacity.json | 56 +++ docs/plans/0074-implementation-status.md | 38 +- ...ound-effects-and-recovery-state-machine.md | 9 + .../auths-gateway/tests/content_journey.rs | 347 ++++++++++++++++++ 4 files changed, 449 insertions(+), 1 deletion(-) create mode 100644 bindings/fixtures/gateway/content-process-capacity.json diff --git a/bindings/fixtures/gateway/content-process-capacity.json b/bindings/fixtures/gateway/content-process-capacity.json new file mode 100644 index 000000000..6734ea651 --- /dev/null +++ b/bindings/fixtures/gateway/content-process-capacity.json @@ -0,0 +1,56 @@ +{ + "schema": "auths.content-process-capacity/1", + "scope": "two independent production daemon processes with separate joined local custody and CLI callers; real native proof/approval/fenced file adapter, counting local HTTP; source-lifetime acquisition count/response ceilings only, not managed fixed-window count/sum, PostgreSQL, distributed fencing or power loss", + "initial_allocations": 15, + "final_contenders": 2, + "final_grants": 1, + "exhausted": 1, + "provider_calls": 16, + "retained_calls": 16, + "retained_response_bytes": 16384, + "all_requests_exact": true, + "restart_replay_no_refetch": true, + "cross_process_history_matches": true, + "durable_grants": 16, + "permanent_allocations": 16, + "native_refusal_code": "gateway.acquisition.exhausted", + "journal_and_allocations_unchanged_after_restart_replay": true, + "successful_read": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 32, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 32 + } + } + } + }, + "capacity_refusal": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + } + } + } +} \ No newline at end of file diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index e93dd43d1..9f60e8d25 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1595,6 +1595,42 @@ closure regeneration passed after that correction (one artifact-generation test) This refresh does not claim a hosted pass. The CI agent is authorized to push the exact integrated revision non-forcibly to the existing PR branch. +## Independent production-process source-capacity checkpoint + +- Based on pushed `6009de25`. The previous user-facing status was not new + implementation progress; this continuation revalidated the clean tree and + implemented a real cross-process capacity case rather than another in-process + store-instance test. AP070 remains independent and unchanged. +- `native_content_process_capacity_fixture_is_current` starts two production + daemons with separate private custody, joined to one native connection and + shared file attempt store. Native CLI authoring, real proofs, exact review and + approvals prepare 17 operations for the same resource. Fifteen reads consume + all but the final source-lifetime allocation; two independently running gateways + then contend for it. Exactly one enters the counting HTTP provider. +- The case asserts 16 actual provider calls, 16 permanent source allocations and + 16 durable entry audits; the loser retains a NotEntered native record with + `gateway.acquisition.exhausted`, no entry, no allocation and no policy slots. + Aggregate retained capacity is 16 calls and 16,384 full-ceiling response bytes. + Cross-process history agrees. Killing both daemons and reopening preserves + byte-for-byte journal/grant/allocation data; all 17 replays add no provider I/O. +- Initial construction mistakenly shared one local credential file between both + daemons, so transient custody contention could refuse a contender before the + admission race. The final fixture uses the supported two-host install/join + layout, retaining independent local custody and one shared journal. No custody + error was ignored or production authorization check relaxed. +- Public acquisition snapshots currently expose NotEntered and charges but not + its specific refusal code. The test checks that reason in the protected native + journal; the missing public reason remains a projection limitation for A10. +- Required artifact construction: + `AUTHS_UPDATE_FIXTURES=1 cargo test -p auths-gateway --features testkit-harness,loopback-provider --test content_journey -- --exact native_content_process_capacity_fixture_is_current` + passed one generator in 6.52 seconds after the retained native-record assertions + were added. The artifact is `bindings/fixtures/gateway/content-process-capacity.json`. +- Scope is actual production daemon/CLI/native authority and final file fencing + for source-lifetime acquisition count/byte ceilings. It is not managed fixed + windows/count/sum, PostgreSQL, hostile UID containment, distributed filesystem + fencing or power-loss evidence. A04 remains partial and no A01–A22 gate closes. + The PostgreSQL/process/fault cases and CI batch corrections are the next work. + ## Phase gates | Phase | State | Outstanding gate | @@ -1616,7 +1652,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / partial / narrow file admission, prerequisite and managed read charge fixtures | Full adapter concurrency and all units pending | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real two-daemon native file acquisition capacity / final source allocation, retained count/bytes and no refetch after restart executed | Fixed-window count/sum and complete PostgreSQL/process cases pending | | A05 | Crash at every persistence/transport boundary | Partial / real daemon/recipient crash after receipt before ACK / charged unknown and exact late ACK executed | Remaining persistence/send boundaries and PostgreSQL | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 5b6a1c3d9..a7553f110 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -668,6 +668,15 @@ optional input to future managed Google capability/differential extraction. The existing broker and corpus are preserved; native Google metadata, token refresh and Python journal migration are deferred rather than AP074 exit gates. +`content-process-capacity.json` adds a real two-daemon file-store history with +separate joined local custody. After fifteen source acquisitions, two new exact +approved reads contend for the final lifetime allocation. One grant/request wins; +the other native record is not-entered for exhaustion with no new charge. Sixteen +grant audits, allocations, provider calls and full response ceilings are retained. +Restart/replay changes neither journal bytes nor provider count. This is finite +source-lifetime count/byte evidence, not fixed-window count/sum or PostgreSQL +conformance; those acceptance requirements remain open. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index 953acd86b..4d9a64f5b 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -211,11 +211,15 @@ impl Drop for Provider { struct Daemon(Child); impl Daemon { fn start(state: &Path, socket: &Path, port: u16) -> Self { + Self::start_at_admin(state, socket, &state.join("admin.sock"), port) + } + fn start_at_admin(state: &Path, socket: &Path, admin: &Path, port: u16) -> Self { let child = command( "serve", &[ ("--state-dir", path(state)), ("--app-socket", path(socket)), + ("--admin-socket", path(admin)), ("--loopback-provider", &port.to_string()), ], &[], @@ -1198,3 +1202,346 @@ fn native_read_only_process_journey_fixture_is_current() { } assert_eq!(std::fs::read(output).expect("fixture"), artifact); } + +struct ReadOnlyInstallation { + _directory: tempfile::TempDir, + root: PathBuf, + state: PathBuf, + now: u64, + reviewer: SigningKey, +} +impl ReadOnlyInstallation { + fn create() -> Self { + let fixtures = + Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let source = std::fs::read(fixtures.join("content-only/recipe.json")).expect("source"); + let lock = std::fs::read(fixtures.join("content-only/profile.lock.json")).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("recipe"); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock") + .as_secs(); + let tools = [CONTENT_READ_TOOL, DISCLOSURE_TOOL].map(|tool| { + McpToolCall::new(recipe.review().service(), tool, serde_json::Map::new()).expect("tool") + }); + let trust = tools_context(&tools, now).expect("trust"); + let reviewer = SigningKey::from_bytes(&[29; 32]); + let policy = EffectPolicy::new( + "process-capacity".to_owned(), + 1, + reviewer.verifying_key().to_bytes(), + ) + .expect("policy"); + let directory = tempfile::Builder::new() + .prefix("ap74-cap-") + .tempdir_in("/tmp") + .expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let state = root.join("state"); + for (name, bytes) in [ + ("recipe", source), + ("lock", lock), + ("trust", trust), + ( + "policy", + policy.to_private_bytes().expect("policy").to_vec(), + ), + ] { + private(&root.join(name), &bytes); + } + success(cli( + "install", + &[ + ("--state-dir", path(&state)), + ("--recipe", path(&root.join("recipe"))), + ("--profile-lock", path(&root.join("lock"))), + ("--trusted-context", path(&root.join("trust"))), + ("--effect-policy", path(&root.join("policy"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "airtable"), + ("--alias", "capacity"), + ("--account-label", "public-capacity-fixture"), + ], + &["--credential-stdin"], + Some(SECRET), + )); + private( + &root.join("resource.json"), + &serde_json::to_vec(&json!({"record_id":RECORD})).expect("resource"), + ); + Self { + _directory: directory, + root, + state, + now, + reviewer, + } + } + fn join_peer(&self) -> PathBuf { + let peer = self.root.join("peer"); + let recipe = CompiledRecipe::compile( + &std::fs::read(self.root.join("recipe")).expect("recipe"), + &std::fs::read(self.root.join("lock")).expect("lock"), + ) + .expect("recipe"); + success(cli( + "install", + &[ + ("--state-dir", path(&peer)), + ("--attempt-store", path(&self.state.join("attempts"))), + ("--recipe", path(&self.root.join("recipe"))), + ("--profile-lock", path(&self.root.join("lock"))), + ("--trusted-context", path(&self.root.join("trust"))), + ("--effect-policy", path(&self.root.join("policy"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "airtable"), + ("--alias", "capacity"), + ], + &["--join", "--credential-stdin"], + Some(SECRET), + )); + peer + } + fn approve_read(&self, operation: &str) -> Approved { + let call = self.root.join(format!("{operation}.call")); + success(cli( + "effect-content-call", + &[ + ("--state-dir", path(&self.state)), + ( + "--resource-arguments", + path(&self.root.join("resource.json")), + ), + ("--operation", operation), + ("--call-out", path(&call)), + ], + &[], + None, + )); + approve( + &self.state, + &call_file(&call), + operation, + self.now, + &self.reviewer, + &[], + &["--content"], + ) + } +} + +fn private_capacity_records(state: &Path) -> std::collections::BTreeMap> { + std::fs::read_dir(state.join("attempts")) + .expect("journal directory") + .map(|entry| entry.expect("journal entry").path()) + .filter(|path| { + path.file_name().is_some_and(|name| { + let name = name.to_string_lossy(); + name.ends_with(".json") + && (name.starts_with("claim-") || name.starts_with("allocation-")) + }) + }) + .map(|path| { + ( + path.file_name() + .expect("name") + .to_string_lossy() + .into_owned(), + std::fs::read(path).expect("private journal"), + ) + }) + .collect() +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one real two-daemon allocation, replay and restart history" +)] +fn native_content_process_capacity_fixture_is_current() { + let installation = ReadOnlyInstallation::create(); + let root = &installation.root; + let provider = Provider::start(); + let left_socket = root.join("left.sock"); + let right_socket = root.join("right.sock"); + let left = Daemon::start_at_admin( + &installation.state, + &left_socket, + &root.join("left-admin.sock"), + provider.port, + ); + let peer = installation.join_peer(); + let right = Daemon::start_at_admin( + &peer, + &right_socket, + &root.join("right-admin.sock"), + provider.port, + ); + assert_ne!(left.0.id(), right.0.id(), "independent gateway processes"); + let operations: Vec<_> = (0..17).map(|index| format!("capacity-{index}")).collect(); + let approved: Vec<_> = operations + .iter() + .map(|operation| installation.approve_read(operation)) + .collect(); + assert!( + provider.calls().is_empty(), + "authoring does not acquire capacity or contact provider" + ); + let mut histories = Vec::new(); + for (index, effect) in approved.iter().enumerate().take(15) { + let socket = if index % 2 == 0 { + &left_socket + } else { + &right_socket + }; + let result = public(effect.execute("content-acquire", socket, &[], &[], None)); + assert_eq!( + result["history"]["snapshot"]["stage"], "response-recorded", + "{result}" + ); + histories.push(result); + } + assert_eq!(provider.calls().len(), 15); + let barrier = std::sync::Barrier::new(3); + let (a, b) = thread::scope(|scope| { + let first = scope.spawn(|| { + barrier.wait(); + public(approved[15].execute("content-acquire", &left_socket, &[], &[], None)) + }); + let second = scope.spawn(|| { + barrier.wait(); + public(approved[16].execute("content-acquire", &right_socket, &[], &[], None)) + }); + barrier.wait(); + ( + first.join().expect("first contender"), + second.join().expect("second contender"), + ) + }); + let race = [a, b]; + assert_eq!( + race.iter() + .filter(|value| value["history"]["snapshot"]["stage"] == "response-recorded") + .count(), + 1, + "one final allocation: {race:?}" + ); + let refused = race + .iter() + .find(|value| value["history"]["snapshot"]["stage"] == "not-entered") + .unwrap_or_else(|| panic!("missing capacity refusal: {race:?}")) + .clone(); + assert_eq!(refused["history"]["snapshot"]["reserved_calls"], 0); + assert_eq!(refused["history"]["snapshot"]["reserved_bytes"], 0); + histories.extend(race); + let calls: u64 = histories + .iter() + .map(|value| { + value["history"]["snapshot"]["reserved_calls"] + .as_u64() + .expect("calls") + }) + .sum(); + let bytes: u64 = histories + .iter() + .map(|value| { + value["history"]["snapshot"]["reserved_bytes"] + .as_u64() + .expect("bytes") + }) + .sum(); + assert_eq!( + (calls, bytes), + (16, 16 * 1024), + "lifetime count and full response ceiling conserved" + ); + assert_eq!( + provider.calls().len(), + 16, + "one external request per admitted read" + ); + for (operation, expected) in operations.iter().zip(&histories) { + assert_eq!( + &history(&right_socket, operation), + expected, + "cross-process history" + ); + } + let retained = private_capacity_records(&installation.state); + let claims: Vec = retained + .iter() + .filter(|(name, _)| name.starts_with("claim-")) + .map(|(_, bytes)| serde_json::from_slice(bytes).expect("native record")) + .collect(); + assert_eq!(claims.len(), 17); + assert_eq!( + claims + .iter() + .filter(|record| !record["entry"].is_null()) + .count(), + 16, + "one durable grant per provider entry" + ); + let not_entered = claims + .iter() + .find(|record| record["state"]["facts"]["phase"]["stage"] == "not-entered") + .expect("durable capacity refusal"); + assert_eq!(not_entered["state"]["protocol"], "acquisition"); + assert_eq!( + not_entered["state"]["facts"]["phase"]["code"], + "gateway.acquisition.exhausted" + ); + assert!(not_entered["entry"].is_null()); + assert!(not_entered["state"]["facts"]["allocation"].is_null()); + assert_eq!(not_entered["state"]["facts"]["counters"], json!([])); + assert_eq!( + retained + .keys() + .filter(|name| name.starts_with("allocation-")) + .count(), + 16 + ); + drop(left); + drop(right); + let reopened_socket = root.join("reopened.sock"); + let reopened = Daemon::start_at_admin( + &installation.state, + &reopened_socket, + &root.join("reopened-admin.sock"), + provider.port, + ); + for ((effect, operation), expected) in approved.iter().zip(&operations).zip(&histories) { + assert_eq!( + &public(effect.execute("content-acquire", &reopened_socket, &[], &[], None)), + expected, + "restart replay {operation}" + ); + } + assert_eq!( + provider.calls().len(), + 16, + "replays cannot allocate or refetch after restart" + ); + assert_eq!( + private_capacity_records(&installation.state), + retained, + "replay leaves journal, grants and allocations byte-for-byte unchanged" + ); + drop(reopened); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.content-process-capacity/1", + "scope":"two independent production daemon processes with separate joined local custody and CLI callers; real native proof/approval/fenced file adapter, counting local HTTP; source-lifetime acquisition count/response ceilings only, not managed fixed-window count/sum, PostgreSQL, distributed fencing or power loss", + "initial_allocations":15,"final_contenders":2,"final_grants":1,"exhausted":1, + "provider_calls":provider.calls().len(),"retained_calls":calls,"retained_response_bytes":bytes, + "all_requests_exact":provider.calls().iter().all(|line|line==&format!("GET /documents/{RECORD}?format=text%2Fplain HTTP/1.1")), + "restart_replay_no_refetch":true,"cross_process_history_matches":true, + "durable_grants":16,"permanent_allocations":16,"native_refusal_code":"gateway.acquisition.exhausted", + "journal_and_allocations_unchanged_after_restart_replay":true, + "successful_read":histories[0],"capacity_refusal":refused})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/content-process-capacity.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write artifact"); + } + assert_eq!(std::fs::read(path).expect("artifact"), artifact); +} From 715bd798097deb81df1db0160cc26cc9d4eb24c4 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 00:08:02 +0000 Subject: [PATCH 067/136] test(gateway): exercise native process capacity on both durable adapters --- .github/workflows/postgres-lifecycle.yml | 3 + .../gateway/native-process-capacity-file.json | 15 + .../native-process-capacity-postgres.json | 15 + docs/plans/0074-implementation-status.md | 38 +- ...ound-effects-and-recovery-state-machine.md | 9 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../auths-gateway/src/native_process_tests.rs | 497 ++++++++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- 9 files changed, 581 insertions(+), 3 deletions(-) create mode 100644 bindings/fixtures/gateway/native-process-capacity-file.json create mode 100644 bindings/fixtures/gateway/native-process-capacity-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_process_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 781fe2469..e28898ac1 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -40,6 +40,9 @@ jobs: AUTHS_POSTGRES_SERVER_NAME: localhost run: | cargo test -p auths-gateway --lib -- --ignored postgres + cargo test -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --exact native_content_process_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_process_tests::native_file_process_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-process-capacity-file.json b/bindings/fixtures/gateway/native-process-capacity-file.json new file mode 100644 index 000000000..4e3b5872b --- /dev/null +++ b/bindings/fixtures/gateway/native-process-capacity-file.json @@ -0,0 +1,15 @@ +{ + "schema": "auths.native-process-capacity/1", + "adapter": "file", + "scope": "full native engine compilation, exact fixed-key approval, installed dependency fencing and real HTTP across two independent processes; fixed test deployment clock and separate local custody; source-lifetime acquisition count/response bytes only; no human UI, hostile containment, power-loss or distributed-file claim", + "prefilled": 15, + "contenders": 2, + "winner_count": 1, + "not_entered": 1, + "durable_grants": 16, + "refusal_code": "gateway.acquisition.exhausted", + "reserved_calls": 16, + "reserved_bytes": 16384, + "provider_calls": 16, + "reopened_replay_no_refetch": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-process-capacity-postgres.json b/bindings/fixtures/gateway/native-process-capacity-postgres.json new file mode 100644 index 000000000..a25babf87 --- /dev/null +++ b/bindings/fixtures/gateway/native-process-capacity-postgres.json @@ -0,0 +1,15 @@ +{ + "schema": "auths.native-process-capacity/1", + "adapter": "postgres", + "scope": "full native engine compilation, exact fixed-key approval, installed dependency fencing and real HTTP across two independent processes; fixed test deployment clock and separate local custody; source-lifetime acquisition count/response bytes only; no human UI, hostile containment, power-loss or distributed-file claim", + "prefilled": 15, + "contenders": 2, + "winner_count": 1, + "not_entered": 1, + "durable_grants": 16, + "refusal_code": "gateway.acquisition.exhausted", + "reserved_calls": 16, + "reserved_bytes": 16384, + "provider_calls": 16, + "reopened_replay_no_refetch": true +} \ No newline at end of file diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 9f60e8d25..be5f40cb8 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1631,6 +1631,42 @@ closure regeneration passed after that correction (one artifact-generation test) fencing or power-loss evidence. A04 remains partial and no A01–A22 gate closes. The PostgreSQL/process/fault cases and CI batch corrections are the next work. +## Native file/PostgreSQL independent-process capacity checkpoint + +- The next common case drives the full native GatewayEngine in two separate OS + processes over each maintained adapter, rather than substituting the test + EntryValidation oracle. Parent and peers use explicit native trust, real signed + actions, exact approvals and current installed dependency/configuration checks. + The deployment clock and signing keys are explicitly fixed test inputs. +- `native_process_tests.rs` attaches peers to the same file location or isolated + TLS PostgreSQL schema. Each process has separate private persistent custody. + After fifteen native acquisitions, ready peers are released through a bounded + test-only barrier and contend for the final source-lifetime allocation while a + real local HTTP double counts exact requests and credential insertion. +- Both adapters record exactly sixteen grants and real GETs, sixteen calls and + 16,384 full-ceiling response bytes, plus one exhausted not-entered record. + Reopening the store/engine and replaying all seventeen operations grants no + further provider access. There is no unchecked effect/approval or final-entry + authorization oracle in this path. +- Required artifacts `native-process-capacity-file.json` and + `native-process-capacity-postgres.json` were generated by exact native tests + with features loopback-provider,testkit-harness. The file generator passed in + 2.20 seconds; the ignored PostgreSQL generator passed in 8.54 seconds against an + independently started TLS fixture on port 55451. Its schema is disposable and + removed on exit. PostgreSQL used certificate verification and synchronous + commits. The dedicated containers/volume were stopped and removed after + construction. Gateway source-closure generation passed one exact generator in + 0.08 seconds after the new module was finalized. +- This is a privileged test installation of the native engine, not production + commissioning/image qualification; the production-CLI file case is separate. +- PostgreSQL CI now explicitly runs both feature-gated process cases; merely + discovering the normal default-feature suite would not execute these tests. + This does not claim a hosted result until that workflow passes on the new head. +- Scope is full native entry checking and real process/adapter/provider boundaries + for source-lifetime acquisition count/bytes. Managed fixed-window count/sum, + all crash/fault and dependency-race schedules, hostile agent containment and + human UI remain open. A04 remains partial; no acceptance row is closed here. + ## Phase gates | Phase | State | Outstanding gate | @@ -1652,7 +1688,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real two-daemon native file acquisition capacity / final source allocation, retained count/bytes and no refetch after restart executed | Fixed-window count/sum and complete PostgreSQL/process cases pending | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / two-daemon file and full native engine processes on file/TLS PostgreSQL / final source lifetime count/bytes, durable grants and reopened replay executed | Managed fixed-window count/sum and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / real daemon/recipient crash after receipt before ACK / charged unknown and exact late ACK executed | Remaining persistence/send boundaries and PostgreSQL | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index a7553f110..71fccfabf 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -677,6 +677,15 @@ Restart/replay changes neither journal bytes nor provider count. This is finite source-lifetime count/byte evidence, not fixed-window count/sum or PostgreSQL conformance; those acceptance requirements remain open. +The common `native-process-capacity-{file,postgres}.json` cases additionally use +full native engine entry validation in separate OS processes over both durable +adapters, with exact proofs/approvals, fixed test deployment time and separate +custody. They record one final winner and an exhausted non-entry while an actual +HTTP double counts sixteen total grants/GETs, and reopening cannot remint access. +These cases use no final-entry authorization oracle. They establish the stated +source-lifetime count/byte behavior; fixed-window count/sum, complete fault and +race schedules and deployed hostile-process containment remain separate gates. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index e72552436..9ad306873 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c37b065fd0c20d090fb0913c8bdc094a362b7102e105d599014cde2feedffca4"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"d5d7871b284bfed8c1cbc55f5ef31c2a769e3c86ed0e8ec65afd0ad3adacaf68"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"ae791a5213b4b2549692d39d2b7853977f85aa281b04591d781b31258b6905a9"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"2a791b73f51e92c49c3dce60cd19325f1919ce1640ffdf7060dc30e46ea410b9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c37b065fd0c20d090fb0913c8bdc094a362b7102e105d599014cde2feedffca4"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"d5d7871b284bfed8c1cbc55f5ef31c2a769e3c86ed0e8ec65afd0ad3adacaf68"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"ae791a5213b4b2549692d39d2b7853977f85aa281b04591d781b31258b6905a9"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"006c735b311ccde0c72b4b30386bbe178e15b2c9beaa9024f9ba1b37cd65290c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"2ab677f9797ebd541da60a96857b653f5c58cce017f98b63b24edcd694a99d41"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 65fc9e49c..d5745a5cd 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -154,3 +154,6 @@ pub use support::{ SupportFacts, support_bundle, }; pub use transport::MAX_TRANSPORT_DURATION; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_process_tests; diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs new file mode 100644 index 000000000..715953049 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -0,0 +1,497 @@ +//! Native engine processes over both durable adapters and real local HTTP. +//! Fixed public test keys/clock and a trusted test control channel are explicit; +//! no human-presence, hostile-process isolation or provider qualification claim. +#![cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + +use crate::effect::{CONTENT_READ_TOOL, ExactEffectApproval, fixture_policy}; +use crate::harness::authoring::{tool_fixture, tools_context}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, CompiledRecipe, GatewayAttempts, GatewayEngine, + GatewaySubmitResult, QualificationGate, QualificationPolicy, SharedConnection, +}; +use auths_connections::{ + ConnectionCredentialStore as _, ConnectionRecord, PersistentCredentialStore, SecretBytes, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use std::{ + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + process::{Child, Command, Stdio}, + sync::{ + Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, + }, + thread, + time::{Duration, Instant}, +}; + +const NOW: u64 = 1_790_000_000; +const SECRET: &[u8] = b"public-native-process-fixture"; +const CONTENT: &[u8] = b"PUBLIC-NATIVE-CONTENT"; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Setup { + backend: String, + location: String, + root: PathBuf, + provider_port: u16, + barrier_port: u16, +} + +fn private(path: &Path, bytes: &[u8]) { + std::fs::write(path, bytes).expect("private input"); + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("private mode"); +} +fn recipe() -> CompiledRecipe { + CompiledRecipe::compile( + include_bytes!("../../../../bindings/fixtures/gateway/content-only/recipe.json"), + include_bytes!("../../../../bindings/fixtures/gateway/content-only/profile.lock.json"), + ) + .expect("recipe") +} +fn trust(recipe: &CompiledRecipe) -> Vec { + let call = McpToolCall::new( + recipe.review().service(), + CONTENT_READ_TOOL, + serde_json::Map::new(), + ) + .expect("tool"); + tools_context(&[call], NOW).expect("native trust") +} +fn runtime() -> tokio::runtime::Runtime { + tokio::runtime::Runtime::new().expect("runtime") +} + +async fn load_engine( + setup: &Setup, + label: &str, + attempts: GatewayAttempts, +) -> (GatewayEngine, ConnectionRecord) { + let recipe = recipe(); + let initial = crate::harness::fixture_connection(&recipe).expect("connection template"); + let credentials = Arc::new( + PersistentCredentialStore::open(setup.root.join(format!("custody-{label}.cbor"))) + .expect("custody"), + ); + let reference = credentials + .install( + initial.connection_id(), + initial.credential_generation(), + SecretBytes::new(SECRET.to_vec()).expect("synthetic credential"), + ) + .await + .expect("credential install"); + let record = ConnectionRecord::new( + initial.provider_kind().clone(), + initial.alias().clone(), + initial.connection_id().clone(), + initial.contract().clone(), + initial.descriptor_schema().clone(), + initial.descriptor().to_vec(), + *initial.account_commitment(), + *reference.as_bytes(), + initial.generation(), + initial.state(), + initial.allowed_workloads().to_vec(), + initial.allowed_profiles().to_vec(), + initial.created_at_unix_seconds(), + initial.updated_at_unix_seconds(), + None, + ) + .expect("record"); + let gate = Arc::new(QualificationGate::new( + QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(NOW))), + auths_recipe_qualification::VerifierState::default(), + )); + gate.load(&crate::QualificationBundle { + signer_certificate: Vec::new(), + revocation_list: Vec::new(), + release_index: Vec::new(), + records: Vec::new(), + attestations: Vec::new(), + }); + let profile = record.allowed_profiles()[0].clone(); + let engine = GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &trust(&recipe), + fixture_policy().expect("policy"), + record.provider_kind().clone(), + record.alias().clone(), + "gateway".to_owned(), + profile, + credentials, + attempts, + ) + .expect("engine") + .with_qualification(gate) + .with_loopback_provider(setup.provider_port); + (engine, record) +} + +async fn authorize(engine: &GatewayEngine, root: &Path, operation: &str) { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) + .await + .expect("native call"); + let signed = tool_fixture(&call, NOW).expect("native authority"); + assert_eq!(signed.context, trust(&recipe())); + let effect = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("native effect"); + let request = effect + .approval_request(NOW, NOW + 300) + .expect("review request"); + let key = SigningKey::from_bytes(&[29; 32]); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approval = request.with_signature(signature); + for (suffix, bytes) in [ + ("proof", signed.proof), + ("action", signed.action), + ( + "approval", + approval.to_private_bytes().expect("approval").to_vec(), + ), + ] { + private(&root.join(format!("{operation}.{suffix}")), &bytes); + } +} +async fn acquire( + engine: &GatewayEngine, + root: &Path, + operation: &str, +) -> Result { + let load = + |suffix| std::fs::read(root.join(format!("{operation}.{suffix}"))).expect("native input"); + let approval = ExactEffectApproval::from_private_bytes(&load("approval")).expect("approval"); + engine + .acquire_content_action(&load("proof"), &load("action"), approval) + .await +} + +struct Provider { + port: u16, + calls: Arc, + stop: Arc, + thread: Option>, +} +impl Provider { + fn start() -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); + let port = listener.local_addr().expect("address").port(); + listener.set_nonblocking(true).expect("nonblocking"); + let calls = Arc::new(AtomicUsize::new(0)); + let stop = Arc::new(AtomicBool::new(false)); + let observed = calls.clone(); + let finished = stop.clone(); + let thread = thread::spawn(move || { + while !finished.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(value) => value, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(2)); + continue; + } + Err(error) => panic!("accept: {error}"), + }; + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut header = Vec::new(); + while !header.ends_with(b"\r\n\r\n") { + assert!(header.len() < 8192); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + header.push(byte[0]); + } + let header = String::from_utf8(header).expect("header UTF8"); + assert_eq!( + header.lines().next(), + Some("GET /documents/recTEST0000000001?format=text%2Fplain HTTP/1.1") + ); + assert!( + header + .to_ascii_lowercase() + .contains("authorization: bearer public-native-process-fixture\r\n") + ); + observed.fetch_add(1, Ordering::SeqCst); + stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: close\r\nContent-Length: {}\r\n\r\n",CONTENT.len()).as_bytes()).expect("response headers"); + stream.write_all(CONTENT).expect("response body"); + } + }); + Self { + port, + calls, + stop, + thread: Some(thread), + } + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(thread) = self.thread.take() { + let result = thread.join(); + if !std::thread::panicking() { + result.expect("provider thread"); + } + } + } +} +struct Peer(Child); +impl Drop for Peer { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} + +/// This helper is invoked in fresh OS processes by the parent; ordinary test +/// discovery with no private fixture input does no work. +#[test] +fn native_capacity_peer() { + let Some(input) = std::env::var_os("AUTHS_AP074_CAPACITY_PEER") else { + return; + }; + let input = PathBuf::from(input); + let setup: Setup = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("closed setup"); + let operation = std::env::var("AUTHS_AP074_CAPACITY_OPERATION").expect("operation"); + let store = TestAttempts::attach(Backend::parse(&setup.backend), &setup.location); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine(&setup, &operation, store.attempts().clone())); + let mut signal = TcpStream::connect(("127.0.0.1", setup.barrier_port)).expect("parent barrier"); + signal + .set_read_timeout(Some(Duration::from_secs(10))) + .expect("barrier deadline"); + signal.write_all(b"R").expect("ready"); + let mut start = [0]; + signal.read_exact(&mut start).expect("start"); + assert_eq!(start, *b"G"); + let result = runtime.block_on(acquire(&engine, &setup.root, &operation)); + private( + &setup.root.join(format!("{operation}.result")), + &serde_json::to_vec(&result).expect("native result"), + ); +} + +fn start_peer(input: &Path, operation: &str) -> Peer { + Peer( + Command::new(std::env::current_exe().expect("test binary")) + .args([ + "--exact", + "native_process_tests::native_capacity_peer", + "--nocapture", + ]) + .env("AUTHS_AP074_CAPACITY_PEER", input) + .env("AUTHS_AP074_CAPACITY_OPERATION", operation) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("peer"), + ) +} +fn finish_peer(peer: &mut Peer) { + let deadline = Instant::now() + Duration::from_secs(30); + loop { + if let Some(status) = peer.0.try_wait().expect("peer status") { + let mut diagnostic = String::new(); + peer.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "native process failed: {diagnostic}"); + return; + } + assert!(Instant::now() < deadline, "native peer timeout"); + thread::sleep(Duration::from_millis(5)); + } +} + +#[allow( + clippy::too_many_lines, + reason = "one independent-process history with authoritative native record and counter assertions" +)] +fn capacity(backend: Backend) { + let store = TestAttempts::open(backend); + let runtime = runtime(); + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + let provider = Provider::start(); + let barrier = TcpListener::bind("127.0.0.1:0").expect("barrier"); + barrier.set_nonblocking(true).expect("nonblocking"); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root: root.clone(), + provider_port: provider.port, + barrier_port: barrier.local_addr().expect("barrier address").port(), + }; + let (engine, record) = + runtime.block_on(load_engine(&setup, "parent", store.attempts().clone())); + let shared = SharedConnection::new( + store.attempts().store(), + record.provider_kind().clone(), + record.alias().clone(), + ); + runtime + .block_on(shared.insert(&record)) + .expect("published connection"); + engine + .initialize_effect_configuration() + .expect("installed configuration"); + let operations: Vec<_> = (0..17) + .map(|index| format!("process-capacity-{index}")) + .collect(); + for operation in &operations { + runtime.block_on(authorize(&engine, &root, operation)); + } + assert_eq!(provider.calls.load(Ordering::SeqCst), 0); + let mut snapshots = Vec::new(); + for operation in operations.iter().take(15) { + let result = runtime + .block_on(acquire(&engine, &root, operation)) + .expect("acquisition"); + assert_eq!(result.stage, AcquisitionStage::ResponseRecorded); + snapshots.push(result); + } + assert_eq!(provider.calls.load(Ordering::SeqCst), 15); + let input = root.join("setup.json"); + private(&input, &serde_json::to_vec(&setup).expect("setup")); + let mut left = start_peer(&input, &operations[15]); + let mut right = start_peer(&input, &operations[16]); + assert_ne!(left.0.id(), right.0.id()); + let deadline = Instant::now() + Duration::from_secs(15); + let mut signals = Vec::new(); + while signals.len() < 2 { + match barrier.accept() { + Ok((mut stream, _)) => { + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut ready = [0]; + stream.read_exact(&mut ready).expect("ready"); + assert_eq!(ready, *b"R"); + signals.push(stream); + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "peer ready timeout"); + thread::sleep(Duration::from_millis(5)); + } + Err(error) => panic!("barrier: {error}"), + } + } + for signal in &mut signals { + signal.write_all(b"G").expect("release"); + } + finish_peer(&mut left); + finish_peer(&mut right); + let contenders: Vec = operations + .iter() + .skip(15) + .map(|operation| { + let value: Result = serde_json::from_slice( + &std::fs::read(root.join(format!("{operation}.result"))).expect("result"), + ) + .expect("native result"); + value.expect("native acquisition result") + }) + .collect(); + assert_eq!( + contenders + .iter() + .filter(|value| value.stage == AcquisitionStage::ResponseRecorded) + .count(), + 1 + ); + assert_eq!( + contenders + .iter() + .filter(|value| value.stage == AcquisitionStage::NotEntered) + .count(), + 1 + ); + snapshots.extend(contenders); + let calls: u64 = snapshots.iter().map(|value| value.reserved_calls).sum(); + let bytes: u64 = snapshots.iter().map(|value| value.reserved_bytes).sum(); + assert_eq!((calls, bytes), (16, 16 * 1024)); + assert_eq!(provider.calls.load(Ordering::SeqCst), 16); + let mut entries = 0; + let mut refusals = 0; + let raw = store.attempts().store(); + for key in raw.attempt_keys(32).expect("keys") { + let value: serde_json::Value = serde_json::from_slice( + &raw.load(crate::GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"), + ) + .expect("record JSON"); + if !value["entry"].is_null() { + entries += 1; + } + if value["state"]["facts"]["phase"]["stage"] == "not-entered" { + assert_eq!( + value["state"]["facts"]["phase"]["code"], + "gateway.acquisition.exhausted" + ); + refusals += 1; + } + } + assert_eq!((entries, refusals), (16, 1)); + let (reopened, _) = runtime.block_on(load_engine(&setup, "reopened", store.reopen())); + for (operation, expected) in operations.iter().zip(&snapshots) { + assert_eq!( + &runtime + .block_on(acquire(&reopened, &root, operation)) + .expect("replay"), + expected + ); + } + assert_eq!(provider.calls.load(Ordering::SeqCst), 16); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-process-capacity/1","adapter":backend.label(), + "scope":"full native engine compilation, exact fixed-key approval, installed dependency fencing and real HTTP across two independent processes; fixed test deployment clock and separate local custody; source-lifetime acquisition count/response bytes only; no human UI, hostile containment, power-loss or distributed-file claim", + "prefilled":15,"contenders":2,"winner_count":1,"not_entered":1,"durable_grants":entries, + "refusal_code":"gateway.acquisition.exhausted","reserved_calls":calls,"reserved_bytes":bytes, + "provider_calls":provider.calls.load(Ordering::SeqCst),"reopened_replay_no_refetch":true})).expect("artifact"); + let output = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-process-capacity-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &artifact).expect("write"); + } + assert_eq!(std::fs::read(output).expect("artifact"), artifact); +} + +#[test] +fn native_file_process_capacity_fixture_is_current() { + capacity(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_process_capacity_fixture_is_current() { + assert!(postgres_configured()); + capacity(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 9fb335deb..6a38b958b 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "79e26cc90a3d81dbe9107f9b0e5c10b08e38528705969a47c31b38ba6144547b"; + "4f96a74b45c1d73d5a0d21a1666a556bed1a5f3fa7284d3c324a9927367d4bc7"; #[cfg(test)] mod tests { From 08f0064cf2b5d13b809cfba19f63f695124c008d Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 00:13:05 +0000 Subject: [PATCH 068/136] fix(gateway): preserve pending prerequisite ownership and align CI contracts --- .../fixtures/gateway/approval-quorum.json | 60 +- .../gateway/attempt-scenarios-v3.json | 4 +- bindings/fixtures/gateway/codes.json | 13 +- bindings/python/api/public-api.txt | 1 + compliance.toml | 329 ++++---- .../qualification/aeneas/source-closure.json | 6 +- .../auths-connections/src/credential.rs | 6 +- .../auths-gateway-kernel/src/transition.rs | 4 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/app.rs | 8 +- .../runtime/auths-gateway/src/app/content.rs | 5 +- .../auths-gateway/src/bin/auths-gateway.rs | 49 +- product/runtime/auths-gateway/src/bounds.rs | 5 +- .../auths-gateway/src/candidate_runtime.rs | 11 +- .../src/commissioning_session.rs | 17 +- .../auths-gateway/src/configuration.rs | 15 +- .../auths-gateway/src/disclosure_transport.rs | 6 +- product/runtime/auths-gateway/src/effect.rs | 16 +- .../auths-gateway/src/effect/acquisition.rs | 13 +- .../auths-gateway/src/effect/candidate.rs | 8 +- .../src/effect/candidate/proposal.rs | 5 +- .../auths-gateway/src/effect/content.rs | 9 +- .../auths-gateway/src/effect/prerequisite.rs | 2 +- .../auths-gateway/src/effect/release.rs | 9 +- .../src/effect_candidate_staging_tests.rs | 737 ++++++++++-------- .../src/effect_candidate_tests.rs | 6 +- .../auths-gateway/src/effect_content_tests.rs | 33 +- .../src/effect_disclosure_delivery_tests.rs | 28 +- .../auths-gateway/src/effect_native_tests.rs | 276 ++++--- .../src/effect_prerequisite_tests.rs | 282 ++++--- .../src/effect_recovery_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 13 +- product/runtime/auths-gateway/src/entry.rs | 8 +- .../runtime/auths-gateway/src/entry_tests.rs | 10 +- product/runtime/auths-gateway/src/harness.rs | 27 +- .../src/pending_vectors/attempts.rs | 2 +- .../src/pending_vectors/codes.rs | 3 +- .../src/pending_vectors/production.rs | 10 +- .../src/prerequisite_race_tests.rs | 129 +++ .../src/qualification_simulation.rs | 58 +- .../runtime/auths-gateway/src/quorum_tests.rs | 31 +- .../auths-gateway/src/recipe/content.rs | 8 +- .../auths-gateway/src/recipe/effect_review.rs | 4 +- .../auths-gateway/src/recipe/review.rs | 35 +- .../runtime/auths-gateway/src/recipe/tests.rs | 4 +- .../auths-gateway/src/scenario_tests.rs | 10 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 86 +- .../auths-gateway/src/store/acquisition.rs | 623 +++++++++------ .../src/store/acquisition/candidate.rs | 148 ++-- .../src/store/acquisition/recovery.rs | 15 +- .../auths-gateway/src/store/disclosure.rs | 8 +- product/runtime/auths-gateway/src/submit.rs | 76 +- .../runtime/auths-gateway/src/transport.rs | 117 +-- .../tests/application_content_cli.rs | 2 +- .../tests/application_recovery_cli.rs | 2 +- .../auths-gateway/tests/candidate_cli.rs | 454 ++++++----- .../auths-gateway/tests/candidate_journey.rs | 2 +- .../auths-gateway/tests/content_journey.rs | 6 +- .../auths-openapi-derive/tests/corpus.rs | 2 +- release/semantic-freeze-versions.toml | 12 +- release/semantic-freeze.json | 22 +- 62 files changed, 2297 insertions(+), 1599 deletions(-) create mode 100644 product/runtime/auths-gateway/src/prerequisite_race_tests.rs diff --git a/bindings/fixtures/gateway/approval-quorum.json b/bindings/fixtures/gateway/approval-quorum.json index 9fa26ada4..fd14d0bf8 100644 --- a/bindings/fixtures/gateway/approval-quorum.json +++ b/bindings/fixtures/gateway/approval-quorum.json @@ -61,9 +61,9 @@ "manager-a", "manager-b" ], - "arguments_json": "{\"operation_id\":\"managers-a-and-b\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWEtYW5kLWIiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOpzV3s62LHkrPp42Agd5wOD7juib-buc4Ot4QUEwxvuBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQHVx7LCrrRztSm-zK_fRyrTBiGyezpt0WeCUl4sCD8UiyHy7ZHhnCxATkLKTin8tQlN-njWRaSMo36JmRi2-GAUDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggZInoF8PVZEQ4wDLtoQbBvUXv-LFxLpj_txUWppDzviQBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYS1hbmQtYiIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6UW40ZGVkRjVUVjRoOFVTaVRWZUF4cFk1NHE1d1ZIRUFuSUhXYXlEbThUYwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCDqc1d7Otix5Kz6eNgIHecDg-47om_m7nODreEFBMMb7gVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAmplZDI1NTE5LXYxAVhA1n-MDrybEYyRH6Rcb7U-PiOxE3G6mI4mUn39XUvWikHJmtF-KSr1oq_HUa90lp2wpi0k3d9dURmPUkCQ2rD6CAKBpABYIKv3gRUV1c8LdOzeOf5JKOTDse7OpXZPRg3brOIvnLchAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACBVFU9CBl6lob6gVGOCa-JoTrkt-SwQACequq5XylVCB6MArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOpzV3s62LHkrPp42Agd5wOD7juib-buc4Ot4QUEwxvuBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEAGDRXWiXneJD-ksuFGtaOueVNkyPFJAzyI-HRX9Ms4bvRCTA0cQA9S1u9Qj9oKbFPR_ua5GvRJqhfMLl1CktwHAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", + "arguments_json": "{\"operation_id\":\"managers-a-and-b\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWEtYW5kLWIiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIEoFupjT9hnMbSVkVQjtlvbEtNFnYGfBF5FoHaX0P2EbBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBIfWS0f8dICle8_Ra38Ubam8HtUlc13zDZ60VhNQ3ozWOiDimg6HUWnK-vuoLT8dF7FdeS_l3b06JcoXWxCIAIDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVgg72nGBdpNDHwDWWpi-5em-TMwgbNjwxyaY60jS3XCjiIBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYS1hbmQtYiIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6UW40ZGVkRjVUVjRoOFVTaVRWZUF4cFk1NHE1d1ZIRUFuSUhXYXlEbThUYwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBKBbqY0_YZzG0lZFUI7Zb2xLTRZ2BnwReRaB2l9D9hGwVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAmplZDI1NTE5LXYxAVhA-1EGI1hldAsa9ana0DslVyjWTL8Rme_g1kwJNDq5OUqpSfuGiU4lkETR92Sdkl2s66TDiqTuKwsXw4tVePknDwKBpABYIKv3gRUV1c8LdOzeOf5JKOTDse7OpXZPRg3brOIvnLchAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACBVFU9CBl6lob6gVGOCa-JoTrkt-SwQACequq5XylVCB6MArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIEoFupjT9hnMbSVkVQjtlvbEtNFnYGfBF5FoHaX0P2EbBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWECMYOXozAyJJBZVSSDg0nfnzAfWKgFcyLCmYqmDTCfgyb9O7aN-wtngVos18Sthuk6L2ir-YJm95X2NpLAmSZwGAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", "decision": "authorized", "code": "", "provider_entries": 1 @@ -76,9 +76,9 @@ "manager-a", "manager-c" ], - "arguments_json": "{\"operation_id\":\"managers-a-and-c\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWEtYW5kLWMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIH13PaBH8EtNI8YA9aLewtQ0q565qfFI8L6ZWWLBzWDoBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQMP5-QOG9O7B8FeCZgUDF-WDlOjD2urQGftuEQmlx4UeN-7Zkzb-o_WmMMga0a4ndstJ2696mt1guIMgpBpNOQoDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggjMBmSoPx6m8ma72LP48uyDj3N8kmk-OOSeOT3J-wn4MBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYS1hbmQtYyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCB9dz2gR_BLTSPGAPWi3sLUNKueuanxSPC-mVliwc1g6AVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AmplZDI1NTE5LXYxAVhAKGeqGqA32RrRu8HEBplvNyH_6U7DauRurxpQ_q_aoDokB53w_WPkzSLQZ6wQ5Qns5IUzbimeJxTlwvnDfQ0xDgKBpABYIBSBPQS527Dja0ON50GQgwYoiggBsJJ0iOeRqdCjw0emAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACC8fLy1Y2N1-h2CQ01GZyTZI3f1O5gGld1J0m0M4SIFpaMArQABAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIH13PaBH8EtNI8YA9aLewtQ0q565qfFI8L6ZWWLBzWDoBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Oi1TeG16MFpLT2tqcW5pYzM4UDByQUVMa1NMOVdjRGlDVDFNXzdUR0VrTjQCamVkMjU1MTktdjEBWECxUsyRUFGAJcgMYMTfPpUwTecDcNN5hiHTJcGhwRAOrpUebu-3y6XoLzrpf8hRDzfMJLC8OraGJlREtecgWKIAAoGkAFggxvsMhQsa81ih4H74bbSV8f283nuV3_n_ZzkvzWIMzW8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINQEvERWWu27iZFQ5bCzsyuUQb8Mt4hMMxMNqNvCfdLP", + "arguments_json": "{\"operation_id\":\"managers-a-and-c\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWEtYW5kLWMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYICrmHAZNxB2fSJIa3acwwpSQLfHt62S4A8_N5PWdVMDcBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQHh4pPGMV8WInzhGWbeD6gbfq2LsPzhlHm23rbScarT2aptaNS1E6_RfWZvvGvRRt5QZQ1pWDveRgjNaDNK7xQkDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggzmbWC7K3PLtbeKttB1r3J480qM96-KQegkPV8h9hcdYBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYS1hbmQtYyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAq5hwGTcQdn0iSGt2nMMKUkC3x7etkuAPPzeT1nVTA3AVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AmplZDI1NTE5LXYxAVhA7u1DDYPKUfVZ31CYJqAmt8jMcQcIpUvznwZfo3Eqp6VjSR8bj0wlMOqdTizzPrx22nnA-MpxlVcRK95bGp1qCQKBpABYIBSBPQS527Dja0ON50GQgwYoiggBsJJ0iOeRqdCjw0emAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACC8fLy1Y2N1-h2CQ01GZyTZI3f1O5gGld1J0m0M4SIFpaMArQABAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYICrmHAZNxB2fSJIa3acwwpSQLfHt62S4A8_N5PWdVMDcBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Oi1TeG16MFpLT2tqcW5pYzM4UDByQUVMa1NMOVdjRGlDVDFNXzdUR0VrTjQCamVkMjU1MTktdjEBWEDOMLavgqjiebdqf5VeVI7fkthz7wCwZq_jgd12VUbbMrunS3OaDcj6XbK3aJpQI8qtwEJeYP2krTdBzLt3ygQCAoGkAFggxvsMhQsa81ih4H74bbSV8f283nuV3_n_ZzkvzWIMzW8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINQEvERWWu27iZFQ5bCzsyuUQb8Mt4hMMxMNqNvCfdLP", "decision": "authorized", "code": "", "provider_entries": 1 @@ -91,9 +91,9 @@ "manager-b", "manager-c" ], - "arguments_json": "{\"operation_id\":\"managers-b-and-c\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWItYW5kLWMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDEthECyLhWg8BPiF4RW2IlpGg_DlYShKoGJ1lza3CPtBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBDNHIrEAz9qh-gwzj2p2KnILDYVcXWoTMGkr--TBKkeKARLk1IzOHy-BXayYi4h0DXAoSP2a64TqTXwueM4IgEDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggqvOHw5n5SXIia157KcN-mnb1WPIYJmqRVrCR2W1Eh4gBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYi1hbmQtYyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6LVN4bXowWktPa2pxbmljMzhQMHJBRUxrU0w5V2NEaUNUMU1fN1RHRWtONAJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAxLYRAsi4VoPAT4heEVtiJaRoPw5WEoSqBidZc2twj7QVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AmplZDI1NTE5LXYxAVhApEpZq_0OrDt-Z1Zgz7qgqKxyq4RM1zbnp1B4TBfy6Fb2kNMlhebW1G--DnoCWx0cBhrIop-1dnQdrXfl8bFEAAKBpABYIMb7DIULGvNYoeB--G20lfH9vN57ld_5_2c5L81iDM1vAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDUBLxEVlrtu4mRUOWws7MrlEG_DLeITDMTDajbwn3Sz6MArQABAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDEthECyLhWg8BPiF4RW2IlpGg_DlYShKoGJ1lza3CPtBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlFuNGRlZEY1VFY0aDhVU2lUVmVBeHBZNTRxNXdWSEVBbklIV2F5RG04VGMCamVkMjU1MTktdjEBWECQ0fPI9KpNrIrZ5WJACF8TXlRWayzpTIj5qusxHE8NyK9ynyWl6cdtkhUzjpZ0TP0bzCJ_Obfb0xb4Y7Fq6G8DAoGkAFggq_eBFRXVzwt07N45_kko5MOx7s6ldk9GDdus4i-ctyEBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIFUVT0IGXqWhvqBUY4Jr4mhOuS35LBAAJ6q6rlfKVUIH", + "arguments_json": "{\"operation_id\":\"managers-b-and-c\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBSnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im1hbmFnZXJzLWItYW5kLWMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINU0p3jGYSP_Xrenk08NXmwWgX9SYxTPLko5JDphZmP6BWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQG0z-EiVmq92NKczlOTqYiVQOlfmyoUi0VWhvu3RctnEbAV3Wg4fBuLnmfl7qLpnUPej21IcYd09Ab_VmGXLRQMDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggFV_Ek66VEs5eRUDcYn7LZ1wZ13V8eVGZ1oxf3MzToGgBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFKeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibWFuYWdlcnMtYi1hbmQtYyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoKjAK0AAQF4NmtleTpzaGEyNTY6UW40ZGVkRjVUVjRoOFVTaVRWZUF4cFk1NHE1d1ZIRUFuSUhXYXlEbThUYwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCDVNKd4xmEj_163p5NPDV5sFoF_UmMUzy5KOSQ6YWZj-gVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAmplZDI1NTE5LXYxAVhAx0uLWhsDAXvMTinutuK1e7fmzUYjk8tdJS-i6YEEa3XSP_5e_pVOgJvvmcL8-76J2ZWsIlaAh75HXLNjKhmbCgKBpABYIKv3gRUV1c8LdOzeOf5JKOTDse7OpXZPRg3brOIvnLchAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACBVFU9CBl6lob6gVGOCa-JoTrkt-SwQACequq5XylVCB6MArQABAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINU0p3jGYSP_Xrenk08NXmwWgX9SYxTPLko5JDphZmP6BWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Oi1TeG16MFpLT2tqcW5pYzM4UDByQUVMa1NMOVdjRGlDVDFNXzdUR0VrTjQCamVkMjU1MTktdjEBWEBBqlbyO8Xvb27dqBRqMP_vPz3i28FLWJYF3hRjDXaNkh2dpUrDv2GKEk9MrMmuLX9F-TWb53hUEC-kRVLxMgcHAoGkAFggxvsMhQsa81ih4H74bbSV8f283nuV3_n_ZzkvzWIMzW8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINQEvERWWu27iZFQ5bCzsyuUQb8Mt4hMMxMNqNvCfdLP", "decision": "authorized", "code": "", "provider_entries": 1 @@ -107,9 +107,9 @@ "manager-b", "manager-c" ], - "arguments_json": "{\"operation_id\":\"three-of-three-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBUXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InRocmVlLW9mLXRocmVlLW1hbmFnZXJzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0DogBqdG9vbHMvY2FsbAF4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEE9gWA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINYDZk-jDz239BStfTUHWkYfKZlsMEwoUwdyjOrOGX4MBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQKMJC9WBB0Kp8cg5XxaxgAJUcn9jXc6FUkKJ-EvFJz9siNYMM_m_tY1DImOH5c-uYLFHvjv1F352T8-cNG2aHggDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggZ4yociZf2I4ZqHNu9LoqehLbqyHNf-VIV5buiZS5KWcBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFReyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidGhyZWUtb2YtdGhyZWUtbWFuYWdlcnMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQqDowCtAAEBeDZrZXk6c2hhMjU2OlFuNGRlZEY1VFY0aDhVU2lUVmVBeHBZNTRxNXdWSEVBbklIV2F5RG04VGMCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg1gNmT6MPPbf0FK19NQdaRh8pmWwwTChTB3KM6s4ZfgwFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6UW40ZGVkRjVUVjRoOFVTaVRWZUF4cFk1NHE1d1ZIRUFuSUhXYXlEbThUYwJqZWQyNTUxOS12MQFYQL1UskygPk2A1tT1GTH0akYUvlvMS19_c59WHPoWU1IRWodmY4YttdQjKtkIkrA1uJyMStuEsBYNy_HmfYjkigoCgaQAWCCr94EVFdXPC3Ts3jn-SSjkw7HuzqV2T0YN26ziL5y3IQFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgVRVPQgZepaG-oFRjgmviaE65LfksEAAnqrquV8pVQgejAK0AAQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCDWA2ZPow89t_QUrX01B1pGHymZbDBMKFMHcozqzhl-DAVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AmplZDI1NTE5LXYxAVhA00ofdX1I674sS5Y1TCTEOIeLFFfVviegRuU_Ey9a7_tyhmzXPNI5s02uHoMB-4BOLfCMQv_6miLqhwH6jxNfAQKBpABYIBSBPQS527Dja0ON50GQgwYoiggBsJJ0iOeRqdCjw0emAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACC8fLy1Y2N1-h2CQ01GZyTZI3f1O5gGld1J0m0M4SIFpaMArQABAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINYDZk-jDz239BStfTUHWkYfKZlsMEwoUwdyjOrOGX4MBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Oi1TeG16MFpLT2tqcW5pYzM4UDByQUVMa1NMOVdjRGlDVDFNXzdUR0VrTjQCamVkMjU1MTktdjEBWEBBANL15eDJHsl4UmzxTz2Cg47f3qvLCNKKFCskFfQwm7gp3kGAmJi0VviLASNlEaOp8nyNG0xvsD1ctGq3yjYGAoGkAFggxvsMhQsa81ih4H74bbSV8f283nuV3_n_ZzkvzWIMzW8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINQEvERWWu27iZFQ5bCzsyuUQb8Mt4hMMxMNqNvCfdLP", + "arguments_json": "{\"operation_id\":\"three-of-three-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBUXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InRocmVlLW9mLXRocmVlLW1hbmFnZXJzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0DogBqdG9vbHMvY2FsbAF4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEE9gWA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIBGTE6bSH5qg1E0VJ_sVqiKFcydGBs6GqXmrFfbCcna3BWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQOWSCPnYqmsV9G_5YMiGypVBpMv2n7xdfSkzlXDCRzzX1-1CMCn1FnwnSZrbMunN7GCBKMUrBBJwkWOgmeISAQEDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggBTr01ihYH66PMoWklLCknHzYEg83NLWUR9qgC09Vj5wBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFReyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidGhyZWUtb2YtdGhyZWUtbWFuYWdlcnMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQqDowCtAAEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggEZMTptIfmqDUTRUn-xWqIoVzJ0YGzoapeasV9sJydrcFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJqZWQyNTUxOS12MQFYQNj88yWnMVxZLbI4Jx2FFNUESLG5d00u1fezlbkqEeIIEl3awBgrMs4g2RvgttJqz1pz2qKDs6fXG7gH9M20Xw8CgaQAWCAUgT0Euduw42tDjedBkIMGKIoIAbCSdIjnkanQo8NHpgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgvHy8tWNjdfodgkNNRmck2SN39TuYBpXdSdJtDOEiBaWjAK0AAQF4NmtleTpzaGEyNTY6UW40ZGVkRjVUVjRoOFVTaVRWZUF4cFk1NHE1d1ZIRUFuSUhXYXlEbThUYwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCARkxOm0h-aoNRNFSf7FaoihXMnRgbOhql5qxX2wnJ2twVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAmplZDI1NTE5LXYxAVhAzdJ_UAmtGSPsqBnHKogNlFjAPcj4wjVv0R-5c7v922cLvnEydZN_bwOvwy0UNrc9xKD3vK4gtIhnosnCqDzgDgKBpABYIKv3gRUV1c8LdOzeOf5JKOTDse7OpXZPRg3brOIvnLchAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACBVFU9CBl6lob6gVGOCa-JoTrkt-SwQACequq5XylVCB6MArQABAXg2a2V5OnNoYTI1NjotU3htejBaS09ranFuaWMzOFAwckFFTGtTTDlXY0RpQ1QxTV83VEdFa040AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIBGTE6bSH5qg1E0VJ_sVqiKFcydGBs6GqXmrFfbCcna3BWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Oi1TeG16MFpLT2tqcW5pYzM4UDByQUVMa1NMOVdjRGlDVDFNXzdUR0VrTjQCamVkMjU1MTktdjEBWEC4qI0m1ErAmpVVkFhDX4LPNrMH6EIuY87nqb18Lf2NIsBhfO-4HthRSvDiOnqHnMHSMKbI4h-a_6fQO_VhOOsPAoGkAFggxvsMhQsa81ih4H74bbSV8f283nuV3_n_ZzkvzWIMzW8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINQEvERWWu27iZFQ5bCzsyuUQb8Mt4hMMxMNqNvCfdLP", "decision": "authorized", "code": "", "provider_entries": 1 @@ -121,9 +121,9 @@ "approvers": [ "manager-a" ], - "arguments_json": "{\"operation_id\":\"one-of-three-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBT3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im9uZS1vZi10aHJlZS1tYW5hZ2VycyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINY7iEHFH0L2B6ZAyXhVJeKaftCRmdRiPK4lfnOehz8GBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBSlp80QXVQP_vVoBPgrfMeTvfcRdnYZ9FtCP4uQHRWu4Ijb06eGPHx62JxBZa2P_f8lriGFZ13f9ZLfgYDpPA8DogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggPo2h1q08J4pwnGD0nP5EHqxQG0v06xextOe8SXRZtMsBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFPeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib25lLW9mLXRocmVlLW1hbmFnZXJzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgaMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINY7iEHFH0L2B6ZAyXhVJeKaftCRmdRiPK4lfnOehz8GBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEDXZuQ98wa-ZgBeogjHGVHTXKp9gzADIaa1Qkzfer9hvDmtKY9JVULLRd9KXIUl0KhWppLd4lkwsVp2kGgt-aYCAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", + "arguments_json": "{\"operation_id\":\"one-of-three-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBT3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im9uZS1vZi10aHJlZS1tYW5hZ2VycyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINr7k3VntnuS4thCprwCJ0DbkBxRiFJ-cyrjnl3XNZLNBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBBOpyymP7XWVwM8orNyeNqHR4JWH53vgi1k9r_RPO4qNmth4zHIutuFEwkpxG5fofvOwyUpMlQRFQApsAgHGwMDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVgg6nEegOncc8o0s2dqeUygXSTCVHLfn8FAGeU4tvMV_q4BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFPeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib25lLW9mLXRocmVlLW1hbmFnZXJzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgaMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYINr7k3VntnuS4thCprwCJ0DbkBxRiFJ-cyrjnl3XNZLNBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEDd1fYIQlvkl3ddQcaUjwi94FZozEvHPmrJTi6npegae0PHwImJnZoIrjx3Gi6y_JC18vUjTVcMpOig7J5JnecNAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", "decision": "denied", "code": "approval-threshold-not-met", "provider_entries": 0 @@ -133,9 +133,9 @@ "authoring": "hand", "required": 2, "approvers": [], - "arguments_json": "{\"operation_id\":\"no-approvals\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBRnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im5vLWFwcHJvdmFscyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIMEQek3NKYLG8q8MWCJOZlHlitbrhpX9DKYhwI4lFsjyBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQJwnMtRyL__hGrEvTNSBa3MDXhswzyMmh7emka5IJiijIxFTTPrThxxXqPGNdhFylkzXisnLaTgxp4SkUePp0wYDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggmw1AuiC303910Yui9UUFeGPLsNCjT6OuHomU8VMwecsBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFGeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibm8tYXBwcm92YWxzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgA", + "arguments_json": "{\"operation_id\":\"no-approvals\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBRnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im5vLWFwcHJvdmFscyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIG28H_x6fTbyLDaGBY-L7gncb3aTJZvfWFenRkr86Tz7BWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQNusr8Dh_b_F3bkPOJ5glZ8BoJYZRogO6eVqboZhXnfP7a7kIRafwVppZXC7vuhkpthm9sNY7BrthVhBOtlIIQsDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVgg7_7V9XWIWbnCin0DoXsg15B2AL-vD5Bz3x1znfxzZA8BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFGeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoibm8tYXBwcm92YWxzIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgA", "decision": "denied", "code": "approval-threshold-not-met", "provider_entries": 0 @@ -148,9 +148,9 @@ "manager-a", "manager-a" ], - "arguments_json": "{\"operation_id\":\"duplicate-approval\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBTHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImR1cGxpY2F0ZS1hcHByb3ZhbCIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIM5UjpzEHcH-BEBQa7X_0_c0HsPm9ehDq9UR1dO1lepPBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQF6ugtXNolB89i8Rh2x5aLyT9dQAF8wLJdTsHOyKABV8-0bwtEH6pKX4oZ_kOjHREmFZprlcykULpqdVhnPv6g4DogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggYv-YnmPHFpB1lJupTSApMLPUw3cyGA5xm2TxZtbX160BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFMeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiZHVwbGljYXRlLWFwcHJvdmFsIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgqMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIM5UjpzEHcH-BEBQa7X_0_c0HsPm9ehDq9UR1dO1lepPBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEAWvhDMgCkWIercd5FWHSY94HAIIs_QhgS8pFhCTK3nBOIQPl7XNn7DcNjQTH2skZqiVBEAEnGIHDJGesH5-OMOAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWlowCtAAEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggzlSOnMQdwf4EQFBrtf_T9zQew-b16EOr1RHV07WV6k8FanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJqZWQyNTUxOS12MQFYQBa-EMyAKRYh6tx3kVYdJj3gcAgiz9CGBLykWEJMrecE4hA-Xtc2fsNw2NBMfayRmqJUEQAScYgcMkZ6wfn44w4CgaQAWCAUgT0Euduw42tDjedBkIMGKIoIAbCSdIjnkanQo8NHpgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgvHy8tWNjdfodgkNNRmck2SN39TuYBpXdSdJtDOEiBaU", + "arguments_json": "{\"operation_id\":\"duplicate-approval\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBTHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImR1cGxpY2F0ZS1hcHByb3ZhbCIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIPT17aDHQ0Y3Pl3FfF_U4XGbLdF7CIzSktWb6iIuSYXWBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQN4Pf3jSmwGsVJENWhK_xMejmZb21sAva86TWLYPAOePk3lWjWkxn8kGMNg_fkG53txGosVKpKryapg6OfxUOAgDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggy60ABUpmn0_HMr6F9DD9OuMHONlmnQ2-kPdMdHHgQr8BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFMeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiZHVwbGljYXRlLWFwcHJvdmFsIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgqMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIPT17aDHQ0Y3Pl3FfF_U4XGbLdF7CIzSktWb6iIuSYXWBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEA_tsnA3yTU1D2_D6Z6VqRB3LYZ7i_cN8S9WsbDGNaK-Y5qyiA4zhtarp34fzYXVWnraNkCmgtcXM7rOGxUGSsPAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWlowCtAAEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg9PXtoMdDRjc-XcV8X9ThcZst0XsIjNKS1ZvqIi5JhdYFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJqZWQyNTUxOS12MQFYQD-2ycDfJNTUPb8PpnpWpEHcthnuL9w3xL1axsMY1or5jmrKIDjOG1qunfh_NhdVaeto2QKaC1xczus4bFQZKw8CgaQAWCAUgT0Euduw42tDjedBkIMGKIoIAbCSdIjnkanQo8NHpgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgvHy8tWNjdfodgkNNRmck2SN39TuYBpXdSdJtDOEiBaU", "decision": "denied", "code": "approval-threshold-not-met", "provider_entries": 0 @@ -163,9 +163,9 @@ "manager-a", "outsider" ], - "arguments_json": "{\"operation_id\":\"outsider-does-not-count\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBUXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im91dHNpZGVyLWRvZXMtbm90LWNvdW50Iiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0DogBqdG9vbHMvY2FsbAF4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEE9gWA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDyeNWQANLmXSMiXQZLFLK-NDaNe2T2L0WEFlgziRzvaBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQPDsHE1UPsNTd0lWv9tH4NW2-iWcby-ARaF6i24RYdFARgj0WcY1j4HWfjyIxdLTq4W_6jeQmqNGbTQI3Wvm3QcDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggBlNSDwHY5YRCkHUb8fdcTE6PAiB4bV6i4IiNY_jkVbMBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFReyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib3V0c2lkZXItZG9lcy1ub3QtY291bnQiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQqCowCtAAEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggPJ41ZAA0uZdIyJdBksUsr40No17ZPYvRYQWWDOJHO9oFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJqZWQyNTUxOS12MQFYQF9NtHTkFH3H1YPX5BJJSHeVg0dDAoN3RBsHG8xoNrsWceIO2z5snHY1tOmI8MyN8jAMWPMqi_GMa1_BeP0fgAwCgaQAWCAUgT0Euduw42tDjedBkIMGKIoIAbCSdIjnkanQo8NHpgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgvHy8tWNjdfodgkNNRmck2SN39TuYBpXdSdJtDOEiBaWjAK0AAQF4NmtleTpzaGEyNTY6MldDMGtMLWtJcTNMNTRrNXJDQnc2MmhrRTRobmpaSlBJcERIQ01Ka3U3SQJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCA8njVkADS5l0jIl0GSxSyvjQ2jXtk9i9FhBZYM4kc72gVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjoyV0Mwa0wta0lxM0w1NGs1ckNCdzYyaGtFNGhualpKUElwREhDTUprdTdJAmplZDI1NTE5LXYxAVhAjR7Slb9nhLc2nFw_BChjpTnSK-1igJVJRmSiO87LjHPW86iCI0ZVcIyBUdIJ2I_4znMG-RfGd_m5_DfqGPGDAwKBpABYIDNtHIXJ67qcb7Aie3EAX8fBMCjKhldczn6JYOb_NX72AWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDtMjSydtTO2lfVm60U-69adzwPMYyZneOmDVPFpbNMBQ", + "arguments_json": "{\"operation_id\":\"outsider-does-not-count\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBUXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im91dHNpZGVyLWRvZXMtbm90LWNvdW50Iiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0DogBqdG9vbHMvY2FsbAF4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEE9gWA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDCe_bX1-tEwr1AL3zFyPXlhhSunGsmFKBUVF50WQljkBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBlZ_i_cqIU9jXK7bpV7ley286EvsRHsvZ9oxwgjKj3ru0IWRgCdFBsF7nPXe4ScNbcR-UBGFn61ey4g7Qyw9w8DogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVgg_eDu7QCRJZjUnHb5ZXXQ70EQ5-bRsEmJqTwQO2UYDFgBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFReyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib3V0c2lkZXItZG9lcy1ub3QtY291bnQiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQqCowCtAAEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggMJ79tfX60TCvUAvfMXI9eWGFK6cayYUoFRUXnRZCWOQFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJqZWQyNTUxOS12MQFYQOw6AfCP0kMDQeL1-p0zRY8hhzR4vlsiOU2Eh3I1pnx0XO4CDJbl_-0KwfOo7BGhIi4xAuekFWjIRfOSWwgfpgwCgaQAWCAUgT0Euduw42tDjedBkIMGKIoIAbCSdIjnkanQo8NHpgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgvHy8tWNjdfodgkNNRmck2SN39TuYBpXdSdJtDOEiBaWjAK0AAQF4NmtleTpzaGEyNTY6MldDMGtMLWtJcTNMNTRrNXJDQnc2MmhrRTRobmpaSlBJcERIQ01Ka3U3SQJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAwnv219frRMK9QC98xcj15YYUrpxrJhSgVFRedFkJY5AVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjoyV0Mwa0wta0lxM0w1NGs1ckNCdzYyaGtFNGhualpKUElwREhDTUprdTdJAmplZDI1NTE5LXYxAVhAHDbcA1Fj5UuzSpf78pOrKp5cgHpJPvINnfEj8qnFaOfQPuzEfQ1sUaG0wnGILqQgnJmb_exaGFY-neNLKZiNCAKBpABYIDNtHIXJ67qcb7Aie3EAX8fBMCjKhldczn6JYOb_NX72AWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDtMjSydtTO2lfVm60U-69adzwPMYyZneOmDVPFpbNMBQ", "decision": "denied", "code": "approval-threshold-not-met", "provider_entries": 0 @@ -179,9 +179,9 @@ "manager-b", "outsider" ], - "arguments_json": "{\"operation_id\":\"outsider-beside-two-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im91dHNpZGVyLWJlc2lkZS10d28tbWFuYWdlcnMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6ImJjYzg3MDIzYzE0YWZlOTNjMDc2MmMyMGI1ODc5NmNkZmFlYzkyZDYwNGMwYzJjZjZjOWY1Y2NlYWUzMDY2ZDEiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOzzqabRcbV1jP6FBRUl-jcwqRvKQbkFfgwkWN-wlA4OBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQLLSN5QPt2gJfNMDKv5XioTRIQ1HwePqGOQNDMcBr75jyvRGze4hmSZzs3xP1pFJt3qQIGxPJWbm10kxw4V3cgkDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggFAauQIQGO243Ges1cImDizJzfy2gmnoO68_BmcEAT1kBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFWeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib3V0c2lkZXItYmVzaWRlLXR3by1tYW5hZ2VycyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoOjAK0AAQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCDs86mm0XG1dYz-hQUVJfo3MKkbykG5BX4MJFjfsJQODgVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AmplZDI1NTE5LXYxAVhAH_IZnVb8z698-i9sfkBZZ36CN1KtMSoRuWm5H6uLQkleaUO5ICj0-YALZFu1d2UaQT9ZUcGCdfQa0juTQMw6DwKBpABYIBSBPQS527Dja0ON50GQgwYoiggBsJJ0iOeRqdCjw0emAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACC8fLy1Y2N1-h2CQ01GZyTZI3f1O5gGld1J0m0M4SIFpaMArQABAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOzzqabRcbV1jP6FBRUl-jcwqRvKQbkFfgwkWN-wlA4OBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlFuNGRlZEY1VFY0aDhVU2lUVmVBeHBZNTRxNXdWSEVBbklIV2F5RG04VGMCamVkMjU1MTktdjEBWEBtTQEeujFVZr-uABbDNUIlCnVLoYE1Nhgo4_fAYpDpQzBCQed1yLmrRVuKNKwZuAzYutB_SuliRfgNWU05jEoPAoGkAFggq_eBFRXVzwt07N45_kko5MOx7s6ldk9GDdus4i-ctyEBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIFUVT0IGXqWhvqBUY4Jr4mhOuS35LBAAJ6q6rlfKVUIHowCtAAEBeDZrZXk6c2hhMjU2OjJXQzBrTC1rSXEzTDU0azVyQ0J3NjJoa0U0aG5qWkpQSXBESENNSmt1N0kCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg7POpptFxtXWM_oUFFSX6NzCpG8pBuQV-DCRY37CUDg4FanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MldDMGtMLWtJcTNMNTRrNXJDQnc2MmhrRTRobmpaSlBJcERIQ01Ka3U3SQJqZWQyNTUxOS12MQFYQIrWXS8iA2TaFxXXsuWC7t464p_CY3ZnS58odf_5tCKuwA-OmcaGaH_vXeo49d3onTeXlRsudsddFOrCECDQ9Q8CgaQAWCAzbRyFyeu6nG-wIntxAF_HwTAoyoZXXM5-iWDm_zV-9gFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg7TI0snbUztpX1ZutFPuvWnc8DzGMmZ3jpg1TxaWzTAU", + "arguments_json": "{\"operation_id\":\"outsider-beside-two-managers\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBVnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6Im91dHNpZGVyLWJlc2lkZS10d28tbWFuYWdlcnMiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJhaXJ0YWJsZS1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjY0ZmY1MDA0Yjk3NThlMmZiMzc0ZTlkNmI0NDNlZjFiMzVhYTAwYzQwMGRiZTEzNThiOTBlZjg5YzVjOWVkYTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoiQXBwcm92ZWQifSwibmFtZSI6InNldF9kZW1vX3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJhaXJ0YWJsZS1nYXRld2F5LWRlbW8ifQOiAGp0b29scy9jYWxsAXg0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQT2BYA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIEn_vRdZK12XtqA_SD9OkyXPbVExnmplFkn5VbrZNjoXBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQK8GEXK2iLuc1KJwKe5V5SyG2tdHcJP6oC3X9Bq1EA-vB8ujFZf8KoJ_xXlEFATxPWuc8hjQpAnEk2mrwtTN-AUDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggE-d-4IPQnrIpEUDpTIIuUyP1NhCZyv5QenLU-mWmPFMBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFWeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoib3V0c2lkZXItYmVzaWRlLXR3by1tYW5hZ2VycyIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9CoOjAK0AAQF4NmtleTpzaGEyNTY6MGF5Z21uNWxPNUNJX0lfTVNrckJhS2pHSXA4SVFaZkYyU3F4Y2tmaWpVdwJYICK8D4i-GwfzWu_l0-cC79VAjEokgo3gmYCGn_tbGskuA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBJ_70XWStdl7agP0g_TpMlz21RMZ5qZRZJ-VW62TY6FwVqdG9vbHMvY2FsbAZ4NG1jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtby90b29scy9zZXRfZGVtb19zdGF0dXNfdjEH9gj2CXgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vClggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVELGmqxO3YMGmqyjPYBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3AmplZDI1NTE5LXYxAVhAXk4uONFTqZe9UaReq1LdDhdhHChQoK0BmIHGQgdjo-TsX2PvQWdwYvFoZXOHFHp6LFFfho5AZMJ0phb5jFj4AQKBpABYIBSBPQS527Dja0ON50GQgwYoiggBsJJ0iOeRqdCjw0emAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACC8fLy1Y2N1-h2CQ01GZyTZI3f1O5gGld1J0m0M4SIFpaMArQABAXg2a2V5OnNoYTI1NjpRbjRkZWRGNVRWNGg4VVNpVFZlQXhwWTU0cTV3VkhFQW5JSFdheURtOFRjAlggIrwPiL4bB_Na7-XT5wLv1UCMSiSCjeCZgIaf-1sayS4DeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIEn_vRdZK12XtqA_SD9OkyXPbVExnmplFkn5VbrZNjoXBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlFuNGRlZEY1VFY0aDhVU2lUVmVBeHBZNTRxNXdWSEVBbklIV2F5RG04VGMCamVkMjU1MTktdjEBWECVrV-5xsdEVJyxgML78Gcy_mGKYgK3OUz5oxY-0vfj2w7Bdrgr9CkfZvg4-6EXvYTeeXqAXNElL6r3lHEFSXYLAoGkAFggq_eBFRXVzwt07N45_kko5MOx7s6ldk9GDdus4i-ctyEBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIFUVT0IGXqWhvqBUY4Jr4mhOuS35LBAAJ6q6rlfKVUIHowCtAAEBeDZrZXk6c2hhMjU2OjJXQzBrTC1rSXEzTDU0azVyQ0J3NjJoa0U0aG5qWkpQSXBESENNSmt1N0kCWCAivA-IvhsH81rv5dPnAu_VQIxKJIKN4JmAhp_7WxrJLgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggSf-9F1krXZe2oD9IP06TJc9tUTGeamUWSflVutk2OhcFanRvb2xzL2NhbGwGeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxB_YI9gl4G21jcDovL2FpcnRhYmxlLWdhdGV3YXktZGVtbwpYIFFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRCxpqsTt2DBpqsoz2AaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6MldDMGtMLWtJcTNMNTRrNXJDQnc2MmhrRTRobmpaSlBJcERIQ01Ka3U3SQJqZWQyNTUxOS12MQFYQGBpjbiMFaer7FPhMNahfQW-MoEX8kIxlZy3Ha5dDGQiJIfEqX0tGxPWwsmZ5Y6uTwbGq6AXB06s91_7aOZM6wQCgaQAWCAzbRyFyeu6nG-wIntxAF_HwTAoyoZXXM5-iWDm_zV-9gFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg7TI0snbUztpX1ZutFPuvWnc8DzGMmZ3jpg1TxaWzTAU", "decision": "authorized", "code": "", "provider_entries": 1 @@ -193,9 +193,9 @@ "approvers": [ "manager-a" ], - "arguments_json": "{\"operation_id\":\"approvals-for-a-lowered-threshold\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"bcc87023c14afe93c0762c20b58796cdfaec92d604c0c2cf6c9f5cceae3066d1\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBW3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImFwcHJvdmFscy1mb3ItYS1sb3dlcmVkLXRocmVzaG9sZCIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiYmNjODcwMjNjMTRhZmU5M2MwNzYyYzIwYjU4Nzk2Y2RmYWVjOTJkNjA0YzBjMmNmNmM5ZjVjY2VhZTMwNjZkMSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", - "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDwq485xd957IS3MjCPjQY7xjgHtrVGZ7v3vcXy_Ev3hBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQCZiJydcieCJ32lah2gcjBNHV4lVe1hf6ITkwfSNV6aCAEJiEj84B5YYF5kMw-54eWfTLYRhqpF0HrsCml2zkAwDogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVgg66twNG8bxSeD7dEce4JHM4kUkrOqe5E74Q3K1r8OFYUBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFbeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYXBwcm92YWxzLWZvci1hLWxvd2VyZWQtdGhyZXNob2xkIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiJiY2M4NzAyM2MxNGFmZTkzYzA3NjJjMjBiNTg3OTZjZGZhZWM5MmQ2MDRjMGMyY2Y2YzlmNWNjZWFlMzA2NmQxIiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgaMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3Algg6BGtMS-DCaN6-nApn5iS7hn777uaG1dTDtW3Nl93t3oDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIDwq485xd957IS3MjCPjQY7xjgHtrVGZ7v3vcXy_Ev3hBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWECFO5lRyMxdMqAnhXXa1w--e7JeetxN7E5E3oiCOXNHrnOEaQnaz60-X_lXTAiS3Inka8Wyd5VLUyikemPEesIFAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", + "arguments_json": "{\"operation_id\":\"approvals-for-a-lowered-threshold\",\"operator_namespace\":\"airtable-demo\",\"recipe_digest\":\"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9\",\"record_id\":\"recTEST0000000001\",\"replacement\":\"Approved\"}", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBW3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImFwcHJvdmFscy1mb3ItYS1sb3dlcmVkLXRocmVzaG9sZCIsIm9wZXJhdG9yX25hbWVzcGFjZSI6ImFpcnRhYmxlLWRlbW8iLCJyZWNpcGVfZGlnZXN0IjoiNjRmZjUwMDRiOTc1OGUyZmIzNzRlOWQ2YjQ0M2VmMWIzNWFhMDBjNDAwZGJlMTM1OGI5MGVmODljNWM5ZWRhOSIsInJlY29yZF9pZCI6InJlY1RFU1QwMDAwMDAwMDAxIiwicmVwbGFjZW1lbnQiOiJBcHByb3ZlZCJ9LCJuYW1lIjoic2V0X2RlbW9fc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImFpcnRhYmxlLWdhdGV3YXktZGVtbyJ9A6IAanRvb2xzL2NhbGwBeDRtY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8vdG9vbHMvc2V0X2RlbW9fc3RhdHVzX3YxBPYFgA", + "proof_b64": "qwCiAAEBAAGAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYII3qrNi6H8g0dDkfmDj0CZEy5XOnJfmgjiZDpjnDrSPMBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CHgbbWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vCVggUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVEKGmqxO3YLGmqyjPYMeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMN9g5YIN_SbFWHpamBW8lhaFp7JxJWyxZRg86ilY2Qf-YvcoKdD2dub25lLXYxEFgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8RgBKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQPVP158k3tQgDEUd9PbAUkhtCX4SguzldHDTmR886hX4YHbgr5dq7xrkNGPEvpzxNgUHRWy6kryPmlGY2VwNRg8DogAAAVgg-TT9U5IN9mkwlyJ5IhqWWvjWR_UnJqF2rk0zSWdSUR8EgaQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzcFgaIAogABAVggagwBIMUxaoejB5FF3-jDRei7u0fyq0Ofzp23xuOeyesBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UGgAeACIAJWQFbeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYXBwcm92YWxzLWZvci1hLWxvd2VyZWQtdGhyZXNob2xkIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoiYWlydGFibGUtZGVtbyIsInJlY2lwZV9kaWdlc3QiOiI2NGZmNTAwNGI5NzU4ZTJmYjM3NGU5ZDZiNDQzZWYxYjM1YWEwMGM0MDBkYmUxMzU4YjkwZWY4OWM1YzllZGE5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6IkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfZGVtb19zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiYWlydGFibGUtZ2F0ZXdheS1kZW1vIn0KgaMArQABAXg2a2V5OnNoYTI1NjowYXlnbW41bE81Q0lfSV9NU2tyQmFLakdJcDhJUVpmRjJTcXhja2ZpalV3Algg6BGtMS-DCaN6-nApn5iS7hn777uaG1dTDtW3Nl93t3oDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYII3qrNi6H8g0dDkfmDj0CZEy5XOnJfmgjiZDpjnDrSPMBWp0b29scy9jYWxsBng0bWNwOi8vYWlydGFibGUtZ2F0ZXdheS1kZW1vL3Rvb2xzL3NldF9kZW1vX3N0YXR1c192MQf2CPYJeBttY3A6Ly9haXJ0YWJsZS1nYXRld2F5LWRlbW8KWCBRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUQsaarE7dgwaarKM9gGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjBheWdtbjVsTzVDSV9JX01Ta3JCYUtqR0lwOElRWmZGMlNxeGNrZmlqVXcCamVkMjU1MTktdjEBWEBsfBZ0o4lEzGsRARBnNaz4ed9gUyic_mkmIAVQLUH-c5OPfhAx8WdAHxho2ywj3aXaF1dBUNzS11y1aX2dUBIGAoGkAFggFIE9BLnbsONrQ43nQZCDBiiKCAGwknSI55Gp0KPDR6YBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAILx8vLVjY3X6HYJDTUZnJNkjd_U7mAaV3UnSbQzhIgWl", "decision": "denied", "code": "approval-threshold-not-met", "provider_entries": 0 diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index eb0ee906e..60e7d6370 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -755,8 +755,8 @@ "code": null, "leases": 1, "credential_reads": 0, - "action_reads": 1, - "provider_entries": 0 + "action_reads": 0, + "provider_entries": 1 } ], "record_cases": [ diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 51422d8c4..0bcce173c 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -613,14 +613,6 @@ "epic": 5, "case": null }, - { - "code": "gateway.observer.credential-guard", - "owner": "observer", - "stage": "observe", - "status": "new", - "epic": 3, - "case": null - }, { "code": "gateway.policy.above-sum-limit", "owner": "engine", @@ -1019,10 +1011,7 @@ "stage": "recorded", "status": "new", "epic": 3, - "case": { - "fixture": "attempt-scenarios-v3.json", - "id": "transport-not-entered" - } + "case": null }, { "code": "gateway.trust.key-aliased", diff --git a/bindings/python/api/public-api.txt b/bindings/python/api/public-api.txt index bff681e97..eaed1cfed 100644 --- a/bindings/python/api/public-api.txt +++ b/bindings/python/api/public-api.txt @@ -95,6 +95,7 @@ GatewayPreEntryObservations GatewayPreEntryResult GatewayProtocolError GatewayProviderEvidence +GatewayReserved GatewayResponseRecorded GatewayResult GatewaySignedObservation diff --git a/compliance.toml b/compliance.toml index 0e448ba17..b9075cd3f 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1231,7 +1231,7 @@ proof-author-or-assembler = [ "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#fresh_evidence_is_closed_to_the_reviewed_subject_and_exact_candidate_digest", "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#offline_differential_requires_native_review_without_custody_or_provider_entry", "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#a_dynamic_doctor_witness_must_match_the_actual_production_tuple", - "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#replay_can_complete_an_unresolved_read_back_but_never_write_or_reacquire_after_observation", + "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#replay_returns_history_without_a_lease_entry_or_new_confirmation", "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#observed_faults_and_changed_candidates_produce_no_passing_case", "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#differential_compares_the_actual_oracle_and_gateway_commitments", "product/qualification/auths-recipe-qualification-issuance/tests/execution.rs#recovery_requires_read_back_and_without_the_capability_stays_unknown", @@ -1441,13 +1441,39 @@ configuration_inputs = ["gateway-app-socket", "trusted-authority-configuration"] security_state = ["portable-linked-receipts"] [packages.auths-proof-python.claims] -content-control-envelopes = [ +# Evidence coverage: content-control-envelopes. +language-binding = [ "bindings/python/tests/test_gateway_client.py#test_content_controls_preserve_native_envelopes", "bindings/python/tests/test_gateway_client.py#test_content_controls_refuse_unbounded_or_invalid_input", + "bindings/python/tests/test_remote_approval.py#test_python_issues_the_native_requests", + "bindings/python/tests/test_remote_approval.py#test_python_opens_every_request_vector", + "bindings/python/tests/test_remote_approval.py#test_python_collects_every_vector", + "bindings/python/tests/test_approval_quorum.py#test_python_authors_the_exact_gateway_quorum_bytes", + "bindings/python/tests/test_approval_quorum.py#test_python_verifier_decides_every_gateway_vector_identically", + "bindings/python/tests/test_openapi_derivation.py#test_native_route_reproduces_the_corpus", + "bindings/python/tests/test_openapi_derivation.py#test_derive_generate_check_and_hand_edit", + "bindings/python/tests/test_public_api_v2.py#test_exact_public_inventory", + "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_rejects_contradictory_projection", + "bindings/python/tests/test_gateway_outcome_v2.py#test_python_client_accepts_every_signed_outcome", + "bindings/python/tests/test_gateway_outcome_v2.py#test_python_verifier_reaches_the_gateway_verdict", + "bindings/python/tests/test_self_hosted_operator.py#test_trusted_context_is_the_native_compile_bound_to_one_request", + "bindings/python/tests/test_self_hosted_operator.py#test_root_grant_equals_the_native_path_and_carries_the_signer_evidence", + "bindings/python/tests/test_enforcement_init.py#test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest", + "bindings/python/tests/test_enforcement_init.py#test_audit_passes_the_gateway_verdict_through_and_adds_no_option", +] +core-wire-consumer = [ + "bindings/python/tests/test_native_boundary_contract.py#test_every_registry_code_classifies_through_the_native_layer", + "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_projection_is_self_contained", + "bindings/python/tests/test_native_authoring.py#test_child_planning_matches_the_shared_rust_typescript_fixture", + "bindings/python/tests/test_workflow.py#test_attach_and_delegate_use_native_authority_without_protocol_bytes", +] +runtime-enforcement-boundary = [ + "bindings/python/tests/test_public_api_v2.py#test_receipts_reject_direct_construction", + "bindings/python/tests/test_public_api_v2.py#test_product_root_is_small_and_removed_names_are_absent", + "bindings/python/tests/test_public_api_v2.py#test_local_agent_client_modules_are_not_importable", + "bindings/python/tests/test_native_boundary_contract.py#test_a_python_caller_cannot_mint_a_canonical_action_for_its_own_profile", + "bindings/python/tests/test_native_boundary_contract.py#test_no_native_symbol_is_exported_without_being_declared", ] -core-wire-consumer = ["bindings/python/tests/test_native_boundary_contract.py#test_every_registry_code_classifies_through_the_native_layer", "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_projection_is_self_contained", "bindings/python/tests/test_native_authoring.py#test_child_planning_matches_the_shared_rust_typescript_fixture", "bindings/python/tests/test_workflow.py#test_attach_and_delegate_use_native_authority_without_protocol_bytes"] -language-binding = ["bindings/python/tests/test_remote_approval.py#test_python_issues_the_native_requests", "bindings/python/tests/test_remote_approval.py#test_python_opens_every_request_vector", "bindings/python/tests/test_remote_approval.py#test_python_collects_every_vector", "bindings/python/tests/test_approval_quorum.py#test_python_authors_the_exact_gateway_quorum_bytes", "bindings/python/tests/test_approval_quorum.py#test_python_verifier_decides_every_gateway_vector_identically", "bindings/python/tests/test_openapi_derivation.py#test_native_route_reproduces_the_corpus", "bindings/python/tests/test_openapi_derivation.py#test_derive_generate_check_and_hand_edit", "bindings/python/tests/test_public_api_v2.py#test_exact_public_inventory", "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_rejects_contradictory_projection", "bindings/python/tests/test_gateway_outcome_v2.py#test_python_client_accepts_every_signed_outcome", "bindings/python/tests/test_gateway_outcome_v2.py#test_python_verifier_reaches_the_gateway_verdict", "bindings/python/tests/test_self_hosted_operator.py#test_trusted_context_is_the_native_compile_bound_to_one_request", "bindings/python/tests/test_self_hosted_operator.py#test_root_grant_equals_the_native_path_and_carries_the_signer_evidence", "bindings/python/tests/test_enforcement_init.py#test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest", "bindings/python/tests/test_enforcement_init.py#test_audit_passes_the_gateway_verdict_through_and_adds_no_option"] -runtime-enforcement-boundary = ["bindings/python/tests/test_public_api_v2.py#test_receipts_reject_direct_construction", "bindings/python/tests/test_public_api_v2.py#test_product_root_is_small_and_removed_names_are_absent", "bindings/python/tests/test_public_api_v2.py#test_local_agent_client_modules_are_not_importable", "bindings/python/tests/test_native_boundary_contract.py#test_a_python_caller_cannot_mint_a_canonical_action_for_its_own_profile", "bindings/python/tests/test_native_boundary_contract.py#test_no_native_symbol_is_exported_without_being_declared"] [packages.auths-proof-wasm] kind = "cargo" @@ -1586,7 +1612,8 @@ configuration_inputs = ["connection-alias", "credential-store-kind", "provider-k security_state = ["connection-generation", "credential-generation", "credential-reference", "provider-account-commitment"] [packages.auths-connections.claims] -file-custody-process-serialization = [ +# Evidence coverage: file-custody-process-serialization. +stateful-replay-budget-component = [ "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", ] @@ -1619,111 +1646,29 @@ configuration_inputs = ["installed-effect-policy", "operator-configuration-revis security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] -content-only-installation = [ +# Evidence coverage: content-only-installation. +# Evidence coverage: disclosure-compilation-contract. +# Evidence coverage: content-compilation-contract. +# Evidence coverage: candidate-installation. +# Evidence coverage: candidate-proposal. +# Evidence coverage: candidate-compilation. +# Evidence coverage: recovery-compilation. +# Evidence coverage: effect-review. +# Evidence coverage: effect-configuration. +configuration-compiler = [ "product/runtime/auths-gateway/src/recipe/tests.rs#native_read_only_recipe_fixture_is_current", "product/runtime/auths-gateway/tests/content_journey.rs#native_read_only_process_journey_fixture_is_current", -] -content-process-composition = [ - "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_journey_fixture_is_current", -] -content-application-boundary = [ - "product/runtime/auths-gateway/src/app/content_tests.rs#native_application_content_frame_fixture_is_current", - "product/runtime/auths-gateway/tests/application_content_cli.rs#native_application_content_cli_fixture_is_current", -] -disclosure-local-socket-file-grant = [ - "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", -] -disclosure-journal-admission = [ - "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", -] -disclosure-compilation-contract = [ - "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", -] -protected-content-retention = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", -] -content-journal-transport = [ - "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", -] - -content-compilation-contract = [ "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_compilation_fixture_is_current", -] - -disclosure-acknowledgement-contract = [ - "product/runtime/auths-gateway/src/effect_disclosure_tests.rs#native_disclosure_acknowledgement_fixture_is_current", -] - -candidate-process-journey = [ - "product/runtime/auths-gateway/tests/candidate_journey.rs#approved_candidate_process_journey_fixture_is_current", -] - -candidate-installation = [ "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", -] -candidate-staging = [ - "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", - "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", -] -candidate-proposal = [ - "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", -] -candidate-publication = [ - "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", -] -candidate-acquisition = [ - "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", -] -candidate-compilation = [ - "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", -] -recovery-refinement = [ - "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", -] -recovery-entry = [ - "product/runtime/auths-gateway/src/effect_prerequisite_tests.rs#native_prerequisite_compilation_fixture_is_current", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", -] -recovery-compilation = [ - "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", -] -effect-replay = [ - "product/runtime/auths-gateway/src/app.rs#native_application_recovery_frame_fixture_is_current", - "product/runtime/auths-gateway/tests/application_recovery_cli.rs#native_application_recovery_cli_fixture_is_current", - "product/runtime/auths-gateway/src/scenario_tests.rs#native_replay_projection_fixture_is_current", - "bindings/python/tests/test_gateway_client.py#test_native_replay_projection_corpus", - "bindings/typescript/test/unit/gateway-client.test.js", -] -effect-review = [ "product/runtime/auths-gateway/src/recipe/tests.rs#native_review_contract_fixture_is_current", "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", -] -effect-entry = [ - "product/runtime/auths-gateway/src/entry_tests.rs#native_admission_fixture_is_current", - "product/runtime/auths-gateway/src/entry_tests.rs#postgres_admission_checks_authority_before_atomic_charges", - "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", - "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", - "product/runtime/auths-gateway/src/entry_tests.rs#postgres_grant_has_one_winner_and_no_restart_permit", - "product/runtime/auths-gateway/src/entry_tests.rs#postgres_reservation_restart_retains_capacity_and_requires_fresh_approval", -] -effect-configuration = [ "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", -] -operational-diagnostics = [ - "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_requires_a_recent_nonfuture_sample", - "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_refuses_links_and_untrusted_write_permissions", - "product/runtime/auths-gateway/src/credential_journal.rs#notes_survive_restart_and_refuse_missing_corrupt_full_or_foreign_state", - "product/runtime/auths-gateway/src/engine.rs#durable_cleanup_retires_abandoned_generations_and_keeps_active_and_future_secrets", - "product/runtime/auths-gateway/src/readiness.rs#the_projection_names_every_check_and_retains_precise_qualification_failure", - "product/runtime/auths-gateway/src/engine.rs#readiness_and_emergency_stop_make_no_credential_lease", - "product/runtime/auths-gateway/src/engine.rs#a_restored_store_below_the_host_floor_cannot_lease_after_restart", - "product/runtime/auths-gateway/tests/support_bundle.rs#a_support_bundle_holds_no_planted_canary", -] -configuration-compiler = [ "product/runtime/auths-gateway/src/recipe/tests.rs#three_independent_recipes_compile_without_provider_code", "product/runtime/auths-gateway/src/recipe/tests.rs#hostile_recipe_corpus_fails_with_exact_codes", "product/runtime/auths-gateway/src/recipe/tests.rs#github_recipe_change_invalidates_old_authorized_arguments", @@ -1747,53 +1692,31 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/pending_vectors/recipes.rs#every_base_compiles_to_its_documented_class_and_digest", "product/runtime/auths-gateway/src/pending_vectors/recipes.rs#every_hostile_case_fails_with_its_code", ] -principal-evidence-integration = [ - "product/runtime/auths-gateway/src/observer.rs#observer_seed_is_owner_only_never_overwritten_and_never_printed", - "product/runtime/auths-gateway/src/observer.rs#signed_read_back_decodes_with_exact_schema_subject_and_facts", - "product/runtime/auths-gateway/src/observed_tests.rs#self_signed_or_forged_observations_never_satisfy", - "product/runtime/auths-gateway/src/observed_tests.rs#observer_in_the_authority_chain_is_refused", - "product/runtime/auths-gateway/src/observed_tests.rs#custody_held_observers_satisfy_requirements", - "product/runtime/auths-gateway/src/observed_tests.rs#custody_observer_passes_custody_conformance", - "product/runtime/auths-gateway/src/observed_tests.rs#custody_observer_lifecycle_gates_the_provider", - "product/runtime/auths-gateway/src/observed_tests.rs#production_principals_must_be_separate", - "product/runtime/auths-gateway/src/observed_tests.rs#observer_key_in_the_authority_chain_is_refused_by_key", - "product/runtime/auths-gateway/src/pending_vectors/keys.rs#key_identity_conformance", - "product/runtime/auths-gateway/src/pending_vectors/keys.rs#separation_compares_one_key_under_two_methods", - "product/runtime/auths-gateway/src/operator.rs#a_signed_attestation_authenticates_its_operator", - "product/runtime/auths-gateway/src/operator.rs#an_invalid_attestation_is_refused", - "product/runtime/auths-gateway/src/observed_tests.rs#two_of_three_root_authorizes_only_with_two_distinct_roots", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_reproduces_every_gateway_decision", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_detects_a_tampered_bundle", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_lists_recorded_approval_responses_without_changing_verdicts", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_flags_an_over_admission_without_any_order", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_reports_an_exhaustion_the_bundle_does_not_show", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_reports_every_entry_unverified", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_never_passes_an_altered_proof", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_flags_a_duplicated_entry", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_flags_misfiled_proofs", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_fails_a_valid_submission_refused_while_disabled", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_fails_an_admitted_entry_whose_outcome_was_removed", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_allowing_unverified_refusals_accepts_an_altered_proof_without_its_outcome", - "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_report_names_unverified_entries", - "product/runtime/auths-gateway/src/audit_tests.rs#audit_flags_a_basis_that_does_not_admit_its_argument", - "product/runtime/auths-gateway/src/audit_tests.rs#audit_requires_the_counter_set_the_audit_derives", - "product/runtime/auths-gateway/src/audit_tests.rs#audit_checks_the_pre_entry_observations", - "product/runtime/auths-gateway/src/audit_tests.rs#audit_applies_the_account_scope_binding", - "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_v2_vectors_are_current", - "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verifier_accepts_every_vector_with_its_facts_and_refuses_the_rest", - "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verdicts_follow_the_stage_condition", - "product/runtime/auths-gateway/src/pending_vectors/codes.rs#gateway_codes_inventory_is_closed", - "product/runtime/auths-gateway/src/pending_vectors/production.rs#recipes_cannot_select_custody_or_declare_qualification", - "product/runtime/auths-gateway/src/pending_vectors/production.rs#store_kind_vectors_match_the_closed_kind", - "product/runtime/auths-gateway/src/pending_vectors/production.rs#every_hostile_class_has_a_vector", - "product/runtime/auths-gateway/src/pending_vectors/production.rs#production_codes_await_their_epics", - "product/runtime/auths-gateway/src/echo_verify.rs#match_mismatch_and_absent_each_have_their_code", - "product/runtime/auths-gateway/src/echo_verify.rs#invalid_inputs_are_refused_with_their_codes", - "product/runtime/auths-gateway/tests/echo_verify.rs#echo_verify_exits_zero_only_on_a_match", - "product/runtime/auths-gateway/src/property_tests.rs#outcome_facts_round_trip_through_signing", - "product/runtime/auths-gateway/src/property_tests.rs#audit_conditions_agree_with_every_arrival_order", -] +# Evidence coverage: content-process-composition. +# Evidence coverage: content-application-boundary. +# Evidence coverage: disclosure-local-socket-file-grant. +# Evidence coverage: content-journal-transport. +# Evidence coverage: disclosure-acknowledgement-contract. +# Evidence coverage: candidate-process-journey. +# Evidence coverage: candidate-acquisition. +# Evidence coverage: recovery-entry. +# Evidence coverage: effect-entry. runtime-enforcement-boundary = [ + "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_journey_fixture_is_current", + "product/runtime/auths-gateway/src/app/content_tests.rs#native_application_content_frame_fixture_is_current", + "product/runtime/auths-gateway/tests/application_content_cli.rs#native_application_content_cli_fixture_is_current", + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", + "product/runtime/auths-gateway/src/effect_disclosure_tests.rs#native_disclosure_acknowledgement_fixture_is_current", + "product/runtime/auths-gateway/tests/candidate_journey.rs#approved_candidate_process_journey_fixture_is_current", + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", + "product/runtime/auths-gateway/src/effect_prerequisite_tests.rs#native_prerequisite_compilation_fixture_is_current", + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#native_admission_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_admission_checks_authority_before_atomic_charges", + "product/runtime/auths-gateway/src/entry_tests.rs#native_entry_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#file_grant_has_one_winner_and_no_restart_permit", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_grant_has_one_winner_and_no_restart_permit", + "product/runtime/auths-gateway/src/entry_tests.rs#postgres_reservation_restart_retains_capacity_and_requires_fresh_approval", "product/runtime/auths-gateway/src/qualification_tests.rs#an_engine_without_a_configured_gate_leases_nothing", "product/runtime/auths-gateway/src/qualification_tests.rs#a_qualified_deployment_leases_and_each_fault_refuses_before_the_lease", "product/runtime/auths-gateway/src/qualification_tests.rs#a_drifted_deployment_is_stale_under_the_same_release", @@ -1818,7 +1741,7 @@ runtime-enforcement-boundary = [ "product/runtime/auths-gateway/src/observed_tests.rs#read_back_of_another_record_cannot_license_this_write", "product/runtime/auths-gateway/src/observed_tests.rs#chained_step_is_refused_until_the_previous_step_is_provider_bound", "product/runtime/auths-gateway/src/observed_tests.rs#action_fact_policy_is_bound_into_the_pinned_configuration", - "product/runtime/auths-gateway/src/observed_tests.rs#sdk_action_window_admits_a_later_gateway_clock_and_replay_stays_refused", + "product/runtime/auths-gateway/src/observed_tests.rs#sdk_action_window_admits_a_later_gateway_clock_and_replay_returns_history", "product/runtime/auths-gateway/src/observed_tests.rs#sdk_action_window_is_cut_to_the_grant_expiry", "product/runtime/auths-gateway/src/observed_tests.rs#a_longer_action_window_never_extends_observation_freshness", "product/runtime/auths-gateway/src/bounds_tests.rs#per_principal_bounds_admit_only_actions_inside_the_signer_bound", @@ -1866,7 +1789,27 @@ runtime-enforcement-boundary = [ "product/runtime/auths-gateway/src/onboarding.rs#a_recipe_without_a_guard_needs_no_network", "product/runtime/auths-gateway/src/onboarding.rs#the_loopback_build_runs_the_same_onboarding_checks", ] +# Evidence coverage: disclosure-journal-admission. +# Evidence coverage: protected-content-retention. +# Evidence coverage: candidate-staging. +# Evidence coverage: candidate-publication. +# Evidence coverage: recovery-refinement. +# Evidence coverage: effect-replay. stateful-replay-budget-component = [ + "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_process_tests.rs#native_file_process_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_process_tests.rs#postgres_native_process_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", + "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", + "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", + "product/runtime/auths-gateway/src/effect_candidate_tests.rs#native_candidate_compilation_fixture_is_current", + "product/runtime/auths-gateway/tests/candidate_cli.rs#native_candidate_cli_fixture_is_current", + "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", + "product/runtime/auths-gateway/src/app.rs#native_application_recovery_frame_fixture_is_current", + "product/runtime/auths-gateway/tests/application_recovery_cli.rs#native_application_recovery_cli_fixture_is_current", + "product/runtime/auths-gateway/src/scenario_tests.rs#native_replay_projection_fixture_is_current", + "bindings/python/tests/test_gateway_client.py#test_native_replay_projection_corpus", + "bindings/typescript/test/unit/gateway-client.test.js#gateway decodes the native replay and reservation corpus", "product/runtime/auths-gateway/src/commissioning_budget/tests.rs#capacity_survives_crash_restart_and_sweep_file", "product/runtime/auths-gateway/src/qualification.rs#pinned_ceremony_authenticates_separate_signer_purposes", "product/runtime/auths-gateway/src/commissioning_floor/tests.rs#runtime_never_creates_a_missing_floor", @@ -1896,13 +1839,12 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/commissioning_budget/tests.rs#hostile_inputs_consume_nothing_and_revocation_survives_omission_postgres", "product/runtime/auths-gateway/src/commissioning_budget/tests.rs#snapshots_reject_noncanonical_unknown_oversized_and_impossible_state", "product/runtime/auths-gateway/src/commissioning_budget/tests.rs#consumption_never_exceeds_the_ceiling_or_charges_a_refused_action", - "product/runtime/auths-gateway/src/recipe/tests.rs#durable_claim_is_one_use_across_races_and_restart", "product/runtime/auths-gateway/src/recipe/tests.rs#response_and_observation_are_distinct_durable_stages", "product/runtime/auths-gateway/src/recipe/tests.rs#read_back_links_only_an_exact_token_with_the_verified_value", "product/runtime/auths-gateway/src/scenario_tests.rs#record_scenarios_drive_the_counting_provider", "product/runtime/auths-gateway/src/scenario_tests.rs#qualification_stages_use_gateway_replay_and_recovery_witnesses", - "product/runtime/auths-gateway/src/scenario_tests.rs#normal_write_reaches_observed_by_provider_with_secret_free_evidence", + "product/runtime/auths-gateway/src/scenario_tests.rs#response_requires_a_separate_reference_observation_for_evidence", "product/runtime/auths-gateway/src/scenario_tests.rs#a_lost_claim_resends_the_same_idempotency_key", "product/runtime/auths-gateway/src/scenario_tests.rs#file_store_passes_attempt_store_conformance", "product/runtime/auths-gateway/src/scenario_tests.rs#postgres_store_passes_attempt_store_conformance", @@ -1919,6 +1861,62 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/property_tests.rs#path_values_decode_back_and_never_add_a_segment", "product/runtime/auths-gateway/src/property_tests.rs#relative_ceiling_agrees_with_floor_division", ] +operational-diagnostics = [ + "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_requires_a_recent_nonfuture_sample", + "product/runtime/auths-gateway/src/qualification.rs#synchronization_marker_refuses_links_and_untrusted_write_permissions", + "product/runtime/auths-gateway/src/credential_journal.rs#notes_survive_restart_and_refuse_missing_corrupt_full_or_foreign_state", + "product/runtime/auths-gateway/src/engine.rs#durable_cleanup_retires_abandoned_generations_and_keeps_active_and_future_secrets", + "product/runtime/auths-gateway/src/readiness.rs#the_projection_names_every_check_and_retains_precise_qualification_failure", + "product/runtime/auths-gateway/src/engine.rs#readiness_and_emergency_stop_make_no_credential_lease", + "product/runtime/auths-gateway/src/engine.rs#a_restored_store_below_the_host_floor_cannot_lease_after_restart", + "product/runtime/auths-gateway/tests/support_bundle.rs#a_support_bundle_holds_no_planted_canary", +] +principal-evidence-integration = [ + "product/runtime/auths-gateway/src/observer.rs#observer_seed_is_owner_only_never_overwritten_and_never_printed", + "product/runtime/auths-gateway/src/observer.rs#signed_read_back_decodes_with_exact_schema_subject_and_facts", + "product/runtime/auths-gateway/src/observed_tests.rs#self_signed_or_forged_observations_never_satisfy", + "product/runtime/auths-gateway/src/observed_tests.rs#observer_in_the_authority_chain_is_refused", + "product/runtime/auths-gateway/src/observed_tests.rs#custody_held_observers_satisfy_requirements", + "product/runtime/auths-gateway/src/observed_tests.rs#custody_observer_passes_custody_conformance", + "product/runtime/auths-gateway/src/observed_tests.rs#custody_observer_lifecycle_gates_the_provider", + "product/runtime/auths-gateway/src/observed_tests.rs#production_principals_must_be_separate", + "product/runtime/auths-gateway/src/observed_tests.rs#observer_key_in_the_authority_chain_is_refused_by_key", + "product/runtime/auths-gateway/src/pending_vectors/keys.rs#key_identity_conformance", + "product/runtime/auths-gateway/src/pending_vectors/keys.rs#separation_compares_one_key_under_two_methods", + "product/runtime/auths-gateway/src/operator.rs#a_signed_attestation_authenticates_its_operator", + "product/runtime/auths-gateway/src/operator.rs#an_invalid_attestation_is_refused", + "product/runtime/auths-gateway/src/observed_tests.rs#two_of_three_root_authorizes_only_with_two_distinct_roots", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_reproduces_every_gateway_decision", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_detects_a_tampered_bundle", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_lists_recorded_approval_responses_without_changing_verdicts", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_flags_an_over_admission_without_any_order", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_reports_an_exhaustion_the_bundle_does_not_show", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_reports_every_entry_unverified", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_never_passes_an_altered_proof", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_flags_a_duplicated_entry", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_without_outcomes_flags_misfiled_proofs", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_fails_a_valid_submission_refused_while_disabled", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_fails_an_admitted_entry_whose_outcome_was_removed", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_allowing_unverified_refusals_accepts_an_altered_proof_without_its_outcome", + "product/runtime/auths-gateway/src/bounds_tests.rs#offline_audit_report_names_unverified_entries", + "product/runtime/auths-gateway/src/audit_tests.rs#audit_flags_a_basis_that_does_not_admit_its_argument", + "product/runtime/auths-gateway/src/audit_tests.rs#audit_requires_the_counter_set_the_audit_derives", + "product/runtime/auths-gateway/src/audit_tests.rs#audit_checks_the_pre_entry_observations", + "product/runtime/auths-gateway/src/audit_tests.rs#audit_applies_the_account_scope_binding", + "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_v2_vectors_are_current", + "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verifier_accepts_every_vector_with_its_facts_and_refuses_the_rest", + "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verdicts_follow_the_stage_condition", + "product/runtime/auths-gateway/src/pending_vectors/codes.rs#gateway_codes_inventory_is_closed", + "product/runtime/auths-gateway/src/pending_vectors/production.rs#recipes_cannot_select_custody_or_declare_qualification", + "product/runtime/auths-gateway/src/pending_vectors/production.rs#store_kind_vectors_match_the_closed_kind", + "product/runtime/auths-gateway/src/pending_vectors/production.rs#every_hostile_class_has_a_vector", + "product/runtime/auths-gateway/src/pending_vectors/production.rs#production_codes_await_their_epics", + "product/runtime/auths-gateway/src/echo_verify.rs#match_mismatch_and_absent_each_have_their_code", + "product/runtime/auths-gateway/src/echo_verify.rs#invalid_inputs_are_refused_with_their_codes", + "product/runtime/auths-gateway/tests/echo_verify.rs#echo_verify_exits_zero_only_on_a_match", + "product/runtime/auths-gateway/src/property_tests.rs#outcome_facts_round_trip_through_signing", + "product/runtime/auths-gateway/src/property_tests.rs#audit_conditions_agree_with_every_arrival_order", +] [packages.auths-gateway-kernel] kind = "cargo" @@ -2076,13 +2074,21 @@ configuration_inputs = ["gateway-app-socket", "trusted-authority-configuration"] security_state = ["portable-linked-receipts"] [packages."@auths-dev/sdk".claims] -content-control-envelopes = [ +# Evidence coverage: content-control-envelopes. +language-binding = [ "bindings/typescript/test/unit/gateway-client.test.js#native content control envelopes preserve Rust fixtures", "bindings/typescript/test/unit/gateway-client.test.js#content controls reject invalid operation and ACK bounds", + "bindings/typescript/test/unit/public-api-v2.test.js#clean-cut modules expose the intended domain-neutral surface", + "bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt projection rejects ID and variant contradictions", + "bindings/typescript/test/unit/self-hosted-authority.test.js#malformed trust or grant input is refused before native code or custody", + "bindings/typescript/test/unit/self-hosted-authority.test.js#a declining or unbound root custody response issues no grant", +] +core-wire-consumer = [ + "bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt v1 uses the Rust projection and needs no companion input", + "bindings/typescript/test/integration/workflow/attach.test.js#attachAgent binds one canonical root authority through native Rust", + "bindings/typescript/test/integration/workflow/delegation.test.js#delegate plans reviews approves and signs one attenuated child", + "bindings/typescript/test/integration/workflow/client.test.js#transaction binding drives the real Rust WASM authoring ABI", ] -core-wire-consumer = ["bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt v1 uses the Rust projection and needs no companion input", "bindings/typescript/test/integration/workflow/attach.test.js#attachAgent binds one canonical root authority through native Rust", "bindings/typescript/test/integration/workflow/delegation.test.js#delegate plans reviews approves and signs one attenuated child", "bindings/typescript/test/integration/workflow/client.test.js#transaction binding drives the real Rust WASM authoring ABI"] -language-binding = ["bindings/typescript/test/unit/public-api-v2.test.js#clean-cut modules expose the intended domain-neutral surface", "bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt projection rejects ID and variant contradictions", "bindings/typescript/test/unit/self-hosted-authority.test.js#malformed trust or grant input is refused before native code or custody", "bindings/typescript/test/unit/self-hosted-authority.test.js#a declining or unbound root custody response issues no grant"] - runtime-enforcement-boundary = [ "bindings/typescript/test/unit/public-api-v2.test.js#the root carries no local-agent connector or operation errors", "bindings/typescript/test/unit/portable-receipt-v1.test.js#portable receipt projection rejects ID and variant contradictions", @@ -2166,7 +2172,20 @@ configuration_inputs = ["operator-pins", "trusted-context-template", "demo-co-ex security_state = ["task-ledger", "challenge-ledger", "provider-attempt-ledger", "release-commitment", "broker-runtime-lock", "encrypted-employee-credentials", "company-scoped-browser-sessions"] [packages.auths-google-employee-delegation-demo.claims] -metadata-domain-reference = ["demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py#test_metadata_reference_fixture_is_current"] -demo-conformance-fixture = ["demos/google-employee-delegation/broker/tests/test_demo_co_contract.py#test_local_fixture_is_valid_but_never_imported_as_live"] -runtime-enforcement-boundary = ["demos/google-employee-delegation/broker/tests/test_admission.py#test_replay_and_release_after_revocation_are_denied", "demos/google-employee-delegation/broker/tests/test_admission.py#test_two_processes_share_atomic_capacity_and_provider_byte_reservations", "demos/google-employee-delegation/broker/tests/test_admission.py#test_crashed_broker_reopens_slot_without_refunding_charges", "demos/google-employee-delegation/broker/tests/test_google_drive.py#test_deadline_interrupts_a_trickling_header_parser", "demos/google-employee-delegation/broker/tests/test_oauth_custody.py#test_offboarding_closes_admission_and_token_custody", "demos/google-employee-delegation/broker/tests/test_workbench.py#test_other_company_browser_cookie_cannot_authorize_this_workbench"] -receipt-producer-consumer = ["demos/google-employee-delegation/broker/tests/test_task_authority.py#test_real_chain_and_exact_action_pass_read_boundary", "demos/google-employee-delegation/broker/tests/test_admission.py#test_receipt_write_failure_rolls_back_release_commitment"] +# Evidence coverage: metadata-domain-reference. +demo-conformance-fixture = [ + "demos/google-employee-delegation/broker/tests/test_google_metadata_reference.py#test_metadata_reference_fixture_is_current", + "demos/google-employee-delegation/broker/tests/test_demo_co_contract.py#test_local_fixture_is_valid_but_never_imported_as_live", +] +runtime-enforcement-boundary = [ + "demos/google-employee-delegation/broker/tests/test_admission.py#test_replay_and_release_after_revocation_are_denied", + "demos/google-employee-delegation/broker/tests/test_admission.py#test_two_processes_share_atomic_capacity_and_provider_byte_reservations", + "demos/google-employee-delegation/broker/tests/test_admission.py#test_crashed_broker_reopens_slot_without_refunding_charges", + "demos/google-employee-delegation/broker/tests/test_google_drive.py#test_deadline_interrupts_a_trickling_header_parser", + "demos/google-employee-delegation/broker/tests/test_oauth_custody.py#test_offboarding_closes_admission_and_token_custody", + "demos/google-employee-delegation/broker/tests/test_workbench.py#test_other_company_browser_cookie_cannot_authorize_this_workbench", +] +receipt-producer-consumer = [ + "demos/google-employee-delegation/broker/tests/test_task_authority.py#test_real_chain_and_exact_action_pass_read_boundary", + "demos/google-employee-delegation/broker/tests/test_admission.py#test_receipt_write_failure_rolls_back_release_commitment", +] diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index 25b92f4e9..c87805196 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "38f42e4b20b5f2c3312654eac384932091c1085677bf073cbe79695ca08048eb", + "digest": "bb575dd0f27bc7c9a5c087cb35730a28deae9dd9c1952e2da15429179c4247f7", "files": [ { "path": ".cargo/config.toml", @@ -157,7 +157,7 @@ }, { "path": "product/runtime/auths-connections/src/credential.rs", - "sha256": "83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb" + "sha256": "7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad" }, { "path": "product/runtime/auths-connections/src/kernel.rs", @@ -205,7 +205,7 @@ }, { "path": "product/runtime/auths-gateway-kernel/src/transition.rs", - "sha256": "ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc" + "sha256": "9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c" }, { "path": "product/runtime/auths-lifecycle/Cargo.toml", diff --git a/product/runtime/auths-connections/src/credential.rs b/product/runtime/auths-connections/src/credential.rs index 4e8bd4815..e593575b8 100644 --- a/product/runtime/auths-connections/src/credential.rs +++ b/product/runtime/auths-connections/src/credential.rs @@ -304,6 +304,8 @@ pub struct InMemoryCredentialStore { maximum_bytes: usize, } +type CredentialEntries = BTreeMap<(String, u64), StoredSecret>; + /// One retained generation. Every clone, including the copy-on-write map in /// [`PersistentCredentialStore`], zeroizes its bytes when dropped. #[derive(Clone)] @@ -685,9 +687,7 @@ impl PersistentCredentialStore { Ok(()) } - fn current_entries( - &self, - ) -> Result>, CredentialStoreError> { + fn current_entries(&self) -> Result, CredentialStoreError> { let mut entries = self .entries .lock() diff --git a/product/runtime/auths-gateway-kernel/src/transition.rs b/product/runtime/auths-gateway-kernel/src/transition.rs index 420c09240..a3a6dace5 100644 --- a/product/runtime/auths-gateway-kernel/src/transition.rs +++ b/product/runtime/auths-gateway-kernel/src/transition.rs @@ -260,8 +260,8 @@ pub fn consistent(view: &AttemptView) -> bool { protocol_consistent(view) && view.revision > 0 && view.revision <= 9_007_199_254_740_991 - && requires_entry(view.stage) == !absent(&view.entry) - && acknowledgement_stage(view.stage) == !absent(&view.acknowledgement) + && requires_entry(view.stage) != absent(&view.entry) + && acknowledgement_stage(view.stage) != absent(&view.acknowledgement) && refusal_stage(view.stage) == view.refusal && (!requires_response(view.stage) || has_response) && (!has_response || permits_response(view.stage)) diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 9ad306873..36dbba573 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"83b4f30aaa0e1ad8440f9f5c1bc9146818e0ee446d2d0005ac8b8cfd0929c0cb"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"ef736111a6630f138de447e3cf6aa126749b1e9741e9e2eb5dc69293051474bc"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"aefdacdd34a9466ec9dee4e33cd1102305624a7e366ac07edbf3d8c0050d7b5e"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5b5fb8c8bd0757ce9293728cecc408a49683050db583382a8f63b27b71ceab7c"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"c0465f9b2ebad8ee9b864a51ef5f557f5c740f31f1bb7eb427da15baa7cd8a67"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"a672f65e3d24274bb9b92ea0bf9cb7d48de5a5af86a315b64b1cdd20b270ee02"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"838acc5cdc7983e3a9c5da465b7fa2d2bfac2cc3c935026d2e4d94c80f04111b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"e9d735e592fa11c068c4e60794812666fef31600429aa7a48b14dc8c901af335"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"3e07e1cf4c747b5c0d1e45d370efce14c32cb61fe2b970f1db623fde5869fa7d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"c055c4b8fa325e7cda54edc7047262a76d7d4e0c35ef1eb173a54c9675219c16"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c37b065fd0c20d090fb0913c8bdc094a362b7102e105d599014cde2feedffca4"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"a2b7016e347060d1e41b7032d5a749fd0ee798a86e5ceb353fd3af7b4284c10d"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"ae791602a3402f2058837ae5a19985d42e0248d3a29bf78fad5d09d39c4ac86e"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"0b41378aa5784619a1bdbbf66fa929d558614a883b9656f0705912e19d02ec49"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"41bfaa5f945b650162c4825654cdf199ff6bc45873cdf360ce3fb2eaadb7dadd"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"d5d7871b284bfed8c1cbc55f5ef31c2a769e3c86ed0e8ec65afd0ad3adacaf68"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"2805b70ec0367a1b1f5d262c7dca391d1cc1abfc69aabede203fe569112b0de7"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"c0781ebb3d027781d859fab6552b3b45eb73887b75753820993297dd1fa9419f"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"b5ff0f98bc0c5b11135e8821ba8485d862e977e47290d16f0d3e54af27f53dc6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"ad60726f3d4ba05386b2a64f1022b8e82b6f6a1098a722b7a2ab1b7604f1f634"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9cdb9a8fac801b2fdb6d0ece72aaa8a69675222a1f094d6edf01ce4792d63d38"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"59325539bd4fb59bad9e8e91cd305f393d4ed33d0b7f814153b1f02131eb892a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"93cdec7043a616742910d6a269315765cb30bf3b0982a02e8bbd0ec70c02fdcf"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"0b98f42876a7eb274ff4dc9f60da72f4c1bcc3f32559decc26425d1a34c7acd4"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"f06d632a538f5ec75492cf99d037d4691899a6637085d51bbe9ee514d84a4c83"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"690ee4b8c2a6b958c28385035eb84627cc62bf29b92d52d10aaf195af2ceda24"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"c513139006c23029e25074220e254c502f26986aecbe29ee615faba783953b3e"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"ae791a5213b4b2549692d39d2b7853977f85aa281b04591d781b31258b6905a9"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"006c735b311ccde0c72b4b30386bbe178e15b2c9beaa9024f9ba1b37cd65290c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"2ab677f9797ebd541da60a96857b653f5c58cce017f98b63b24edcd694a99d41"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"af5fe3a43b8cee415f3a4ecfb91d167fd91307a00686da56f83d1dc0def0d249"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"7f1c85fcd9eccc3f2dda13d78d89cad680795b738859a67c4975a92de5165928"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"e0d51a450b2f45c9f0c40c057cf2ef23ebe326a51f579f67acdff96698902cab"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"a4f53cd0b02ad36b7821b3933f0ce1f288d4c164a28b751d31b1088e0603b56b"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a78380b019104d688c11a4410082c7e08ded3106aab099954c4f8a1b4ae0fd89"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"4daa85982d20474a07f7cce1e0817ebbaa1bbdc29f0ffc7abfa12db40ff5544f"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"1523d90eb6b80215a7f5688436a583e5753f309c684f2e298335b0ddaa179311"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"57f9f39d7e5105451b2434058ae8299d3cdf970f0fd0743bc20cb88abad34bad"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"b8f71d3d9529039b0582c9da2ca23dc7cc996377b5ad346ba7f4d182a97e3ea1"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"545720ecbed3a72c8e57ccea41d6d884dfeb7a539d87fabbe2ed0d2300907a0d"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0f5972c947871adcbec841f1b56adf3b7db2f7c5439c6ae9fbc0d9eefe9e2336"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"aeb0c7118cb2a9078f30d64179301744fa1aaa0827f50f804a7a53e5fa4685cf"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"18bb830d2aa5a301e424a399bb2ee32c1337029ebf130d022c9500aff9f89ed8"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"289d4db5d81673cd5b339ff8b9100f535ffe99b266a6a84ed64bdb5308d225ef"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"15a57bdb1404524e8400d1912d6e958d1944e775d9c5ebc2225860cc538f2c83"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"a2fb7fa7968da51b2957a00ffdb59223932bea02bde734e1f20d6c2e69b38245"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"b3358a3130cf3f37b9d4f8c5cfa115fd551d0142630b8d0afc7a5adc7705913f"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"938b1fe5d3b0f32f95e10d8052b7a11c39fb4c7024452cef72a575903df4f41e"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"006c735b311ccde0c72b4b30386bbe178e15b2c9beaa9024f9ba1b37cd65290c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"2ab677f9797ebd541da60a96857b653f5c58cce017f98b63b24edcd694a99d41"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 835d72302..a59f70440 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -413,7 +413,10 @@ impl GatewayApplication for GatewayEngine { stream: UnixStream, clock: SessionClock, ) { - content::engine_disclose(self, target, submission, stream, clock).await; + Box::pin(content::engine_disclose( + self, target, submission, stream, clock, + )) + .await; } async fn observe(&self, request: &GatewayObserveRequest) -> GatewayObserveResult { @@ -767,7 +770,8 @@ mod tests { "request": {"kind": "outcome", "operation_id": "step-1"} }); assert!(serde_json::from_value::(read_back.clone()).is_err()); - for frame in [&outcome] { + { + let frame = &outcome; assert!(matches!( serde_json::from_value::(frame.clone()), Ok(AppFrame::Observe(_)) diff --git a/product/runtime/auths-gateway/src/app/content.rs b/product/runtime/auths-gateway/src/app/content.rs index e4c6c5770..82a6baa8f 100644 --- a/product/runtime/auths-gateway/src/app/content.rs +++ b/product/runtime/auths-gateway/src/app/content.rs @@ -231,7 +231,7 @@ pub(super) async fn disclose( Ok(decoded) => { application .disclose_content(request.target, decoded, stream, clock) - .await + .await; } Err(code) => { let mut stream = stream; @@ -308,7 +308,7 @@ pub(super) async fn engine_disclose( /// no received bytes and never authorizes automatic redelivery. pub enum AppDisclosureReception { /// Exact plaintext received through the authenticated native transport. - Received(crate::disclosure_transport::ReceivedDisclosure), + Received(Box), /// The operation already has retained history; no handshake/send occurred. History(crate::DisclosureSnapshot), /// Native pre-handshake refusal. @@ -365,6 +365,7 @@ pub async fn receive_content_disclosure( key, ) .await + .map(Box::new) .map(AppDisclosureReception::Received), AppContentResult::History { history: crate::ContentHistory::Disclosure(snapshot), diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 583b6cb09..e055f8228 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -2506,23 +2506,7 @@ mod unix { ..AdminResponse::refused("gateway.admin.execution-witness") }, Ok(AdminCommand::QualificationReload) => { - let reloading = Arc::clone(&engine); - let directory = Arc::clone(&state_dir); - let reloaded = tokio::task::spawn_blocking(move || { - let local = qualification_reload(&directory, reloading.qualification()); - reloading.publish_effect_qualification(reloading.qualification())?; - local - }) - .await; - match reloaded { - Ok(Ok(())) => AdminResponse { - ok: true, - qualification: Some(QualificationReport::of(engine.qualification())), - ..AdminResponse::refused("gateway.admin.qualification-reloaded") - }, - Ok(Err(code)) => AdminResponse::refused(code), - Err(_) => AdminResponse::refused("gateway.qualification.unavailable"), - } + reload_admin_qualification(&engine, &state_dir).await } Ok(AdminCommand::Recover { source_operation, @@ -2567,13 +2551,36 @@ mod unix { Err(code) => AdminResponse::refused(code), } }; - if let Some((mut stream, response)) = clock.complete(stream, change).await + if let Some((mut stream, response)) = Box::pin(clock.complete(stream, change)).await && let Ok(bytes) = serde_json::to_vec(&response) { let _ = clock.write_frame(&mut stream, &bytes).await; } } + async fn reload_admin_qualification( + engine: &Arc, + state_dir: &Arc, + ) -> AdminResponse { + let reloading = Arc::clone(engine); + let directory = Arc::clone(state_dir); + let reloaded = tokio::task::spawn_blocking(move || { + let local = qualification_reload(&directory, reloading.qualification()); + reloading.publish_effect_qualification(reloading.qualification())?; + local + }) + .await; + match reloaded { + Ok(Ok(())) => AdminResponse { + ok: true, + qualification: Some(QualificationReport::of(engine.qualification())), + ..AdminResponse::refused("gateway.admin.qualification-reloaded") + }, + Ok(Err(code)) => AdminResponse::refused(code), + Err(_) => AdminResponse::refused("gateway.qualification.unavailable"), + } + } + /// Admits an admin connection only from the gateway's own effective UID /// or root, before it takes an admin permit. fn admin_peer_admitted(stream: &UnixStream, owner: u32) -> bool { @@ -2744,7 +2751,7 @@ mod unix { let engine = Arc::clone(&app_engine); async move { let _permit = permit; - app_session(stream, engine.as_ref()).await; + Box::pin(app_session(stream, engine.as_ref())).await; } }, ); @@ -2759,7 +2766,7 @@ mod unix { let state_dir = Arc::clone(&admin_state_dir); async move { let _permit = permit; - admin_session(stream, engine, state_dir).await; + Box::pin(admin_session(stream, engine, state_dir)).await; } }, ); @@ -5407,7 +5414,7 @@ mod unix { #[cfg(unix)] #[tokio::main] async fn main() { - if let Err(failure) = unix::run().await { + if let Err(failure) = Box::pin(unix::run()).await { eprintln!("{failure}"); std::process::exit(1); } diff --git a/product/runtime/auths-gateway/src/bounds.rs b/product/runtime/auths-gateway/src/bounds.rs index 71c4e5c1b..3ab501f79 100644 --- a/product/runtime/auths-gateway/src/bounds.rs +++ b/product/runtime/auths-gateway/src/bounds.rs @@ -727,6 +727,7 @@ pub(crate) fn admit_disclosure_bounds( ) } +#[derive(Clone, Copy)] enum InformationBudget { Acquisition, Disclosure, @@ -798,7 +799,7 @@ pub(crate) fn admit_links( links, action, recipe.namespace(), - recipe.sum_requirement(), + recipe.sum_requirement().as_ref(), now, ) } @@ -807,7 +808,7 @@ fn admit_policy_links( links: Vec, action: &CanonicalAction, namespace: &OperatorNamespace, - requirement: Option, + requirement: Option<&SumRequirement>, now: u64, ) -> Result, &'static str> { if links.len() > MAX_BOUNDED_LINKS { diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index 76f218406..a06592fbc 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -1,7 +1,12 @@ //! Candidate checks use the shared acquisition owner and exact staged custody. //! Publication is a separate operator action over complete retained evidence. -use super::*; +use super::{ + Arc, ConnectionRecord, ConnectionState, Duration, ExactEffectApproval, + GatewayConnectionDescriptor, GatewayEngine, GatewayHttpTransport, GatewaySubmitResult, Instant, + LoadedConnection, Ordering, ProviderResponse, SecretBytes, SharedConnectionError, + StoredSecretLease, not_entered, submit, +}; use crate::effect::{BoundEffect, CandidateCredentialTarget, compile_candidate_credential}; use crate::submit::AcquisitionIo; @@ -146,7 +151,7 @@ impl GatewayEngine { .map_err(|_| "gateway.admin.transition-unavailable")?; self.holds(record) .await - .map_err(|_| "gateway.admin.credential-unavailable")?; + .map_err(|()| "gateway.admin.credential-unavailable")?; let secret = SecretBytes::new(std::mem::take(&mut *candidate)) .map_err(|_| "gateway.admin.invalid-credential")?; self.note_credential(record, proposed.credential_generation()) @@ -313,7 +318,7 @@ impl GatewayEngine { ); self.holds(target.record()) .await - .map_err(|_| "gateway.credential.unavailable")?; + .map_err(|()| "gateway.credential.unavailable")?; let disposition = self .attempts .publish_candidate(approved, self.candidate_validation(target, started)?, now) diff --git a/product/runtime/auths-gateway/src/commissioning_session.rs b/product/runtime/auths-gateway/src/commissioning_session.rs index d6ab031d0..f25e6d1ad 100644 --- a/product/runtime/auths-gateway/src/commissioning_session.rs +++ b/product/runtime/auths-gateway/src/commissioning_session.rs @@ -369,17 +369,16 @@ impl CommissioningSession<'_> { .await .map_err(|_| "gateway.commissioning.store-unavailable")? .map_err(CommissioningBudgetRefusal::code)?; - match update.refusal() { - Some(refusal) => Err(refusal.code()), + if let Some(refusal) = update.refusal() { + Err(refusal.code()) + } else { // A queued host lock or durable store write can outlast the permit // window. Capacity stays spent, but custody requires fresh time. - None => { - action - .claimed - .set(update.snapshot().clone()) - .map_err(|_| "gateway.commissioning.binding-mismatch")?; - self.check(action) - } + action + .claimed + .set(update.snapshot().clone()) + .map_err(|_| "gateway.commissioning.binding-mismatch")?; + self.check(action) } } } diff --git a/product/runtime/auths-gateway/src/configuration.rs b/product/runtime/auths-gateway/src/configuration.rs index 841b48b2d..e195e97cd 100644 --- a/product/runtime/auths-gateway/src/configuration.rs +++ b/product/runtime/auths-gateway/src/configuration.rs @@ -407,12 +407,15 @@ mod tests { let retained = gate(VerifierState::default()); candidate.check(&retained).expect("retained shared memory"); assert!(retained.verifier_state().revoked_signers.contains(&signer)); - let mut saturated = VerifierState::default(); - saturated.revoked_signers = (0..=MAX_REVOKED_SIGNERS) - .map(|n| { - QualificationSignerId::parse(format!("synthetic-signer-{n}")).expect("signer") - }) - .collect(); + let saturated = VerifierState { + revoked_signers: (0..=MAX_REVOKED_SIGNERS) + .map(|n| { + QualificationSignerId::parse(format!("synthetic-signer-{n}")) + .expect("signer") + }) + .collect(), + ..VerifierState::default() + }; candidate .publish(&gate(saturated)) .expect("durable saturated denial"); diff --git a/product/runtime/auths-gateway/src/disclosure_transport.rs b/product/runtime/auths-gateway/src/disclosure_transport.rs index fb36995df..c43ff234e 100644 --- a/product/runtime/auths-gateway/src/disclosure_transport.rs +++ b/product/runtime/auths-gateway/src/disclosure_transport.rs @@ -20,12 +20,12 @@ const SESSION_SECONDS: u64 = 15; impl UnixDisclosurePolicy { fn server_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { - self.peer(stream, self.gateway_uid(), self.recipient_uid()) + Self::peer(stream, self.gateway_uid(), self.recipient_uid()) } pub(crate) fn recipient_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { - self.peer(stream, self.recipient_uid(), self.gateway_uid()) + Self::peer(stream, self.recipient_uid(), self.gateway_uid()) } - fn peer(&self, stream: &UnixStream, local: u32, remote: u32) -> Result<(), &'static str> { + fn peer(stream: &UnixStream, local: u32, remote: u32) -> Result<(), &'static str> { if rustix::process::geteuid().as_raw() != local || stream .peer_cred() diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 3844994eb..405d44d0f 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -803,21 +803,21 @@ impl PrivateEffectReview { let json = Zeroizing::new( serde_json::to_string_pretty(self).map_err(|_| EffectBindingError::Invalid)?, ); - let mut rendered = Zeroizing::new(String::new()); + let mut literal = Zeroizing::new(String::new()); for character in json.chars() { if character.is_ascii() { - rendered.push(character); + literal.push(character); } else { let mut units = [0; 2]; for unit in character.encode_utf16(&mut units) { - write!(rendered, "\\u{unit:04x}").map_err(|_| EffectBindingError::Invalid)?; + write!(literal, "\\u{unit:04x}").map_err(|_| EffectBindingError::Invalid)?; } } - if rendered.len() > 1_048_576 { + if literal.len() > 1_048_576 { return Err(EffectBindingError::Invalid); } } - Ok(rendered) + Ok(literal) } /// Encodes machine-readable private review without reconstructing identity, @@ -1245,7 +1245,7 @@ impl ApprovedEffect { CompiledEffect::Acquisition(command) => command.request_bytes()?, CompiledEffect::Disclosure(_) => return Err(EffectBindingError::Invalid), }; - let plan = PrerequisitePlan::new(self.effect.binding(), index, transport)?; + let plan = PrerequisitePlan::new(self.effect.binding(), index, &transport)?; Ok((plan, read.clone())) } @@ -1670,8 +1670,8 @@ mod tests { ); let text = std::str::from_utf8(&bytes).expect("json"); for invalid in [ - text.replacen("{", "{\"epoch\":1,", 1), - text.replacen("{", "{\"unknown\":1,", 1), + text.replacen('{', "{\"epoch\":1,", 1), + text.replacen('{', "{\"unknown\":1,", 1), text.replace("\"epoch\":1", "\"epoch\":1.0"), text.replace("\"epoch\":1", "\"epoch\":0"), ] { diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 900e00967..1b67a7462 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -2,7 +2,14 @@ //! This constructs the shared bound effect, not an entry permit. The journal //! must later account and fence the acquisition separately from its source. -use super::*; +use super::{ + ApprovalPolicy, BindingWire, BoundEffect, COMPILER, CompiledEffect, CompiledRecipe, + Deserialize, EFFECT_BINDING_SCHEMA, EffectBinding, EffectBindingError, EffectInstallation, + GatewayConnectionDescriptor, GatewaySubmitResult, LogicalOperationId, MAX_EFFECT_BYTES, + PrerequisitePlan, Prerequisites, Protocol, ReadWire, Reservation, ReservationWindow, Scope, + Serialize, SourceCapacity, Unit, Zeroizing, canonical, commitment, fmt, managed_reservations, + native_authority_commitment, not_entered, +}; use auths_profile_api::ActionProfile as _; use auths_profile_mcp::{McpProfile, McpToolCall}; #[cfg(unix)] @@ -493,7 +500,7 @@ pub(super) fn compile_acquisition( action: &[u8], ) -> Result { let sealed = crate::engine::verify_native(installed.context, now, proof, action)?; - compile_verified_acquisition(installed, target, now, proof, action, sealed) + compile_verified_acquisition(installed, target, now, proof, action, &sealed) } #[allow( @@ -506,7 +513,7 @@ pub(super) fn compile_verified_acquisition( now: u64, proof: &[u8], action: &[u8], - sealed: auths_verifier::SealedVerificationResult, + sealed: &auths_verifier::SealedVerificationResult, ) -> Result { let invalid = || not_entered("gateway.acquisition.binding"); GatewayConnectionDescriptor::from_record(installed.connection, installed.recipe) diff --git a/product/runtime/auths-gateway/src/effect/candidate.rs b/product/runtime/auths-gateway/src/effect/candidate.rs index 55b413f6b..54d0c5f88 100644 --- a/product/runtime/auths-gateway/src/effect/candidate.rs +++ b/product/runtime/auths-gateway/src/effect/candidate.rs @@ -4,7 +4,13 @@ use super::acquisition::{AcquisitionTarget, build_binding, compile_acquisition}; use super::prerequisite::Prerequisite; -use super::*; +use super::{ + BoundEffect, ClosedPrerequisiteRead, CompiledRecipe, ConnectionRecord, Deserialize, + EffectBinding, EffectBindingError, EffectInstallation, GatewayConnectionDescriptor, + GatewaySubmitResult, LogicalOperationId, MAX_EFFECT_BYTES, PrerequisiteKind, Prerequisites, + Protocol, ReservationWindow, Serialize, SourceCapacity, Unit, Zeroizing, canonical, commitment, + fmt, managed_reservations, not_entered, +}; use auths_connections::ConnectionState; use auths_profile_mcp::McpToolCall; use serde_json::{Value, json}; diff --git a/product/runtime/auths-gateway/src/effect/candidate/proposal.rs b/product/runtime/auths-gateway/src/effect/candidate/proposal.rs index 26824ee8f..f1e5f8aa4 100644 --- a/product/runtime/auths-gateway/src/effect/candidate/proposal.rs +++ b/product/runtime/auths-gateway/src/effect/candidate/proposal.rs @@ -1,7 +1,10 @@ //! Private candidate persistence for explicit operator review and restart. //! Decoding reconstructs proposed data only; it grants no custody or I/O. -use super::*; +use super::{ + CandidateCredentialTarget, CompiledRecipe, ConnectionRecord, Deserialize, EffectBindingError, + MAX_EFFECT_BYTES, Serialize, Zeroizing, canonical, decode_connection, +}; const SCHEMA: &str = "auths.gateway-credential-candidate/1"; diff --git a/product/runtime/auths-gateway/src/effect/content.rs b/product/runtime/auths-gateway/src/effect/content.rs index 2b4062039..a94381078 100644 --- a/product/runtime/auths-gateway/src/effect/content.rs +++ b/product/runtime/auths-gateway/src/effect/content.rs @@ -2,7 +2,12 @@ //! Compilation does not grant entry, retain a response or release content. use super::acquisition::{AcquisitionTarget, build_binding, compile_acquisition}; -use super::*; +use super::{ + BoundEffect, CompiledRecipe, ConnectionRecord, Deserialize, EffectBinding, EffectBindingError, + EffectInstallation, GatewayConnectionDescriptor, GatewaySubmitResult, LogicalOperationId, + MAX_EFFECT_BYTES, Prerequisites, Protocol, ReservationWindow, Serialize, SourceCapacity, Unit, + Zeroizing, canonical, commitment, fmt, managed_reservations, not_entered, +}; use crate::recipe::ClosedContentRead; use auths_profile_mcp::McpToolCall; use serde_json::{Map, Value, json}; @@ -266,7 +271,7 @@ pub fn compile_content_action( now, proof, action, - sealed, + &sealed, ) } diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index 0460d7429..8dc748119 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -347,7 +347,7 @@ impl PrerequisitePlan { pub(super) fn new( source: &super::EffectBinding, index: u8, - transport: zeroize::Zeroizing>, + transport: &[u8], ) -> Result { let plan = Self { source_binding: String::from_utf8(source.to_private_bytes()?.to_vec()) diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs index 7a5639e56..5dd2aa771 100644 --- a/product/runtime/auths-gateway/src/effect/release.rs +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -1,6 +1,13 @@ //! Separately verified disclosure compilation over sealed retained provenance. //! No constructor in this module releases bytes or authenticates a live channel. -use super::*; +use super::{ + BoundEffect, CompiledEffect, CompiledRecipe, DISCLOSURE_ACK_SCHEMA, Deserialize, + DisclosureAcknowledgementRequest, EffectBinding, EffectBindingError, EffectInstallation, + GatewayConnectionDescriptor, GatewaySubmitResult, LogicalOperationId, MAX_EFFECT_BYTES, + Prerequisites, Protocol, Reservation, ReservationWindow, Scope, Serialize, SourceCapacity, + Unit, VerifyingKey, Zeroizing, acquisition, canonical, commitment, fmt, managed_reservations, + native_authority_commitment, not_entered, +}; use auths_profile_api::ActionProfile as _; use auths_profile_mcp::{McpProfile, McpToolCall}; use auths_raw_key::{RawKeyDescriptor, RawKeyType}; diff --git a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs index a169aab80..95374dd6f 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs @@ -16,102 +16,17 @@ pub(super) async fn histories( "missing-journal", "bad-prefix", ] { - let directory = tempfile::tempdir().expect("directory"); - let root = std::fs::canonicalize(directory.path()).expect("path"); - #[cfg(unix)] - { - use std::os::unix::fs::PermissionsExt as _; - std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) - .expect("private directory"); - } - let credentials_path = root.join("credentials.cbor"); - let credentials = - Arc::new(PersistentCredentialStore::open(&credentials_path).expect("custody")); - let store: Arc = - Arc::new(crate::FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); - let attempts = - crate::GatewayAttempts::new(Arc::clone(&store), policy.clone()).expect("attempts"); - let template = connection_account( - recipe, - crate::submit::account_commitment("acct_TESTACCOUNT01"), - ); - let first = credentials - .install( - template.connection_id(), - NonZeroU64::MIN, - SecretBytes::new(b"rk_test_initial".to_vec()).expect("secret"), - ) - .await - .expect("custody install"); - let record = ConnectionRecord::new( - template.provider_kind().clone(), - template.alias().clone(), - template.connection_id().clone(), - SemanticId::parse("auths.gateway-operation/1").expect("contract"), - SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), - template.descriptor().to_vec(), - *template.account_commitment(), - *first.as_bytes(), - NonZeroU64::MIN, - ConnectionState::Active, - template.allowed_workloads().to_vec(), - template.allowed_profiles().to_vec(), - NOW - 100, - NOW - 100, - None, - ) - .expect("record"); - let record = match case { - "disabled" => record - .transition_state(ConnectionState::Disabled, NOW - 10) - .expect("disable"), - "revoked" => record - .transition_state(ConnectionState::Revoked, NOW - 10) - .expect("revoke"), - _ => record, - }; - let shared = crate::SharedConnection::new( - Arc::clone(&store), - record.provider_kind().clone(), - record.alias().clone(), - ); - shared.insert(&record).await.expect("insert"); - let journal = crate::CredentialJournal::new(root.clone()); - if case != "missing-journal" { - journal.initialize(record.connection_id()).expect("journal"); - journal - .register(record.connection_id(), record.credential_generation()) - .expect("first note"); - } - let floor = crate::GenerationFloor::new(root.clone()); - floor.initialize(&record).expect("floor"); - let engine = crate::GatewayEngine::new( - recipe.clone(), - *recipe.digest(), - &auths_codec::encode_verifier_context(trust).expect("trust"), - policy.clone(), - record.provider_kind().clone(), - record.alias().clone(), - "gateway".to_owned(), - record.allowed_profiles()[0].clone(), - credentials.clone(), - attempts, - ) - .expect("engine") - .with_credential_journal(journal.clone()) - .with_generation_floor(floor) - .with_qualification(Arc::new(crate::QualificationGate::new( - crate::QualificationPolicy::Optional, - None, - None, - Box::new(Arc::new(crate::FixedClock::at(NOW))), - auths_recipe_qualification::VerifierState::default(), - ))); - engine - .initialize_effect_configuration() - .expect("configuration"); + let fixture = rotation_fixture(recipe, trust, policy, case).await; + let RotationFixture { + credentials_path, + credentials, + record, + shared, + engine, + .. + } = &fixture; let stale = - PersistentCredentialStore::open(&credentials_path).expect("second pre-staging handle"); + PersistentCredentialStore::open(credentials_path).expect("second pre-staging handle"); let before = engine.execution_witness(); assert_eq!( engine @@ -142,101 +57,7 @@ pub(super) async fn histories( .await; if matches!(case, "active" | "disabled") { let target = result.expect("staged"); - assert_eq!(target.record().state(), record.state()); - assert_eq!( - target.record().generation().get(), - record.generation().get() + 1 - ); - assert_eq!( - target.record().credential_generation(), - target.record().generation() - ); - assert_eq!(target.previous(), Some(&record)); - assert!( - credentials - .holds(&record.credential_binding()) - .await - .is_ok() - ); - assert!( - credentials - .holds(&target.record().credential_binding()) - .await - .is_ok() - ); - assert!( - stale - .holds(&target.record().credential_binding()) - .await - .is_ok(), - "a preexisting reader refreshes custody" - ); - assert!( - stale - .replace( - record.connection_id(), - record.generation(), - target.record().credential_generation(), - SecretBytes::new(b"rk_test_stale".to_vec()).expect("secret") - ) - .await - .is_err(), - "a stale writer cannot overwrite the committed candidate" - ); - let bytes = target.to_private_bytes().expect("proposal"); - let repeated = engine - .stage_candidate_rotation(zeroize::Zeroizing::new(secret.to_vec())) - .await - .expect("idempotent custody stage"); - assert_eq!(repeated.to_private_bytes().expect("repeated"), bytes); - assert!( - engine - .stage_candidate_rotation(zeroize::Zeroizing::new(b"rk_test_other".to_vec())) - .await - .is_err(), - "never overwrite a staged candidate" - ); - let reopened = PersistentCredentialStore::open(&credentials_path).expect("reopen"); - assert!(reopened.holds(&record.credential_binding()).await.is_ok()); - assert!( - reopened - .holds(&target.record().credential_binding()) - .await - .is_ok() - ); - let generations = reopened - .stored_generations(record.connection_id()) - .expect("generations"); - assert_eq!( - generations, - vec![ - record.credential_generation(), - target.record().credential_generation() - ] - ); - assert_eq!( - journal.generations(record.connection_id()).expect("notes"), - generations - ); - reopened - .revoke( - record.connection_id(), - target.record().credential_generation(), - ) - .await - .expect("delete staged generation"); - assert!( - stale - .holds(&target.record().credential_binding()) - .await - .is_err(), - "completed deletion is visible to a stale reader" - ); - assert!( - stale.holds(&record.credential_binding()).await.is_ok(), - "current credential remains" - ); - cases.push(json!({"case": case, "staged_generation": target.record().credential_generation().get(), "same_secret_idempotent": true, "different_secret_refused": true, "reopen_retains_current_and_candidate": true, "cleanup_notes_retained": true, "preexisting_reader_refreshes_custody": true, "stale_writer_cannot_overwrite": true, "completed_delete_visible_to_stale_reader": true})); + cases.push(assert_staged_rotation(&fixture, &stale, &target, secret, case).await); } else { assert!(result.is_err(), "{case}"); assert_eq!( @@ -254,7 +75,7 @@ pub(super) async fn histories( .expect("load") .expect("current") .record(), - &record + record ); assert_eq!( engine.execution_witness(), @@ -279,40 +100,13 @@ async fn installation_histories( "substituted-floor", "corrupt-journal", ] { - let directory = tempfile::tempdir().expect("directory"); - let root = std::fs::canonicalize(directory.path()).expect("path"); - #[cfg(unix)] - { - use std::os::unix::fs::PermissionsExt as _; - std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); - } + let (_directory, root) = private_case_directory(); let credentials = Arc::new( PersistentCredentialStore::open(root.join("credentials.cbor")).expect("custody"), ); let store = - Arc::new(crate::FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); - let template = connection_account( - recipe, - crate::submit::account_commitment("acct_TESTACCOUNT01"), - ); - let draft = ConnectionRecord::new( - template.provider_kind().clone(), - template.alias().clone(), - template.connection_id().clone(), - template.contract().clone(), - template.descriptor_schema().clone(), - template.descriptor().to_vec(), - *template.account_commitment(), - [0; 32], - NonZeroU64::MIN, - ConnectionState::Active, - template.allowed_workloads().to_vec(), - template.allowed_profiles().to_vec(), - NOW, - NOW, - None, - ) - .expect("draft"); + Arc::new(crate::FileGatewayAttemptStore::open(root.join("attempts")).expect("store")); + let draft = installation_draft(recipe); let shared = crate::SharedConnection::new( store.clone(), draft.provider_kind().clone(), @@ -329,33 +123,8 @@ async fn installation_histories( std::fs::write(root.join("credential-journal.json"), b"invalid") .expect("corrupt journal"); } - let make_engine = || { - crate::GatewayEngine::new( - recipe.clone(), - *recipe.digest(), - &auths_codec::encode_verifier_context(trust).expect("trust"), - policy.clone(), - draft.provider_kind().clone(), - draft.alias().clone(), - "gateway".to_owned(), - draft.allowed_profiles()[0].clone(), - Arc::new( - PersistentCredentialStore::open(root.join("credentials.cbor")) - .expect("reopened custody"), - ), - crate::GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"), - ) - .expect("engine") - .with_credential_journal(crate::CredentialJournal::new(root.clone())) - .with_generation_floor(floor.clone()) - .with_qualification(Arc::new(crate::QualificationGate::new( - crate::QualificationPolicy::Optional, - None, - None, - Box::new(Arc::new(crate::FixedClock::at(NOW))), - auths_recipe_qualification::VerifierState::default(), - ))) - }; + let make_engine = + || installation_engine(recipe, trust, policy, &draft, &root, &store, &floor); assert_eq!( crate::install_connection( recipe, @@ -384,71 +153,20 @@ async fn installation_histories( .await; if case == "staged" { let target = result.expect("staged"); - assert!(target.previous().is_none()); - assert_eq!(target.record().generation(), NonZeroU64::MIN); - assert!( - credentials - .holds(&target.record().credential_binding()) - .await - .is_ok() - ); - floor.accept(target.record()).expect("floor exact"); - assert!( - floor.accept(&draft).is_err(), - "same generation substitution refused" - ); - let bytes = target.to_private_bytes().expect("proposal"); assert_eq!(engine.execution_witness(), before); drop(engine); - let reopened = make_engine(); - let reopened_before = reopened.execution_witness(); - let repeated = reopened - .stage_candidate_installation(&draft, zeroize::Zeroizing::new(secret.to_vec())) - .await - .expect("resume"); - assert_eq!( - repeated.to_private_bytes().expect("resumed proposal"), - bytes - ); - assert!( - reopened - .stage_candidate_installation( - &draft, - zeroize::Zeroizing::new(b"rk_test_other".to_vec()) - ) - .await - .is_err() - ); - std::fs::remove_file(root.join("connection-floor.json")).expect("lost floor"); - let refused = reopened - .compile_candidate_effect(&target, &[], &[]) - .await - .err() - .expect("missing floor refusal"); - assert_eq!( - refused, - crate::GatewaySubmitResult::NotEntered { - code: "gateway.connection.restore-rollback".to_owned() - } - ); - assert!( - !root.join("connection-floor.json").exists(), - "runtime cannot repair floor" - ); - let restored = reopened - .stage_candidate_installation(&draft, zeroize::Zeroizing::new(secret.to_vec())) - .await - .expect("explicit operator restaging"); - assert_eq!(restored.to_private_bytes().expect("restaged"), bytes); - assert_eq!(reopened.execution_witness(), reopened_before); - assert!(shared.load().await.expect("load").is_none()); - assert_eq!( - crate::CredentialJournal::new(root.clone()) - .generations(draft.connection_id()) - .expect("notes"), - vec![NonZeroU64::MIN] + cases.push( + assert_staged_installation( + &target, + &draft, + &root, + &credentials, + &floor, + &shared, + make_engine, + ) + .await, ); - cases.push(json!({"case":case,"reopened_same_draft_and_secret_exact":true,"different_secret_refused":true,"runtime_missing_floor_refused_without_repair":true,"explicit_restaging_exact":true,"connection_remains_absent":true,"cleanup_note_retained":true})); } else { assert!(result.is_err(), "{case}"); assert_eq!(engine.execution_witness(), before); @@ -464,3 +182,402 @@ async fn installation_histories( } json!({"direct_install_requires_approval_before_custody":true,"cases":cases}) } + +struct RotationFixture { + _directory: tempfile::TempDir, + credentials_path: std::path::PathBuf, + credentials: Arc, + record: ConnectionRecord, + shared: crate::SharedConnection, + journal: crate::CredentialJournal, + engine: crate::GatewayEngine, +} + +async fn rotation_fixture( + recipe: &CompiledRecipe, + trust: &auths_model::TrustedContext, + policy: &EffectPolicy, + case: &str, +) -> RotationFixture { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private directory"); + } + let credentials_path = root.join("credentials.cbor"); + let credentials = + Arc::new(PersistentCredentialStore::open(&credentials_path).expect("custody")); + let store: Arc = + Arc::new(crate::FileGatewayAttemptStore::open(root.join("attempts")).expect("store")); + let attempts = + crate::GatewayAttempts::new(Arc::clone(&store), policy.clone()).expect("attempts"); + let template = connection_account( + recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + let first = credentials + .install( + template.connection_id(), + NonZeroU64::MIN, + SecretBytes::new(b"rk_test_initial".to_vec()).expect("secret"), + ) + .await + .expect("custody install"); + let record = rotation_record(&template, *first.as_bytes(), case); + let shared = crate::SharedConnection::new( + Arc::clone(&store), + record.provider_kind().clone(), + record.alias().clone(), + ); + shared.insert(&record).await.expect("insert"); + let journal = crate::CredentialJournal::new(root.clone()); + if case != "missing-journal" { + journal.initialize(record.connection_id()).expect("journal"); + journal + .register(record.connection_id(), record.credential_generation()) + .expect("first note"); + } + let floor = crate::GenerationFloor::new(root.clone()); + floor.initialize(&record).expect("floor"); + let engine = crate::GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &auths_codec::encode_verifier_context(trust).expect("trust"), + policy.clone(), + record.provider_kind().clone(), + record.alias().clone(), + "gateway".to_owned(), + record.allowed_profiles()[0].clone(), + credentials.clone(), + attempts, + ) + .expect("engine") + .with_credential_journal(journal.clone()) + .with_generation_floor(floor) + .with_qualification(Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(NOW))), + auths_recipe_qualification::VerifierState::default(), + ))); + engine + .initialize_effect_configuration() + .expect("configuration"); + RotationFixture { + _directory: directory, + credentials_path, + credentials, + record, + shared, + journal, + engine, + } +} + +fn rotation_record(template: &ConnectionRecord, first: [u8; 32], case: &str) -> ConnectionRecord { + let record = ConnectionRecord::new( + template.provider_kind().clone(), + template.alias().clone(), + template.connection_id().clone(), + SemanticId::parse("auths.gateway-operation/1").expect("contract"), + SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), + template.descriptor().to_vec(), + *template.account_commitment(), + first, + NonZeroU64::MIN, + ConnectionState::Active, + template.allowed_workloads().to_vec(), + template.allowed_profiles().to_vec(), + NOW - 100, + NOW - 100, + None, + ) + .expect("record"); + + match case { + "disabled" => record + .transition_state(ConnectionState::Disabled, NOW - 10) + .expect("disable"), + "revoked" => record + .transition_state(ConnectionState::Revoked, NOW - 10) + .expect("revoke"), + _ => record, + } +} + +async fn assert_staged_rotation( + fixture: &RotationFixture, + stale: &PersistentCredentialStore, + target: &crate::effect::CandidateCredentialTarget, + secret: &[u8], + case: &str, +) -> Value { + let RotationFixture { + credentials, + record, + engine, + .. + } = fixture; + assert_eq!(target.record().state(), record.state()); + assert_eq!( + target.record().generation().get(), + record.generation().get() + 1 + ); + assert_eq!( + target.record().credential_generation(), + target.record().generation() + ); + assert_eq!(target.previous(), Some(record)); + assert!( + credentials + .holds(&record.credential_binding()) + .await + .is_ok() + ); + assert!( + credentials + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + assert!( + stale + .holds(&target.record().credential_binding()) + .await + .is_ok(), + "a preexisting reader refreshes custody" + ); + assert!( + stale + .replace( + record.connection_id(), + record.generation(), + target.record().credential_generation(), + SecretBytes::new(b"rk_test_stale".to_vec()).expect("secret") + ) + .await + .is_err(), + "a stale writer cannot overwrite the committed candidate" + ); + let bytes = target.to_private_bytes().expect("proposal"); + let repeated = engine + .stage_candidate_rotation(zeroize::Zeroizing::new(secret.to_vec())) + .await + .expect("idempotent custody stage"); + assert_eq!(repeated.to_private_bytes().expect("repeated"), bytes); + assert!( + engine + .stage_candidate_rotation(zeroize::Zeroizing::new(b"rk_test_other".to_vec())) + .await + .is_err(), + "never overwrite a staged candidate" + ); + assert_reopened_candidate(fixture, stale, target).await; + json!({"case": case, "staged_generation": target.record().credential_generation().get(), "same_secret_idempotent": true, "different_secret_refused": true, "reopen_retains_current_and_candidate": true, "cleanup_notes_retained": true, "preexisting_reader_refreshes_custody": true, "stale_writer_cannot_overwrite": true, "completed_delete_visible_to_stale_reader": true}) +} + +async fn assert_reopened_candidate( + fixture: &RotationFixture, + stale: &PersistentCredentialStore, + target: &crate::effect::CandidateCredentialTarget, +) { + let RotationFixture { + credentials_path, + record, + journal, + .. + } = fixture; + let reopened = PersistentCredentialStore::open(credentials_path).expect("reopen"); + assert!(reopened.holds(&record.credential_binding()).await.is_ok()); + assert!( + reopened + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + let generations = reopened + .stored_generations(record.connection_id()) + .expect("generations"); + assert_eq!( + generations, + vec![ + record.credential_generation(), + target.record().credential_generation() + ] + ); + assert_eq!( + journal.generations(record.connection_id()).expect("notes"), + generations + ); + reopened + .revoke( + record.connection_id(), + target.record().credential_generation(), + ) + .await + .expect("delete staged generation"); + assert!( + stale + .holds(&target.record().credential_binding()) + .await + .is_err(), + "completed deletion is visible to a stale reader" + ); + assert!( + stale.holds(&record.credential_binding()).await.is_ok(), + "current credential remains" + ); +} + +fn installation_draft(recipe: &CompiledRecipe) -> ConnectionRecord { + let template = connection_account( + recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + + ConnectionRecord::new( + template.provider_kind().clone(), + template.alias().clone(), + template.connection_id().clone(), + template.contract().clone(), + template.descriptor_schema().clone(), + template.descriptor().to_vec(), + *template.account_commitment(), + [0; 32], + NonZeroU64::MIN, + ConnectionState::Active, + template.allowed_workloads().to_vec(), + template.allowed_profiles().to_vec(), + NOW, + NOW, + None, + ) + .expect("draft") +} + +fn installation_engine( + recipe: &CompiledRecipe, + trust: &auths_model::TrustedContext, + policy: &EffectPolicy, + draft: &ConnectionRecord, + root: &std::path::Path, + store: &Arc, + floor: &crate::GenerationFloor, +) -> crate::GatewayEngine { + crate::GatewayEngine::new( + recipe.clone(), + *recipe.digest(), + &auths_codec::encode_verifier_context(trust).expect("trust"), + policy.clone(), + draft.provider_kind().clone(), + draft.alias().clone(), + "gateway".to_owned(), + draft.allowed_profiles()[0].clone(), + Arc::new( + PersistentCredentialStore::open(root.join("credentials.cbor")) + .expect("reopened custody"), + ), + crate::GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"), + ) + .expect("engine") + .with_credential_journal(crate::CredentialJournal::new(root.to_path_buf())) + .with_generation_floor(floor.clone()) + .with_qualification(Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Optional, + None, + None, + Box::new(Arc::new(crate::FixedClock::at(NOW))), + auths_recipe_qualification::VerifierState::default(), + ))) +} + +async fn assert_staged_installation( + target: &crate::effect::CandidateCredentialTarget, + draft: &ConnectionRecord, + root: &std::path::Path, + credentials: &PersistentCredentialStore, + floor: &crate::GenerationFloor, + shared: &crate::SharedConnection, + make_engine: impl Fn() -> crate::GatewayEngine, +) -> Value { + assert!(target.previous().is_none()); + assert_eq!(target.record().generation(), NonZeroU64::MIN); + assert!( + credentials + .holds(&target.record().credential_binding()) + .await + .is_ok() + ); + floor.accept(target.record()).expect("floor exact"); + assert!( + floor.accept(draft).is_err(), + "same generation substitution refused" + ); + let bytes = target.to_private_bytes().expect("proposal"); + let reopened = make_engine(); + let reopened_before = reopened.execution_witness(); + let repeated = reopened + .stage_candidate_installation( + draft, + zeroize::Zeroizing::new(b"rk_test_first_install".to_vec()), + ) + .await + .expect("resume"); + assert_eq!( + repeated.to_private_bytes().expect("resumed proposal"), + bytes + ); + assert!( + reopened + .stage_candidate_installation(draft, zeroize::Zeroizing::new(b"rk_test_other".to_vec())) + .await + .is_err() + ); + std::fs::remove_file(root.join("connection-floor.json")).expect("lost floor"); + let refused = reopened + .compile_candidate_effect(target, &[], &[]) + .await + .expect_err("missing floor refusal"); + assert_eq!( + refused, + crate::GatewaySubmitResult::NotEntered { + code: "gateway.connection.restore-rollback".to_owned() + } + ); + assert!( + !root.join("connection-floor.json").exists(), + "runtime cannot repair floor" + ); + let restored = reopened + .stage_candidate_installation( + draft, + zeroize::Zeroizing::new(b"rk_test_first_install".to_vec()), + ) + .await + .expect("explicit operator restaging"); + assert_eq!(restored.to_private_bytes().expect("restaged"), bytes); + assert_eq!(reopened.execution_witness(), reopened_before); + assert!(shared.load().await.expect("load").is_none()); + assert_eq!( + crate::CredentialJournal::new(root.to_path_buf()) + .generations(draft.connection_id()) + .expect("notes"), + vec![NonZeroU64::MIN] + ); + json!({"case":"staged","reopened_same_draft_and_secret_exact":true,"different_secret_refused":true,"runtime_missing_floor_refused_without_repair":true,"explicit_restaging_exact":true,"connection_remains_absent":true,"cleanup_note_retained":true}) +} + +fn private_case_directory() -> (tempfile::TempDir, std::path::PathBuf) { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + } + (directory, root) +} diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index abe4077ae..186e07115 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -29,7 +29,7 @@ async fn native_candidate_compilation_fixture_is_current() { let capacity_directory = tempfile::tempdir().expect("capacity directory"); let capacity_store = std::sync::Arc::new( crate::FileGatewayAttemptStore::open( - &std::fs::canonicalize(capacity_directory.path()) + std::fs::canonicalize(capacity_directory.path()) .expect("path") .join("journal"), ) @@ -177,7 +177,7 @@ async fn native_candidate_compilation_fixture_is_current() { .expect("grant"); let submission = submission_for_call(&root, &reader, &grant, &call, &[]); if case == "rotation" { - staging_cases = staging::histories(&recipe, &trust, &policy).await; + staging_cases = Box::pin(staging::histories(&recipe, &trust, &policy)).await; } let installed = policy.installation( &recipe, @@ -286,7 +286,7 @@ async fn native_candidate_compilation_fixture_is_current() { let directory = tempfile::tempdir().expect("tempdir"); let store = std::sync::Arc::new( crate::FileGatewayAttemptStore::open( - &std::fs::canonicalize(directory.path()) + std::fs::canonicalize(directory.path()) .expect("canonical") .join("journal"), ) diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index 320082b17..b4679e904 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -3,7 +3,7 @@ use super::*; use crate::effect::{CONTENT_READ_TOOL, ContentReadTarget, compile_content_acquisition}; -fn declaration(projection: Value) -> Value { +fn declaration(projection: &Value) -> Value { json!({"schema": "auths.gateway-content-read/1", "resource_field": "record_id", "path": [{"kind": "fixed", "value": "documents"}, {"kind": "field", "name": "record_id"}], "query": [{"name": "format", "value": "text/plain"}], "projection": projection, @@ -18,7 +18,7 @@ fn content_recipe(content: Value) -> Result Value { - let original = declaration(json!({"kind": "json-string", "pointer": "/content"})); + let original = declaration(&json!({"kind": "json-string", "pointer": "/content"})); let mut cases = vec![]; for field in [ "schema", @@ -219,10 +219,10 @@ fn native_content_compilation_fixture_is_current() { json!({"kind": "utf8"}), json!({"kind": "json-string", "pointer": "/content"}), ] { - let recipe = content_recipe(declaration(projection.clone())).expect("content recipe"); + let recipe = content_recipe(declaration(&projection)).expect("content recipe"); assert_eq!( recipe.review_document()["content_acquisition"]["declaration"], - declaration(projection.clone()) + declaration(&projection) ); let connection = connection(&recipe); let target = ContentReadTarget::new(&recipe, &connection, arguments.clone()) @@ -475,7 +475,7 @@ async fn native_content_journal_fixture_is_current() { EffectPolicy::new("synthetic-content-journal".to_owned(), 1, public).expect("policy"); let (source, lock) = h::recipe_sources(&json!({}), &Value::Null).expect("source"); let mut source: Value = serde_json::from_slice(&source).expect("source JSON"); - source["content"] = declaration(json!({"kind": "utf8"})); + source["content"] = declaration(&json!({"kind": "utf8"})); source["provider_headers"] = json!({"Stripe-Version": "2024-06-20"}); let recipe = CompiledRecipe::compile(&serde_json::to_vec(&source).expect("source bytes"), &lock) @@ -681,7 +681,6 @@ async fn native_content_journal_fixture_is_current() { continue; } let headers = match index { - 0 => "Content-Type: text/plain\r\n", 1 => "Content-Type: text/plain\r\nContent-Encoding: gzip\r\n", 2 => "Content-Type: text/plain\r\nContent-Type: application/json\r\n", 3 => "", @@ -689,7 +688,7 @@ async fn native_content_journal_fixture_is_current() { "Content-Type: text/plain\r\nContent-Encoding: identity\r\nContent-Encoding: gzip\r\n" } 5 => "Content-Type: application/json\r\n", - 6..=12 | 14 => "Content-Type: text/plain\r\n", + 0 | 6..=12 | 14 => "Content-Type: text/plain\r\n", 13 => "Content-Type: text/plain\r\nContent-Encoding: identity\r\n", _ => unreachable!(), }; @@ -771,7 +770,9 @@ async fn native_content_journal_fixture_is_current() { let value: Value = serde_json::from_slice(&retained).expect("record JSON"); let phase = &value["state"]["facts"]["phase"]; let metadata = &phase["metadata"]; - if index != 6 { + if index == 6 { + assert_eq!(phase["stage"], "unknown"); + } else { assert_eq!(phase["stage"], "content-response-recorded"); let expected_media = match index { 2 => json!({"kind": "invalid"}), @@ -808,8 +809,6 @@ async fn native_content_journal_fixture_is_current() { store .replace(crate::GatewayRecordKind::Attempt, &key, &changed, &retained) .expect("restore fixture"); - } else { - assert_eq!(phase["stage"], "unknown"); } let history_operation = LogicalOperationId::parse(&format!("content-journal-{index}")).expect("operation"); @@ -849,19 +848,19 @@ async fn native_content_journal_fixture_is_current() { let retained_source = retained_source.expect("validated source"); assert_eq!(retained_source.bytes, expected_body.len() as u64); if index == 0 { - disclosure_journal = super::disclosure_journal_tests::corpus( + disclosure_journal = Box::pin(super::disclosure_journal_tests::corpus( retained_source.clone(), &recipe, &record, &policy, &store, &path, - ) + )) .await; } if matches!(index, 0 | 9) { disclosures.push(disclosure_compilation_cases( - retained_source, + &retained_source, &recipe, &record, &policy, @@ -884,8 +883,8 @@ async fn native_content_journal_fixture_is_current() { "/state/facts/phase/metadata/media_type/value", ] { let mut changed = value.clone(); - let cell = changed.pointer_mut(pointer).expect("field"); - *cell = match pointer { + let field_value = changed.pointer_mut(pointer).expect("field"); + *field_value = match pointer { "/schema" => json!("auths.gateway-attempt/13"), "/state/facts/phase/content/value/schema" => { json!("auths.gateway-protected-content/0") @@ -895,7 +894,7 @@ async fn native_content_journal_fixture_is_current() { } "/state/facts/phase/response/version_ok" => json!(false), "/state/facts/phase/metadata/media_type/value" => json!("application/json"), - _ => json!(cell.as_u64().expect("number") ^ 1), + _ => json!(field_value.as_u64().expect("number") ^ 1), }; let bytes = serde_json_canonicalizer::to_vec(&changed).expect("changed bytes"); store @@ -997,7 +996,7 @@ async fn native_content_journal_fixture_is_current() { reason = "one native disclosure compilation corpus over validated retained content" )] fn disclosure_compilation_cases( - retained: crate::RetainedContent, + retained: &crate::RetainedContent, recipe: &CompiledRecipe, connection: &ConnectionRecord, policy: &EffectPolicy, diff --git a/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs index 164674879..16cb5945a 100644 --- a/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs +++ b/product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs @@ -1,5 +1,5 @@ //! Real local sockets over the native installed file fence. Same-process UID -//! checks do not establish independent-process isolation or PostgreSQL evidence. +//! checks do not establish independent-process isolation or `PostgreSQL` evidence. use super::*; use crate::disclosure_transport::{ AuthenticatedDisclosureChannel, DisclosureConnection, ReceivedDisclosure, deliver, @@ -53,7 +53,7 @@ async fn authenticate( match crate::app::receive_content_disclosure(client, &request, &binding, bytes, &client_key) .await? { - crate::app::AppDisclosureReception::Received(received) => Ok(received), + crate::app::AppDisclosureReception::Received(delivery) => Ok(*delivery), _ => Err("test.unexpected-history"), } }); @@ -155,15 +155,15 @@ pub(super) async fn corpus( .await .expect("grant"); let receive_and_ack = async { - let received = receiver.await.expect("receiver task").expect("delivery"); - assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); - assert_eq!(received.content().len() as u64, bytes); + let delivery = receiver.await.expect("receiver task").expect("delivery"); + assert_eq!(delivery.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + assert_eq!(delivery.content().len() as u64, bytes); assert!( - received + delivery .acknowledgement(&SigningKey::from_bytes(&[52; 32])) .is_err() ); - received.acknowledge(recipient).await.expect("ACK send"); + delivery.acknowledge(recipient).await.expect("ACK send"); }; let (ack, ()) = tokio::join!(deliver(permit), receive_and_ack); let ack = ack.expect("received ACK"); @@ -231,9 +231,9 @@ pub(super) async fn corpus( .await .expect("grant"); let lose_ack = async { - let received = receiver.await.expect("receiver task").expect("delivery"); - assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); - received + let delivery = receiver.await.expect("receiver task").expect("delivery"); + assert_eq!(delivery.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + delivery .acknowledgement(recipient) .expect("retain late ACK") // Owned client socket drops without sending its ACK. @@ -359,9 +359,9 @@ pub(super) async fn corpus( }; assert!(loser.await.expect("losing receiver").is_err()); let receive = async { - let received = winner.await.expect("winner").expect("one delivery"); - assert_eq!(received.content(), b"PRIVATE-SYNTHETIC-CONTENT"); - received.acknowledge(recipient).await.expect("ACK"); + let delivery = winner.await.expect("winner").expect("one delivery"); + assert_eq!(delivery.content(), b"PRIVATE-SYNTHETIC-CONTENT"); + delivery.acknowledge(recipient).await.expect("ACK"); }; let (ack, ()) = tokio::join!(deliver(permit), receive); let raced_snapshot = attempts @@ -581,7 +581,7 @@ async fn authentication_failures( client.write_u32(4097).await.expect("oversized header"); } else { client - .write_u32(response.len() as u32) + .write_u32(u32::try_from(response.len()).expect("bounded frame")) .await .expect("length"); client.write_all(&response).await.expect("response"); diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 3198e269a..b4e17d35b 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -619,7 +619,7 @@ async fn exercise_recovery_journal( } /// Signed read effects and durable file records with synthetic provider bodies. -/// No installed authority, network or PostgreSQL claim is made by this corpus. +/// No installed authority, network or `PostgreSQL` claim is made by this corpus. #[allow( clippy::too_many_lines, reason = "one native evidence history and its refusal matrix" @@ -922,57 +922,10 @@ fn connection_account(recipe: &CompiledRecipe, account: [u8; 32]) -> ConnectionR .expect("connection") } -#[test] -fn native_compilation_approval_and_reverification_keep_exact_request() { - let root = signer(h::ROOT_SEED); - let agent = signer(0x22); - let observer = signer(h::OBSERVER_SEED); - let recipe = recipe( - &json!({ - "replacement": {"kind": "string", "minimum": 1, "maximum": 64} - }), - &Value::Null, - ); - let context = context(&root, &observer.principal, None); - let connection = connection(&recipe); - let arguments = json!({ - "operation_id": "bound-native-1", "operator_namespace": NAMESPACE, - "recipe_digest": recipe.digest_hex(), "record_id": RECORD, - "replacement": "private-sentinel-\u{202e}Approved" - }) - .as_object() - .expect("arguments") - .clone(); - let grant = grant(&root, &agent, None); - let submission = submission(&root, &agent, &grant, &arguments, &[]); - let key = SigningKey::from_bytes(&[29; 32]); - let public = key.verifying_key().to_bytes(); - let policy = EffectPolicy::new("synthetic-partition".to_owned(), 1, public) - .expect("installed effect policy"); - let policy_bytes = policy.to_private_bytes().expect("policy bytes"); - assert_eq!( - EffectPolicy::from_private_bytes(&policy_bytes).expect("policy"), - policy - ); - let installed = policy.installation( - &recipe, - &context, - &connection, - crate::QualificationPolicy::Optional, - [12; 32], - ); - let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) - .expect("native effect"); - let later = compile_mutation_effect(&installed, NOW + 1, &submission.proof, &submission.action) - .expect("fresh native effect"); - assert_eq!( - effect.binding(), - later.binding(), - "evaluation time is not signed event time" - ); - let expected = recipe - .closed_request_from_arguments(&arguments, submission.commitment) - .expect("compiler output"); +fn assert_compiled_request( + effect: &crate::effect::BoundEffect, + expected: &crate::ClosedProviderRequest, +) { assert_eq!( effect.private_request().expect("mutation request").body(), expected.body() @@ -988,7 +941,47 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .headers(), expected.headers() ); - let bytes = effect.binding().to_private_bytes().expect("binding bytes"); +} + +fn assert_effect_fixtures( + fixture: &[u8], + policy_bytes: &[u8], + signing_request: &[u8], + approval_bytes: &[u8], +) { + let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/effect-binding.json"); + let policy_path = fixture_path.with_file_name("effect-policy.json"); + let request_path = fixture_path.with_file_name("effect-approval-request.json"); + let approval_path = fixture_path.with_file_name("effect-approval.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { + std::fs::write(&fixture_path, fixture).expect("write native fixture"); + std::fs::write(&policy_path, policy_bytes).expect("write native policy fixture"); + std::fs::write(&request_path, signing_request).expect("write native signing fixture"); + std::fs::write(&approval_path, approval_bytes).expect("write native approval fixture"); + } + assert_eq!( + std::fs::read(&approval_path).expect("approval fixture"), + approval_bytes + ); + assert_eq!( + std::fs::read(&policy_path).expect("policy fixture"), + policy_bytes + ); + assert_eq!( + std::fs::read(&request_path).expect("signing fixture"), + signing_request + ); + assert_eq!( + std::fs::read(&fixture_path).expect("native fixture"), + fixture + ); +} + +fn assert_complete_private_review( + effect: &crate::effect::BoundEffect, + expected: &crate::ClosedProviderRequest, +) -> (Value, zeroize::Zeroizing) { let private_review = effect.private_review().expect("native private review"); let review_bytes = private_review.to_private_bytes().expect("review JSON"); let review_json: Value = serde_json::from_slice(&review_bytes).expect("review JSON"); @@ -1024,29 +1017,64 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { .is_err() ); assert!(!format!("{private_review:?}").contains("private-sentinel")); + (review_json, literal) +} + +#[test] +fn native_compilation_approval_and_reverification_keep_exact_request() { + let root = signer(h::ROOT_SEED); + let agent = signer(0x22); + let observer = signer(h::OBSERVER_SEED); + let recipe = recipe( + &json!({ + "replacement": {"kind": "string", "minimum": 1, "maximum": 64} + }), + &Value::Null, + ); + let context = context(&root, &observer.principal, None); + let connection = connection(&recipe); + let arguments = json!({ + "operation_id": "bound-native-1", "operator_namespace": NAMESPACE, + "recipe_digest": recipe.digest_hex(), "record_id": RECORD, + "replacement": "private-sentinel-\u{202e}Approved" + }) + .as_object() + .expect("arguments") + .clone(); + let grant = grant(&root, &agent, None); + let submission = submission(&root, &agent, &grant, &arguments, &[]); + let key = SigningKey::from_bytes(&[29; 32]); + let public = key.verifying_key().to_bytes(); + let policy = EffectPolicy::new("synthetic-partition".to_owned(), 1, public) + .expect("installed effect policy"); + let policy_bytes = policy.to_private_bytes().expect("policy bytes"); assert_eq!( - &EffectBinding::from_private_bytes(&bytes).expect("binding data"), - effect.binding() + EffectPolicy::from_private_bytes(&policy_bytes).expect("policy"), + policy ); - assert!( - !String::from_utf8(bytes.to_vec()) - .expect("json") - .contains("private-sentinel") + let installed = policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], ); - assert!(!format!("{effect:?}").contains("private-sentinel")); - let review = effect.approval_request(NOW, NOW + 30).expect("review"); - let signature = key - .sign(&review.signing_message().expect("native message")) - .to_bytes(); - let signing_request = review - .to_private_bytes() - .expect("canonical signing request"); + let effect = compile_mutation_effect(&installed, NOW, &submission.proof, &submission.action) + .expect("native effect"); + let later = compile_mutation_effect(&installed, NOW + 1, &submission.proof, &submission.action) + .expect("fresh native effect"); assert_eq!( - crate::effect::EffectApprovalRequest::from_private_bytes(&signing_request) - .expect("signing data"), - review + effect.binding(), + later.binding(), + "evaluation time is not signed event time" ); - let approval = review.with_signature(signature); + let expected = recipe + .closed_request_from_arguments(&arguments, submission.commitment) + .expect("compiler output"); + assert_compiled_request(&effect, &expected); + let bytes = effect.binding().to_private_bytes().expect("binding bytes"); + let (review_json, literal) = assert_complete_private_review(&effect, &expected); + let (approval, signing_request) = assert_bound_approval(&effect, &bytes, &key); let frame = crate::app::AppSubmission { schema: crate::app::APP_REQUEST_SCHEMA.to_owned(), proof_b64: base64ct::Base64UrlUnpadded::encode_string(&submission.proof), @@ -1072,34 +1100,33 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { "approval_expires_at": NOW + 30, "submission_frame_canonical": String::from_utf8(serde_json_canonicalizer::to_vec(&frame).expect("native frame")).expect("UTF-8"), })).expect("fixture JSON"); - let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) - .join("../../../bindings/fixtures/gateway/effect-binding.json"); - let policy_path = fixture_path.with_file_name("effect-policy.json"); - let request_path = fixture_path.with_file_name("effect-approval-request.json"); - let approval_path = fixture_path.with_file_name("effect-approval.json"); - let approval_bytes = approval.to_private_bytes().expect("approval bytes"); - if std::env::var_os("AUTHS_UPDATE_FIXTURES").as_deref() == Some(std::ffi::OsStr::new("1")) { - std::fs::write(&fixture_path, &fixture).expect("write native fixture"); - std::fs::write(&policy_path, &policy_bytes).expect("write native policy fixture"); - std::fs::write(&request_path, &signing_request).expect("write native signing fixture"); - std::fs::write(&approval_path, &approval_bytes).expect("write native approval fixture"); - } - assert_eq!( - std::fs::read(&approval_path).expect("approval fixture"), - *approval_bytes - ); - assert_eq!( - std::fs::read(&policy_path).expect("policy fixture"), - *policy_bytes - ); - assert_eq!( - std::fs::read(&request_path).expect("signing fixture"), - *signing_request + assert_effect_fixtures( + &fixture, + &policy_bytes, + &signing_request, + &approval.to_private_bytes().expect("approval bytes"), ); - assert_eq!( - std::fs::read(&fixture_path).expect("native fixture"), - fixture + assert_approval_entry( + effect, + later, + &installed, + &key, + approval, + &expected, + (&submission.proof, &submission.action), ); +} + +fn assert_approval_entry( + effect: crate::effect::BoundEffect, + later: crate::effect::BoundEffect, + installed: &EffectInstallation<'_>, + key: &SigningKey, + approval: crate::effect::ExactEffectApproval, + expected: &crate::ClosedProviderRequest, + submission: (&[u8], &[u8]), +) { + let public = key.verifying_key().to_bytes(); let approved = effect .approve(approval.clone(), &public, NOW) .expect("exact approval"); @@ -1113,8 +1140,8 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { ); assert!(approved.validate_approval(&public, NOW + 29).is_ok()); assert!(approved.validate_approval(&public, NOW + 30).is_err()); - assert!(approved.validate_for_entry(&installed, NOW + 29).is_ok()); - assert!(approved.validate_for_entry(&installed, NOW + 30).is_err()); + assert!(approved.validate_for_entry(installed, NOW + 29).is_ok()); + assert!(approved.validate_for_entry(installed, NOW + 30).is_err()); let late_request = later .approval_request(NOW + 3_570, NOW + 3_605) .expect("approval spanning native action expiry"); @@ -1128,23 +1155,52 @@ fn native_compilation_approval_and_reverification_keep_exact_request() { NOW + 3_570, ) .expect("late approval"); - assert!(late.validate_for_entry(&installed, NOW + 3_599).is_ok()); + assert!(late.validate_for_entry(installed, NOW + 3_599).is_ok()); assert!(late.validate_approval(&public, NOW + 3_601).is_ok()); assert!( - late.validate_for_entry(&installed, NOW + 3_601).is_err(), + late.validate_for_entry(installed, NOW + 3_601).is_err(), "a current human approval must not revive expired native resource authority" ); let changed_installation = EffectInstallation { epoch: 2, - ..installed + ..*installed }; - let changed = compile_mutation_effect( - &changed_installation, - NOW, - &submission.proof, - &submission.action, - ) - .expect("changed epoch"); + let changed = compile_mutation_effect(&changed_installation, NOW, submission.0, submission.1) + .expect("changed epoch"); assert!(changed.approve(approval, &public, NOW).is_err()); - assert!(compile_mutation_effect(&changed_installation, NOW, &[], &submission.action).is_err()); + assert!(compile_mutation_effect(&changed_installation, NOW, &[], submission.1).is_err()); +} + +fn assert_bound_approval( + effect: &crate::effect::BoundEffect, + bytes: &[u8], + key: &SigningKey, +) -> ( + crate::effect::ExactEffectApproval, + zeroize::Zeroizing>, +) { + assert_eq!( + &EffectBinding::from_private_bytes(bytes).expect("binding data"), + effect.binding() + ); + assert!( + !String::from_utf8(bytes.to_vec()) + .expect("json") + .contains("private-sentinel") + ); + assert!(!format!("{effect:?}").contains("private-sentinel")); + let review = effect.approval_request(NOW, NOW + 30).expect("review"); + let signature = key + .sign(&review.signing_message().expect("native message")) + .to_bytes(); + let signing_request = review + .to_private_bytes() + .expect("canonical signing request"); + assert_eq!( + crate::effect::EffectApprovalRequest::from_private_bytes(&signing_request) + .expect("signing data"), + review + ); + let approval = review.with_signature(signature); + (approval, signing_request) } diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 5bc827f8d..257c70f9c 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -2,6 +2,9 @@ //! This fixture does not claim durable acquisition admission or provider entry. use super::*; +use crate::entry::EntryValidation; +use crate::{AcquisitionClaim, AcquisitionStage, GatewayAttempts}; +use std::sync::Arc; #[tokio::test] #[allow( @@ -255,8 +258,8 @@ async fn journal_witness( policy: &EffectPolicy, recipe: &str, ) -> Value { + use crate::GatewayAttempts; use crate::entry::EntryValidation; - use crate::{AcquisitionClaim, AcquisitionStage, GatewayAttempts}; use std::sync::Arc; let plans = approved.prerequisite_plans().expect("closed plans"); let mut histories = Vec::new(); @@ -286,122 +289,9 @@ async fn journal_witness( }; let mut snapshots = Vec::new(); for plan in plans.iter().filter(|_| history != "missing-read") { - let kind = plan.kind().expect("closed purpose"); - let capacity = plan - .validate(approved.effect().binding()) - .expect("membership"); - assert_eq!(capacity.attempts, 1); - let mut corrupted = serde_json::to_value(plan).expect("plan audit"); - corrupted["transport_canonical"] = json!("{}"); - let corrupted: crate::effect::PrerequisitePlan = - serde_json::from_value(corrupted).expect("audit only"); - assert!(corrupted.validate(approved.effect().binding()).is_err()); - let AcquisitionClaim::Reserved(reserved) = attempts - .claim_prerequisite( - approved, - kind, - NOW, - crate::entry::EntryValidation::Oracle { now: NOW }, - ) - .await - .expect("read claim") - else { - panic!("reserved") - }; - let AcquisitionClaim::Reserved(stale) = attempts - .claim_prerequisite( - approved, - kind, - NOW, - crate::entry::EntryValidation::Oracle { now: NOW }, - ) - .await - .expect("equal reservation") - else { - panic!("equal reservation") - }; - assert_eq!( - reserved.snapshot().expect("snapshot"), - stale.snapshot().expect("snapshot") - ); - let (granted, permit) = reserved - .grant_entry( - Arc::clone(approved), - EntryValidation::Oracle { now: NOW }, - NOW, - ) - .await - .expect("read grant"); - assert!(matches!( - permit.request(), - crate::store::AcquisitionRequest::Prerequisite(_) - )); - drop(permit); - assert!( - stale - .grant_entry( - Arc::clone(approved), - EntryValidation::Oracle { now: NOW }, - NOW - ) - .await - .is_err() + snapshots.push( + prerequisite_history(approved, policy, &path, &attempts, plan, lose_permit).await, ); - if lose_permit { - drop(granted); - } else { - granted - .record_response(200, true, b"{}", NOW + 1) - .await - .expect("retained synthetic response"); - let response = attempts - .read_prerequisite(approved, kind, NOW + 2) - .await - .expect("fresh response"); - assert_eq!(response.received_at, NOW + 1); - assert_eq!(response.observed_at, NOW); - assert!( - attempts - .read_prerequisite(approved, kind, NOW) - .await - .is_err(), - "future response cannot be fresh" - ); - assert!( - attempts - .read_prerequisite(approved, kind, NOW + 32) - .await - .is_err() - ); - } - let reopened = GatewayAttempts::new( - Arc::new(crate::FileGatewayAttemptStore::open(&path).expect("reopen journal")), - policy.clone(), - ) - .expect("reopened attempts"); - let AcquisitionClaim::Existing(snapshot) = reopened - .claim_prerequisite( - approved, - kind, - NOW + 2, - crate::entry::EntryValidation::Oracle { now: NOW + 2 }, - ) - .await - .expect("replay") - else { - panic!("no second permit") - }; - assert_eq!( - snapshot.stage, - if lose_permit { - AcquisitionStage::Unknown - } else { - AcquisitionStage::ResponseRecorded - } - ); - assert_eq!(snapshot.reserved_calls, 1); - assert_eq!(snapshot.reserved_bytes, capacity.maximum_bytes); - snapshots.push(json!(snapshot)); } let grant = parent .grant_entry( @@ -588,7 +478,7 @@ fn native_prerequisite_evidence_fixture_is_current() { .expect("wrong subject signature") .bytes() .to_vec(), - ] + ]; } "wrong-observer" => { checkpoint.observations = vec![ @@ -602,7 +492,7 @@ fn native_prerequisite_evidence_fixture_is_current() { .expect("other signature") .bytes() .to_vec(), - ] + ]; } "signature-changed" => { let signed = auths_codec::decode_signed_observation( @@ -630,7 +520,7 @@ fn native_prerequisite_evidence_fixture_is_current() { .push(checkpoint.observations[0].clone()), "duplicate-provider-member" => { response.body = - br#"{"fields":{"DemoStatus":"Pending","DemoStatus":"Approved"}}"#.to_vec() + br#"{"fields":{"DemoStatus":"Pending","DemoStatus":"Approved"}}"#.to_vec(); } "wrong-status" => response.status = 403, "wrong-version" => response.version_ok = false, @@ -639,7 +529,7 @@ fn native_prerequisite_evidence_fixture_is_current() { value: 1, response_digest: [0; 32], read_at: NOW, - }) + }); } _ => {} } @@ -747,12 +637,13 @@ fn guard_evidence_fixture( "account-mismatch" => acquired[0].response.body = br#"{"id":"acct_WRONG"}"#.to_vec(), "duplicate-account" => { acquired[0].response.body = - br#"{"id":"acct_WRONG","id":"acct_TESTACCOUNT01"}"#.to_vec() + br#"{"id":"acct_WRONG","id":"acct_TESTACCOUNT01"}"#.to_vec(); } "capability-excess" => acquired[1].response.status = 200, "denied-version" => acquired[2].response.version_ok = false, "currency-mismatch" => { - acquired[3].response.body = br#"{"amount_received":1000,"currency":"eur"}"#.to_vec() + acquired[3].response.body = + br#"{"amount_received":1000,"currency":"eur"}"#.to_vec(); } "above-ceiling" => { acquired[3].response.body = br#"{"amount_received":900,"currency":"usd"}"#.to_vec(); @@ -766,7 +657,7 @@ fn guard_evidence_fixture( "missing-basis" => checkpoint.basis = None, "duplicate-basis" => { acquired[3].response.body = - br#"{"amount_received":0,"amount_received":1000,"currency":"usd"}"#.to_vec() + br#"{"amount_received":0,"amount_received":1000,"currency":"usd"}"#.to_vec(); } "wrong-order" => acquired.swap(0, 1), "missing-read" => { @@ -799,3 +690,148 @@ fn guard_evidence_fixture( } assert_eq!(std::fs::read(path).expect("fixture"), bytes); } +async fn prerequisite_history( + approved: &std::sync::Arc, + policy: &EffectPolicy, + path: &std::path::Path, + attempts: &crate::GatewayAttempts, + plan: &crate::effect::PrerequisitePlan, + lose_permit: bool, +) -> Value { + let kind = plan.kind().expect("closed purpose"); + let capacity = plan + .validate(approved.effect().binding()) + .expect("membership"); + assert_eq!(capacity.attempts, 1); + assert_prerequisite_membership(plan, approved); + let AcquisitionClaim::Reserved(reserved) = attempts + .claim_prerequisite( + approved, + kind, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await + .expect("read claim") + else { + panic!("reserved") + }; + let AcquisitionClaim::Reserved(stale) = attempts + .claim_prerequisite( + approved, + kind, + NOW, + crate::entry::EntryValidation::Oracle { now: NOW }, + ) + .await + .expect("equal reservation") + else { + panic!("equal reservation") + }; + assert_eq!( + reserved.snapshot().expect("snapshot"), + stale.snapshot().expect("snapshot") + ); + let (granted, permit) = reserved + .grant_entry( + Arc::clone(approved), + EntryValidation::Oracle { now: NOW }, + NOW, + ) + .await + .expect("read grant"); + assert!(matches!( + permit.request(), + crate::store::AcquisitionRequest::Prerequisite(_) + )); + drop(permit); + assert!( + stale + .grant_entry( + Arc::clone(approved), + EntryValidation::Oracle { now: NOW }, + NOW + ) + .await + .is_err() + ); + if lose_permit { + drop(granted); + } else { + record_prerequisite_response( + granted.record_response(200, true, b"{}", NOW + 1), + attempts, + approved, + kind, + ) + .await; + } + let reopened = GatewayAttempts::new( + Arc::new(crate::FileGatewayAttemptStore::open(path).expect("reopen journal")), + policy.clone(), + ) + .expect("reopened attempts"); + let AcquisitionClaim::Existing(snapshot) = reopened + .claim_prerequisite( + approved, + kind, + NOW + 2, + crate::entry::EntryValidation::Oracle { now: NOW + 2 }, + ) + .await + .expect("replay") + else { + panic!("no second permit") + }; + assert_eq!( + snapshot.stage, + if lose_permit { + AcquisitionStage::Unknown + } else { + AcquisitionStage::ResponseRecorded + } + ); + assert_eq!(snapshot.reserved_calls, 1); + assert_eq!(snapshot.reserved_bytes, capacity.maximum_bytes); + json!(snapshot) +} +async fn record_prerequisite_response( + response: impl std::future::Future< + Output = Result, + >, + attempts: &crate::GatewayAttempts, + approved: &std::sync::Arc, + kind: crate::effect::PrerequisiteKind, +) { + response.await.expect("retained synthetic response"); + let response = attempts + .read_prerequisite(approved, kind, NOW + 2) + .await + .expect("fresh response"); + assert_eq!(response.received_at, NOW + 1); + assert_eq!(response.observed_at, NOW); + assert!( + attempts + .read_prerequisite(approved, kind, NOW) + .await + .is_err(), + "future response cannot be fresh" + ); + assert!( + attempts + .read_prerequisite(approved, kind, NOW + 32) + .await + .is_err() + ); +} + +fn assert_prerequisite_membership( + plan: &crate::effect::PrerequisitePlan, + approved: &crate::effect::ApprovedEffect, +) { + let mut corrupted = serde_json::to_value(plan).expect("plan audit"); + corrupted["transport_canonical"] = json!("{}"); + let corrupted: crate::effect::PrerequisitePlan = + serde_json::from_value(corrupted).expect("audit only"); + assert!(corrupted.validate(approved.effect().binding()).is_err()); +} diff --git a/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs index 98a403765..fafbd5664 100644 --- a/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs @@ -5,6 +5,7 @@ use crate::effect::{ApprovedEffect, PrerequisiteKind, compile_recovery_acquisiti use crate::entry::EntryValidation::Oracle; use crate::store::BoundedClaim; use crate::{AcquisitionClaim, AcquisitionStage, GatewayAttempts}; +use sha2::Digest as _; use std::sync::Arc; #[allow( @@ -87,7 +88,6 @@ pub(super) async fn fixture( .expect("observation template") .extract_locator(body) .expect("source locator"); - use sha2::Digest as _; granted_source .record_response(200, sha2::Sha256::digest(body).into(), Some(locator)) .await diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 5351c251c..e26d4c07f 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -2876,7 +2876,7 @@ pub(crate) mod tests { /// One gateway process: its own credential store over the shared /// attempt store. pub(crate) struct Host { - _state: tempfile::TempDir, + state_directory: tempfile::TempDir, credentials_directory: std::path::PathBuf, pub(crate) engine: GatewayEngine, pub(crate) leases: Arc, @@ -2970,7 +2970,7 @@ pub(crate) mod tests { let mut engine = engine; engine.retirement_delay = Duration::ZERO; Host { - _state: state, + state_directory: state, credentials_directory, engine, leases, @@ -3108,7 +3108,7 @@ pub(crate) mod tests { ) -> Result { crate::join_connection( &self.engine.connection, - &crate::CredentialJournal::new(self._state.path().to_path_buf()), + &crate::CredentialJournal::new(self.state_directory.path().to_path_buf()), &*self.engine.credentials, &self.engine.recipe, &candidate(secret), @@ -3162,13 +3162,16 @@ pub(crate) mod tests { #[tokio::test] async fn a_restored_store_below_the_host_floor_cannot_lease_after_restart() { - restored_store_floor(crate::store_testkit::Backend::File).await; + Box::pin(restored_store_floor(crate::store_testkit::Backend::File)).await; } #[tokio::test] #[ignore = "requires the TLS PostgreSQL fixture"] async fn postgres_restore_below_the_host_floor_cannot_lease_after_restart() { - restored_store_floor(crate::store_testkit::Backend::Postgres).await; + Box::pin(restored_store_floor( + crate::store_testkit::Backend::Postgres, + )) + .await; } async fn restored_store_floor(backend: crate::store_testkit::Backend) { diff --git a/product/runtime/auths-gateway/src/entry.rs b/product/runtime/auths-gateway/src/entry.rs index ff59273af..1adb8168b 100644 --- a/product/runtime/auths-gateway/src/entry.rs +++ b/product/runtime/auths-gateway/src/entry.rs @@ -126,9 +126,9 @@ impl EntryValidation { if target.final_kind() != primary.kind || primary.observed_at > primary.received_at || primary.received_at > now - || !now + || now .checked_sub(primary.observed_at) - .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + .is_none_or(|age| age > crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) { return Err(invalid); } @@ -282,9 +282,9 @@ pub(crate) fn validate_prerequisite_evidence( if plan.kind().map_err(|_| invalid)? != evidence.kind || evidence.observed_at > evidence.received_at || evidence.received_at > now - || !now + || now .checked_sub(evidence.observed_at) - .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + .is_none_or(|age| age > crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) { return Err(invalid); } diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index e4fea48a9..c73c93340 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -768,7 +768,7 @@ fn admission_batch_contract(store: &dyn GatewayAttemptStore) -> serde_json::Valu /// A writer holds the common fence while admission starts. The decision must /// observe the writer's committed dependency, never its earlier value. -fn admission_dependency_order(store: Arc) -> serde_json::Value { +fn admission_dependency_order(store: &Arc) -> serde_json::Value { use std::sync::mpsc; use std::time::Duration; let dependency = ( @@ -785,7 +785,7 @@ fn admission_dependency_order(store: Arc) -> serde_json .expect("dependency"); let (locked_tx, locked_rx) = mpsc::channel(); let (release_tx, release_rx) = mpsc::channel(); - let writer_store = Arc::clone(&store); + let writer_store = Arc::clone(store); let writer = std::thread::spawn(move || { writer_store.fenced_replace(&[dependency], &mut |snapshots| { assert_eq!(snapshots, &[Some(b"current".to_vec())]); @@ -800,7 +800,7 @@ fn admission_dependency_order(store: Arc) -> serde_json .recv_timeout(Duration::from_secs(1)) .expect("writer locked"); let (started_tx, started_rx) = mpsc::channel(); - let admission_store = Arc::clone(&store); + let admission_store = Arc::clone(store); let claim_key = GatewayAttemptKey([196; 32]); let charge_key = GatewayAttemptKey([197; 32]); let admission = std::thread::spawn(move || { @@ -856,7 +856,7 @@ async fn native_admission_fixture_is_current() { let (mechanism, dependency_order) = tokio::task::spawn_blocking(move || { ( admission_batch_contract(&*raw), - admission_dependency_order(raw), + admission_dependency_order(&raw), ) }) .await @@ -884,7 +884,7 @@ async fn postgres_admission_checks_authority_before_atomic_charges() { let raw = store.raw(); tokio::task::spawn_blocking(move || { admission_batch_contract(&*raw); - admission_dependency_order(raw); + admission_dependency_order(&raw); }) .await .expect("contract"); diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 00dd4bfbc..04db3b28e 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -857,20 +857,19 @@ impl SubmitIo for HarnessIo<'_> { let effect = crate::effect::compile_mutation_effect(&installed, now, self.proof, self.action)?; let key = SigningKey::from_bytes(&[29; 32]); - let approval = match &self.approval { - Some(approval) => approval.clone(), - None => { - let request = effect - .approval_request( - now, - now.saturating_add(crate::effect::MAX_EFFECT_APPROVAL_SECONDS), - ) - .map_err(|_| invalid())?; - let signature = key - .sign(&request.signing_message().map_err(|_| invalid())?) - .to_bytes(); - request.with_signature(signature) - } + let approval = if let Some(approval) = &self.approval { + approval.clone() + } else { + let request = effect + .approval_request( + now, + now.saturating_add(crate::effect::MAX_EFFECT_APPROVAL_SECONDS), + ) + .map_err(|_| invalid())?; + let signature = key + .sign(&request.signing_message().map_err(|_| invalid())?) + .to_bytes(); + request.with_signature(signature) }; effect .approve(approval, &key.verifying_key().to_bytes(), now) diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index a4f75337d..ba80767e2 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -470,7 +470,7 @@ fn entry_and_recovery_cases() -> Vec { json!({"crash": "after-write-before-response", "replay": "same-binding"}), &["reserved", "entry-granted"], None, - &counts(1, 0, 1, 0), + &counts(1, 0, 0, 1), ), ] } diff --git a/product/runtime/auths-gateway/src/pending_vectors/codes.rs b/product/runtime/auths-gateway/src/pending_vectors/codes.rs index 707f737fa..1b85e9257 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/codes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/codes.rs @@ -97,10 +97,9 @@ const ROWS: &[&str] = &[ "gateway.relative-ceiling.above engine recorded new 3 A:relative-ceiling-above", "gateway.relative-ceiling.binding-mismatch engine recorded new 3 A:relative-binding-mismatch", "gateway.relative-ceiling.unavailable engine recorded new 3 A:relative-basis-unavailable", - "gateway.transport.not-entered engine recorded new 3 A:transport-not-entered", + "gateway.transport.not-entered engine recorded new 3 -", "gateway.trust.key-aliased install install-and-serve new 5 -", "gateway.trust.observer-key-in-authority-chain engine before-claim new 5 -", - "gateway.observer.credential-guard observer observe new 3 -", "gateway.admin.candidate-approval-required admin admin new 74 -", "gateway.admin.credential-account admin admin new 3 -", "gateway.admin.credential-capability admin admin new 3 -", diff --git a/product/runtime/auths-gateway/src/pending_vectors/production.rs b/product/runtime/auths-gateway/src/pending_vectors/production.rs index b87d4b6d3..774b443e3 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/production.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/production.rs @@ -939,13 +939,19 @@ fn recipes_cannot_select_custody_or_declare_qualification() { } } -/// A submission frame carries a proof and an action and nothing else. +/// A submission frame carries only native proof, action and exact approval. #[cfg(unix)] #[test] fn submission_frames_cannot_select_custody() { use crate::app::{APP_REQUEST_SCHEMA, AppSubmission}; let corpus = load(CUSTODY_FILE); - let base = json!({"schema": APP_REQUEST_SCHEMA, "proof_b64": "AA", "action_b64": "AA"}); + let base: Value = serde_json::from_str( + load("effect-binding.json")["submission_frame_canonical"] + .as_str() + .expect("native submission"), + ) + .expect("native frame"); + assert_eq!(base["schema"], APP_REQUEST_SCHEMA); assert!(serde_json::from_value::(base.clone()).is_ok()); for case in corpus["frame_selection"].as_array().expect("frames") { let mut frame = base.clone(); diff --git a/product/runtime/auths-gateway/src/prerequisite_race_tests.rs b/product/runtime/auths-gateway/src/prerequisite_race_tests.rs new file mode 100644 index 000000000..c55927d03 --- /dev/null +++ b/product/runtime/auths-gateway/src/prerequisite_race_tests.rs @@ -0,0 +1,129 @@ +//! A paused provider response exposes the shared-reservation race deterministically. +//! Native projection is a test oracle; journal entries and one-use permits are real. +use super::*; +use tokio::sync::Notify; + +struct HeldFirstCredentialRead<'a, P> { + provider: &'a P, + entered: Notify, + release: Notify, + pending: AtomicBool, +} + +impl ProviderPort for HeldFirstCredentialRead<'_, P> { + async fn write( + &self, + permit: crate::store::ProviderEntryPermit, + ) -> Result { + self.provider.write(permit).await + } + + async fn action_read( + &self, + url: &str, + headers: &[RequestHeader], + maximum: usize, + ) -> Option { + self.provider.action_read(url, headers, maximum).await + } + + async fn credential_read(&self, read: &ClosedCredentialRead) -> Option { + if self.pending.swap(false, Ordering::SeqCst) { + self.entered.notify_one(); + self.release.notified().await; + } + self.provider.credential_read(read).await + } +} + +async fn pending_read_keeps_parent_reserved(backend: Backend) { + let family = Family::Stripe; + let recipe = family.recipe(); + let provider = OracleProvider { + inner: TableProvider::new(&recipe, &stripe_setup()["responses"], "respond"), + expected: family.oracle("qualification-1", &ORIGINAL), + checked: AtomicUsize::new(0), + read_back_url: family.read_back_url(), + read_backs: AtomicUsize::new(0), + }; + let held = HeldFirstCredentialRead { + provider: &provider, + entered: Notify::new(), + release: Notify::new(), + pending: AtomicBool::new(true), + }; + let store = TestAttempts::open(backend); + let other = store.reopen(); + let observer = GatewayObserver::from_test_seed(OBSERVER_SEED); + let arguments = family.arguments("qualification-1"); + let mut first = TestIo::new(&held, family.command(&recipe, &arguments, ORIGINAL)); + let mut second = TestIo::new(&held, family.command(&recipe, &arguments, ORIGINAL)); + first.recipe = Some(&recipe); + second.recipe = Some(&recipe); + let operation = LogicalOperationId::parse("qualification-1").expect("operation"); + let (winner, contender) = tokio::time::timeout(std::time::Duration::from_secs(10), async { + tokio::join!(run(store.attempts(), &recipe, &observer, &first), async { + // The first process owns the read permit but has not yet received + // evidence. The second process cannot interpret this as a failed + // provider predicate or consume another permit. + held.entered.notified().await; + let result = run(&other, &recipe, &observer, &second).await; + let snapshot = other + .read(recipe.namespace(), &operation) + .await + .expect("source read") + .expect("source reservation"); + held.release.notify_one(); + assert_eq!(snapshot.stage(), GatewayAttemptStage::Reserved); + result + }) + }) + .await + .expect("both contenders finish"); + assert!( + matches!(contender, GatewaySubmitResult::Reserved { .. }), + "{contender:?}" + ); + assert_eq!( + winner, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!(provider.checked.load(Ordering::SeqCst), 1); + assert_eq!(provider.inner.writes(), 1); + assert_eq!( + provider.inner.credential_reads.load(Ordering::SeqCst), + 3, + "account and two denied-capability reads each consume one permit" + ); + assert_eq!( + provider.inner.action_reads.load(Ordering::SeqCst), + 1, + "one ceiling read and no recovery read" + ); + assert_eq!(first.leases(), 1); + assert_eq!(second.leases(), 1); + assert_eq!( + other + .read(recipe.namespace(), &operation) + .await + .expect("source read") + .expect("source result") + .stage(), + GatewayAttemptStage::ResponseRecorded + ); +} + +#[tokio::test] +async fn file_in_flight_prerequisite_cannot_poison_shared_parent() { + pending_read_keeps_parent_reserved(Backend::File).await; +} + +#[tokio::test] +#[ignore = "needs the TLS PostgreSQL fixture"] +async fn postgres_in_flight_prerequisite_cannot_poison_shared_parent() { + assert!( + postgres_configured(), + "TLS PostgreSQL environment slots are required" + ); + pending_read_keeps_parent_reserved(Backend::Postgres).await; +} diff --git a/product/runtime/auths-gateway/src/qualification_simulation.rs b/product/runtime/auths-gateway/src/qualification_simulation.rs index 13a0c020f..a55459650 100644 --- a/product/runtime/auths-gateway/src/qualification_simulation.rs +++ b/product/runtime/auths-gateway/src/qualification_simulation.rs @@ -6,6 +6,9 @@ use super::*; use serde::Serialize; +#[path = "prerequisite_race_tests.rs"] +mod prerequisite_race_tests; + const STRIPE_VERSION: &str = "2025-03-31.basil"; const STRIPE_PAYMENT: &str = "pi_TEST0000000001"; @@ -241,7 +244,8 @@ fn publish(family: Family, recipe: &CompiledRecipe, cases: &[Measurement]) { "verification_boundary": "native-verified-command projection", "provider": "in-process mutable double", "cases": cases, "excluded_claims": ["live provider acceptance", "production qualification", - "production PostgreSQL/custody", "independent human onboarding"]}); + "production PostgreSQL/custody", "independent human onboarding", + "independent AP074 recovery authorization"]}); if let Some(directory) = std::env::var_os("AUTHS_QUALIFICATION_SIMULATION_OUTPUT") { let directory = std::path::PathBuf::from(directory); std::fs::create_dir_all(&directory).expect("report directory"); @@ -286,7 +290,10 @@ async fn lifecycle( assert!(matches!(result, GatewaySubmitResult::Unknown)); } else { assert!( - matches!(result, GatewaySubmitResult::ObservedByProvider { .. }), + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "{result:?}" ); } @@ -295,7 +302,7 @@ async fn lifecycle( if ambiguous { "ambiguous-write" } else { - "exact-write-and-read-back" + "exact-write-response-recorded" }, &result, first.leases(), @@ -334,14 +341,14 @@ async fn lifecycle( before, "{name}: no second write" ); - let mut observed = measurement( + let mut readback = measurement( name, &result, io.leases(), provider.inner.entries() - entries_before, ); - observed.confirmed_by_read_back = 0; // Historical evidence is not a new provider read. - cases.push(observed); + readback.confirmed_by_read_back = 0; // Historical evidence is not a new provider read. + cases.push(readback); } if ambiguous && matches!(family, Family::Airtable) { let io = TestIo::new(provider, family.command(&recipe, &args, ORIGINAL)); @@ -354,7 +361,12 @@ async fn lifecycle( GatewaySubmitResult::ObservedByProvider { .. } )); assert_eq!(provider.inner.entries(), entries_before); - cases.push(measurement("operator-read-back", &result, io.leases(), 0)); + cases.push(measurement( + "reference-only-operator-read-back", + &result, + io.leases(), + 0, + )); } cases } @@ -376,33 +388,37 @@ async fn race(family: Family, provider: &OracleProvider

0), + confirmed_by_read_back: 0, } } diff --git a/product/runtime/auths-gateway/src/quorum_tests.rs b/product/runtime/auths-gateway/src/quorum_tests.rs index cbc6a7882..ff564bca8 100644 --- a/product/runtime/auths-gateway/src/quorum_tests.rs +++ b/product/runtime/auths-gateway/src/quorum_tests.rs @@ -663,17 +663,11 @@ async fn approval_quorum_hostile_cases_admit_only_two_distinct_managers() { assert!( matches!( result, - GatewaySubmitResult::ObservedByProvider { - status: Some(200), - .. - } + GatewaySubmitResult::ResponseRecorded { status: 200 } ), "{id}: {result:?}" ); - assert_eq!( - leases, 2, - "{id}: one lease for the entry and one for its read-back" - ); + assert_eq!(leases, 1, "{id}: one write lease and no implicit read-back"); unauthorized_entries += entries.saturating_sub(1); } else { assert_eq!(leases, 0, "{id}: refused before any credential lease"); @@ -693,8 +687,11 @@ async fn approval_quorum_hostile_cases_admit_only_two_distinct_managers() { ) .await; assert!( - !matches!(result, GatewaySubmitResult::ResponseRecorded { .. }), - "an authorized quorum is one-use: {result:?}" + matches!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), + "replay reports historical response without a new entry: {result:?}" ); assert_eq!(counts().0, expected_entries, "a replay never writes again"); } @@ -732,18 +729,18 @@ async fn a_quorum_still_authorizes_23_hours_after_approval_and_only_once() { assert!( matches!( result, - GatewaySubmitResult::ObservedByProvider { - status: Some(200), - .. - } + GatewaySubmitResult::ResponseRecorded { status: 200 } ), "{result:?}" ); let (writes, _, leases) = harness.provider.counts(); - assert_eq!((writes, leases), (1, 2)); + assert_eq!((writes, leases), (1, 1)); let replay = harness.submit(&proof, &action, later + 60).await; assert!( - !matches!(replay, GatewaySubmitResult::ResponseRecorded { .. }), + matches!( + replay, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ), "{replay:?}" ); assert_eq!( @@ -857,7 +854,7 @@ async fn remote_approvals_from_any_two_managers_authorize() { case.id ); assert_eq!(after.0 - before.0, case.provider_entries, "{}", case.id); - assert_eq!(after.2 - before.2, 2 * case.provider_entries, "{}", case.id); + assert_eq!(after.2 - before.2, case.provider_entries, "{}", case.id); entries += case.provider_entries; } assert!( diff --git a/product/runtime/auths-gateway/src/recipe/content.rs b/product/runtime/auths-gateway/src/recipe/content.rs index 8c336c789..5a0357c8a 100644 --- a/product/runtime/auths-gateway/src/recipe/content.rs +++ b/product/runtime/auths-gateway/src/recipe/content.rs @@ -130,10 +130,10 @@ impl ContentSource { } previous = Some(query.name.as_str()); } - if let ContentProjection::JsonString { pointer } = &self.projection { - if !super::validate::valid_response_pointer(pointer) || !valid_escapes(pointer) { - return Err(GatewayRecipeError::InvalidSource); - } + if let ContentProjection::JsonString { pointer } = &self.projection + && (!super::validate::valid_response_pointer(pointer) || !valid_escapes(pointer)) + { + return Err(GatewayRecipeError::InvalidSource); } Ok(()) } diff --git a/product/runtime/auths-gateway/src/recipe/effect_review.rs b/product/runtime/auths-gateway/src/recipe/effect_review.rs index c6b0ffc63..0a0709b71 100644 --- a/product/runtime/auths-gateway/src/recipe/effect_review.rs +++ b/product/runtime/auths-gateway/src/recipe/effect_review.rs @@ -94,8 +94,8 @@ impl ReviewContract { ( Presentation::Text { label } | Presentation::Identifier { label }, Some(FieldSchema::String { .. } | FieldSchema::Enum { .. }), - ) => (label, true), - (Presentation::Boolean { label }, Some(FieldSchema::Boolean)) => (label, true), + ) + | (Presentation::Boolean { label }, Some(FieldSchema::Boolean)) => (label, true), (Presentation::Integer { label, unit }, Some(FieldSchema::Integer { .. })) => { (label, trusted_text(unit, 80)) } diff --git a/product/runtime/auths-gateway/src/recipe/review.rs b/product/runtime/auths-gateway/src/recipe/review.rs index 40f0a1066..6b889ac90 100644 --- a/product/runtime/auths-gateway/src/recipe/review.rs +++ b/product/runtime/auths-gateway/src/recipe/review.rs @@ -322,22 +322,7 @@ impl CompiledRecipe { "recovery": review.recovery().as_ref().map(recovery_document), "write_is_conditional": false, }); - document["provider_headers"] = - source - .provider_headers - .as_ref() - .map_or(Value::Null, |headers| { - Value::Object( - headers - .iter() - .map(|(name, value)| { - let response = provider_header(name) - .map_or("not-checked", |entry| entry.response.as_str()); - (name.clone(), json!({"value": value, "response": response})) - }) - .collect(), - ) - }); + document["provider_headers"] = self.provider_headers_review(); document["credential_guard"] = self.guard_review(); if let Some(content) = &source.content { document["content_acquisition"] = json!({ @@ -401,6 +386,24 @@ impl CompiledRecipe { document } + fn provider_headers_review(&self) -> Value { + self.source + .provider_headers + .as_ref() + .map_or(Value::Null, |headers| { + Value::Object( + headers + .iter() + .map(|(name, value)| { + let response = provider_header(name) + .map_or("not-checked", |entry| entry.response.as_str()); + (name.clone(), json!({"value": value, "response": response})) + }) + .collect(), + ) + }) + } + fn guard_review(&self) -> Value { let Some(guard) = self.source.credential.guard() else { return Value::Null; diff --git a/product/runtime/auths-gateway/src/recipe/tests.rs b/product/runtime/auths-gateway/src/recipe/tests.rs index 3048ccf14..3a153487d 100644 --- a/product/runtime/auths-gateway/src/recipe/tests.rs +++ b/product/runtime/auths-gateway/src/recipe/tests.rs @@ -104,6 +104,7 @@ fn with_preconditions( lock["schema_digest"] = Value::String(digest.clone()); let mut source: Value = serde_json::from_slice(source).expect("source"); source["profile_schema_digest"] = Value::String(digest); + source["review"] = super::synthetic_review(&lock["command_schema"]["fields"]); if let Some(preconditions) = preconditions { source["preconditions"] = preconditions; } @@ -209,7 +210,8 @@ fn preconditions_are_closed_reviewed_and_digest_bound() { let names: Vec = (0..9).map(|index| format!("v{index}")).collect(); assert_eq!( with_preconditions(&many, Some(json!({"verified": names})), false).err(), - Some(GatewayRecipeError::PreconditionConflict) + Some(GatewayRecipeError::InvalidSource), + "the complete review field bound rejects an oversized declaration before precondition validation" ); } diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index b7aa48a6d..d3c93d595 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -498,10 +498,10 @@ async fn reobserve_operator( if !io.reload().await { return None; } - let lease = io.lease().await?; + io.lease().await?; let prefix = recipe .guard_checks() - .is_none_or(|guard| io.secret_admitted(&lease, &guard)); + .is_none_or(|guard| io.secret_admitted(&(), &guard)); if !submit::lease_checks(recipe, io.provider, prefix, io.account_commitment()).await { return None; } @@ -2730,7 +2730,7 @@ async fn store_conformance(backend: Backend) { conformance_fresh_challenge(backend).await; conformance_unknown_and_reobserve(backend).await; conformance_echo_mismatch(backend).await; - conformance_concurrent_reobservation(backend).await; + Box::pin(conformance_concurrent_reobservation(backend)).await; conformance_mechanism_fails_closed(backend).await; conformance_concurrent_claims_from_two_processes(backend).await; conformance_batches_from_two_processes(backend).await; @@ -2741,7 +2741,7 @@ async fn store_conformance(backend: Backend) { #[tokio::test] async fn file_store_passes_attempt_store_conformance() { - store_conformance(Backend::File).await; + Box::pin(store_conformance(Backend::File)).await; } #[tokio::test] @@ -2751,7 +2751,7 @@ async fn postgres_store_passes_attempt_store_conformance() { postgres_configured(), "TLS PostgreSQL environment slots are required" ); - store_conformance(Backend::Postgres).await; + Box::pin(store_conformance(Backend::Postgres)).await; } /// A batch interrupted at any step leaves nothing once the store is opened diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 6a38b958b..1d132ebe8 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "4f96a74b45c1d73d5a0d21a1666a556bed1a5f3fa7284d3c324a9927367d4bc7"; + "d4fc5a0b03f146dd1cad971d75db4e199f2ec44405e916f2fd764b32b973cc6c"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 974b16bb1..968b6639d 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -300,7 +300,7 @@ impl GatewayAttemptSnapshot { pub fn recovery_received_at(&self) -> Option { self.recovery_evidence .as_ref() - .map(|link| link.received_at()) + .map(acquisition::RecoveryEvidenceLink::received_at) } /// Returns the durable journal revision. @@ -705,9 +705,9 @@ impl Record { deny_unknown_fields )] enum ProtocolState { - Mutation(MutationState), - Acquisition(acquisition::AcquisitionState), - Disclosure(disclosure::DisclosureState), + Mutation(Box), + Acquisition(Box), + Disclosure(Box), } mod acquisition; @@ -732,11 +732,11 @@ trait JournalProtocol: Clone + Sized { impl JournalProtocol for MutationState { fn wrap(self) -> ProtocolState { - ProtocolState::Mutation(self) + ProtocolState::Mutation(Box::new(self)) } fn extract(state: ProtocolState) -> Result { match state { - ProtocolState::Mutation(state) => Ok(state), + ProtocolState::Mutation(state) => Ok(*state), ProtocolState::Acquisition(_) | ProtocolState::Disclosure(_) => { Err(GatewayAttemptError::BindingConflict) } @@ -2195,7 +2195,7 @@ impl GatewayAttempts { Arc::clone(&self.store) } - /// Reference-store oracle only; production admission requires ApprovedEffect. + /// Reference-store oracle only; production admission requires `ApprovedEffect`. #[cfg(test)] pub(crate) async fn claim( &self, @@ -2486,6 +2486,31 @@ impl Attempt { } } +fn validate_mutation_prerequisites( + key: GatewayAttemptKey, + approved: &ApprovedEffect, + validation: &crate::entry::EntryValidation, + pre_entry: Option<&PreEntryWire>, + prerequisites: &[crate::effect::PrerequisitePlan], + snapshots: &[Option>], + now: u64, +) -> Result<(), GatewayAttemptError> { + let acquired = acquisition::validate_prerequisites( + key, + approved.effect().binding(), + prerequisites, + snapshots, + now, + )?; + let evidence = pre_entry + .map(PreEntryWire::decode) + .transpose()? + .unwrap_or_default(); + validation + .validate_prerequisite_evidence(approved, &evidence, &acquired, now) + .map_err(|_| GatewayAttemptError::InvalidTransition) +} + /// A durable attempt handle. A reservation does not authorize transport; only /// a newly acknowledged grant produces a one-use provider permit. pub struct ClaimedGatewayAttempt { @@ -2564,21 +2589,15 @@ impl ClaimedGatewayAttempt { &snapshots[dependency_end..counter_end], now, )?; - let acquired = acquisition::validate_prerequisites( + validate_mutation_prerequisites( attempt.key, - approved.effect().binding(), + &approved, + &validation, + pre_entry.as_ref(), &prerequisites, &snapshots[counter_end..], now, )?; - let evidence = pre_entry - .as_ref() - .map(PreEntryWire::decode) - .transpose()? - .unwrap_or_default(); - validation - .validate_prerequisite_evidence(&approved, &evidence, &acquired, now) - .map_err(|_| GatewayAttemptError::InvalidTransition)?; let mut next = current.clone(); next.record_grant( &approved, @@ -3316,23 +3335,22 @@ impl GatewayAttempts { admission.approved.approval(), evaluated_at, )?; - let result = match &bound { - Some(bound) => reserve_with_claim(&*store, key, &base, bound, &admission), - None => { - let mut record = base.clone(); - let entries = [GatewayRecordEntry { - kind: GatewayRecordKind::Attempt, - key, - record: encode(&record)?, - expires_at: None, - }]; - match insert_claim(&*store, &mut record, &entries, &admission, None)? { - GatewayInsert::Inserted => Ok(Reserved::Claimed { - stored: encode(&record)?, - record: Box::new(record), - }), - GatewayInsert::Exists { .. } => Err(GatewayAttemptError::Replay), - } + let result = if let Some(bound) = &bound { + reserve_with_claim(&*store, key, &base, bound, &admission) + } else { + let mut record = base.clone(); + let entries = [GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + match insert_claim(&*store, &mut record, &entries, &admission, None)? { + GatewayInsert::Inserted => Ok(Reserved::Claimed { + stored: encode(&record)?, + record: Box::new(record), + }), + GatewayInsert::Exists { .. } => Err(GatewayAttemptError::Replay), } }; match result { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index f8a1f2b74..618c7e13f 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -117,12 +117,12 @@ impl AcquisitionPhase { impl JournalProtocol for AcquisitionState { fn wrap(self) -> ProtocolState { - ProtocolState::Acquisition(self) + ProtocolState::Acquisition(Box::new(self)) } fn extract(state: ProtocolState) -> Result { match state { - ProtocolState::Acquisition(state) => Ok(state), + ProtocolState::Acquisition(state) => Ok(*state), ProtocolState::Mutation(_) | ProtocolState::Disclosure(_) => { Err(GatewayAttemptError::BindingConflict) } @@ -409,9 +409,9 @@ impl Record { .ok_or(GatewayAttemptError::Corrupt)? .granted_at; if now < response.received_at - || !now + || now .checked_sub(observed_at) - .is_some_and(|age| age <= crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) + .is_none_or(|age| age > crate::effect::MAX_PREREQUISITE_EVIDENCE_AGE_SECONDS) { return Err(GatewayAttemptError::InvalidTransition); } @@ -577,6 +577,54 @@ impl GatewayAttempts { .await } + fn acquisition_source( + &self, + plan: &AcquisitionPlan, + namespace: &OperatorNamespace, + ) -> Result<(GatewayRecordKind, GatewayAttemptKey), GatewayAttemptError> { + Ok(match plan { + AcquisitionPlan::Content(plan) => ( + GatewayRecordKind::Connection, + plan.source_key() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionPlan::Candidate(plan) => ( + GatewayRecordKind::Connection, + plan.source_key() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + _ => { + let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; + let operation = LogicalOperationId::parse(source.journal_identity().1) + .map_err(|_| GatewayAttemptError::Corrupt)?; + (GatewayRecordKind::Attempt, self.key(namespace, &operation)?) + } + }) + } + + async fn retained_acquisition( + &self, + key: GatewayAttemptKey, + expected_plan: &AcquisitionPlan, + binding: &crate::effect::EffectBinding, + ) -> Result<(Record, Vec), GatewayAttemptError> { + let store = Arc::clone(&self.store); + let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + .await? + .ok_or(GatewayAttemptError::Unavailable)?; + let record: Record = decode_as(&bytes)?; + if &record.state.plan != expected_plan + || record.binding_canonical.as_bytes() + != binding + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + Ok((record, bytes)) + } + async fn claim_acquisition( &self, approved: &Arc, @@ -597,27 +645,7 @@ impl GatewayAttempts { let operation = LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?; let key = self.key(&namespace, &operation)?; - let (source_kind, source_key) = match &plan { - AcquisitionPlan::Content(plan) => ( - GatewayRecordKind::Connection, - plan.source_key() - .map_err(|_| GatewayAttemptError::Corrupt)?, - ), - AcquisitionPlan::Candidate(plan) => ( - GatewayRecordKind::Connection, - plan.source_key() - .map_err(|_| GatewayAttemptError::Corrupt)?, - ), - _ => { - let source = plan.source().map_err(|_| GatewayAttemptError::Corrupt)?; - let operation = LogicalOperationId::parse(source.journal_identity().1) - .map_err(|_| GatewayAttemptError::Corrupt)?; - ( - GatewayRecordKind::Attempt, - self.key(&namespace, &operation)?, - ) - } - }; + let (source_kind, source_key) = self.acquisition_source(&plan, &namespace)?; let key = match &plan { AcquisitionPlan::Recovery(_) | AcquisitionPlan::Candidate(_) @@ -662,115 +690,25 @@ impl GatewayAttempts { }, )?; base.validate_header()?; - let mut candidate = bound - .as_ref() - .map(|bound| capacity::CapacityCandidate::new(&*store, bound)) - .transpose()?; - let mut slot = 0; - for _ in 0..MAX_CLAIM_ROUNDS { - let refusal = if slot >= capacity.attempts { - Some("gateway.acquisition.exhausted") - } else { - candidate - .as_ref() - .and_then(capacity::CapacityCandidate::refusal) - }; - let mut record = base.clone(); - let mut slots = Vec::new(); - if let Some(code) = refusal { - record.state.phase = AcquisitionPhase::NotEntered { - code: code.to_owned(), - }; - } else { - record.state.allocation = Some(slot); - if let Some(candidate) = &candidate { - (record.state.counters, slots) = - candidate.batch(key, &record.namespace, &record.operation_id)?; - } - } - AcquisitionState::validate(&record)?; - let mut entries = vec![GatewayRecordEntry { - kind: GatewayRecordKind::Attempt, - key, - record: encode(&record)?, - expires_at: None, - }]; - if refusal.is_none() { - entries.push(GatewayRecordEntry { - kind: GatewayRecordKind::EffectAllocation, - key: capacity::allocation_key(&capacity, slot), - record: canonical(&allocation(&record.state.plan, key, slot)?)?, - expires_at: None, - }); - entries.extend(slots); - } - match insert_acquisition( - &*store, - &mut record, - &entries, - &dependencies, - &admission, - &native_indices, - if refusal.is_none() { - candidate.as_ref() - } else { - None - }, - )? { - GatewayInsert::Inserted => { - let stored = encode(&record)?; - return Ok((record, stored)); - } - GatewayInsert::Exists { index: 0 } => { - return Err(existing_binding(&*store, key, &base.binding_canonical)); - } - GatewayInsert::Exists { index: 1 } if refusal.is_none() => { - // Lifetime allocations are append-only. A credential - // cannot restart its byte ceiling through another recipe - // proposal while retaining the same custody identity. - let bytes = store - .load( - GatewayRecordKind::EffectAllocation, - &capacity::allocation_key(&capacity, slot), - )? - .ok_or(GatewayAttemptError::Corrupt)?; - let occupied: capacity::SourceAllocation = - serde_json::from_slice(&bytes) - .map_err(|_| GatewayAttemptError::Corrupt)?; - let expected = allocation(&record.state.plan, key, slot)?; - occupied.validate_occupied(&expected, &bytes)?; - slot += 1; - } - GatewayInsert::Exists { index } if refusal.is_none() => { - candidate - .as_mut() - .ok_or(GatewayAttemptError::Corrupt)? - .advance(&*store, index - 2)?; - } - GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), - } - } - Err(GatewayAttemptError::Conflict) + reserve_acquisition( + &*store, + key, + &base, + &capacity, + bound.as_ref(), + AcquisitionDependencies { + keys: &dependencies, + native_indices: &native_indices, + }, + &admission, + ) }) .await; let (record, stored) = match reserved { Ok(value) => value, Err(GatewayAttemptError::Replay) => { - let store = Arc::clone(&self.store); - let bytes = blocking(move || store.load(GatewayRecordKind::Attempt, &key)) + self.retained_acquisition(key, &expected_plan, binding) .await? - .ok_or(GatewayAttemptError::Unavailable)?; - let record: Record = decode_as(&bytes)?; - if record.state.plan != expected_plan - || record.binding_canonical.as_bytes() - != binding - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .as_slice() - { - return Err(GatewayAttemptError::BindingConflict); - } - (record, bytes) } Err(error) => return Err(error), }; @@ -790,6 +728,288 @@ impl GatewayAttempts { } } +#[derive(Clone, Copy)] +struct AcquisitionDependencies<'a> { + keys: &'a [(GatewayRecordKind, GatewayAttemptKey)], + native_indices: &'a [usize], +} + +fn reserve_acquisition( + store: &dyn GatewayAttemptStore, + key: GatewayAttemptKey, + base: &Record, + capacity: &SourceCapacity, + bound: Option<&crate::bounds::BoundAdmission>, + dependencies: AcquisitionDependencies<'_>, + admission: &Admission, +) -> Result<(Record, Vec), GatewayAttemptError> { + let mut candidate = bound + .map(|bound| capacity::CapacityCandidate::new(store, bound)) + .transpose()?; + let mut slot = 0; + for _ in 0..MAX_CLAIM_ROUNDS { + let refusal = if slot >= capacity.attempts { + Some("gateway.acquisition.exhausted") + } else { + candidate + .as_ref() + .and_then(capacity::CapacityCandidate::refusal) + }; + let (mut record, entries) = + acquisition_batch(base, key, capacity, slot, refusal, candidate.as_ref())?; + match insert_acquisition( + store, + &mut record, + &entries, + dependencies.keys, + admission, + dependencies.native_indices, + if refusal.is_none() { + candidate.as_ref() + } else { + None + }, + )? { + GatewayInsert::Inserted => { + let stored = encode(&record)?; + return Ok((record, stored)); + } + GatewayInsert::Exists { index: 0 } => { + return Err(existing_binding(store, key, &base.binding_canonical)); + } + GatewayInsert::Exists { index: 1 } if refusal.is_none() => { + // Lifetime allocations are append-only. A credential + // cannot restart its byte ceiling through another recipe + // proposal while retaining the same custody identity. + let bytes = store + .load( + GatewayRecordKind::EffectAllocation, + &capacity::allocation_key(capacity, slot), + )? + .ok_or(GatewayAttemptError::Corrupt)?; + let occupied: capacity::SourceAllocation = + serde_json::from_slice(&bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + let expected = allocation(&record.state.plan, key, slot)?; + occupied.validate_occupied(&expected, &bytes)?; + slot += 1; + } + GatewayInsert::Exists { index } if refusal.is_none() => { + candidate + .as_mut() + .ok_or(GatewayAttemptError::Corrupt)? + .advance(store, index - 2)?; + } + GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), + } + } + Err(GatewayAttemptError::Conflict) +} + +fn acquisition_batch( + base: &Record, + key: GatewayAttemptKey, + capacity: &SourceCapacity, + slot: u64, + refusal: Option<&str>, + candidate: Option<&capacity::CapacityCandidate>, +) -> Result<(Record, Vec), GatewayAttemptError> { + let mut record = base.clone(); + let mut slots = Vec::new(); + if let Some(code) = refusal { + record.state.phase = AcquisitionPhase::NotEntered { + code: code.to_owned(), + }; + } else { + record.state.allocation = Some(slot); + if let Some(candidate) = candidate { + (record.state.counters, slots) = + candidate.batch(key, &record.namespace, &record.operation_id)?; + } + } + AcquisitionState::validate(&record)?; + let mut entries = vec![GatewayRecordEntry { + kind: GatewayRecordKind::Attempt, + key, + record: encode(&record)?, + expires_at: None, + }]; + if refusal.is_none() { + entries.push(GatewayRecordEntry { + kind: GatewayRecordKind::EffectAllocation, + key: capacity::allocation_key(capacity, slot), + record: canonical(&allocation(&record.state.plan, key, slot)?)?, + expires_at: None, + }); + entries.extend(slots); + } + Ok((record, entries)) +} + +fn approved_request( + plan: &AcquisitionPlan, + approved: &ApprovedEffect, +) -> Result<(AcquisitionPlan, AcquisitionRequest), GatewayAttemptError> { + Ok(match plan { + AcquisitionPlan::Content(_) => ( + AcquisitionPlan::Content( + approved + .content_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Content( + approved + .content_target() + .ok_or(GatewayAttemptError::InvalidTransition)? + .closed_read() + .clone(), + ), + ), + AcquisitionPlan::Recovery(_) => { + let target = approved + .recovery_target() + .ok_or(GatewayAttemptError::InvalidTransition)?; + ( + AcquisitionPlan::Recovery( + approved + .recovery_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Recovery(target.closed_request().clone()), + ) + } + AcquisitionPlan::Candidate(_) => ( + AcquisitionPlan::Candidate( + approved + .candidate_plan() + .map_err(|_| GatewayAttemptError::Corrupt)?, + ), + AcquisitionRequest::Prerequisite( + approved + .candidate_target() + .ok_or(GatewayAttemptError::InvalidTransition)? + .final_request() + .clone(), + ), + ), + AcquisitionPlan::Prerequisite(plan) => { + let kind = plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?; + let (plan, read) = approved + .prerequisite(kind) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + ( + AcquisitionPlan::Prerequisite(plan), + AcquisitionRequest::Prerequisite(read), + ) + } + }) +} + +fn validate_reserved_acquisition( + attempt: &Attempt, + plan: &AcquisitionPlan, + approved: &ApprovedEffect, + source_key: GatewayAttemptKey, + slot: u64, + dependency_count: usize, + snapshots: &[Option>], +) -> Result, GatewayAttemptError> { + if snapshots.len() != dependency_count + || snapshots[0].as_deref() != Some(attempt.stored.as_slice()) + { + return Err(GatewayAttemptError::Conflict); + } + let current: Record = decode_as( + snapshots[0] + .as_deref() + .ok_or(GatewayAttemptError::Corrupt)?, + )?; + if !matches!(current.state.phase, AcquisitionPhase::Reserved) + || ¤t.state.plan != plan + || current.binding_canonical.as_bytes() + != approved + .effect() + .binding() + .to_private_bytes() + .map_err(|_| GatewayAttemptError::Corrupt)? + .as_slice() + { + return Err(GatewayAttemptError::BindingConflict); + } + let (source_matches, _) = + eligible_source(plan, snapshots[1].as_deref(), source_key, attempt.key)?; + if !source_matches + || snapshots[2].as_deref() + != Some(canonical(&allocation(plan, attempt.key, slot)?)?.as_slice()) + { + return Err(GatewayAttemptError::BindingConflict); + } + Ok(current) +} + +struct AcquisitionEntryDependencies { + keys: Vec<(GatewayRecordKind, GatewayAttemptKey)>, + slot: u64, + native_indices: Vec, + native_end: usize, + counter_end: usize, + prerequisites: Vec, +} + +fn acquisition_entry_dependencies( + attempt: &Attempt, + plan: &AcquisitionPlan, + approved: &ApprovedEffect, + validation: &crate::entry::EntryValidation, + source_key: GatewayAttemptKey, +) -> Result { + let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; + let slot = attempt + .record + .state + .allocation + .ok_or(GatewayAttemptError::Corrupt)?; + let dependencies = validation.dependencies(); + let mut keys = vec![ + (GatewayRecordKind::Attempt, attempt.key), + ( + if matches!( + plan, + AcquisitionPlan::Candidate(_) | AcquisitionPlan::Content(_) + ) { + GatewayRecordKind::Connection + } else { + GatewayRecordKind::Attempt + }, + source_key, + ), + ( + GatewayRecordKind::EffectAllocation, + capacity::allocation_key(&capacity, slot), + ), + ]; + let native_indices = append_dependencies(&mut keys, &dependencies); + let native_end = keys.len(); + keys.extend(capacity::dependencies(&attempt.record.state.counters)?); + let counter_end = keys.len(); + let prerequisites = match plan { + AcquisitionPlan::Recovery(_) + | AcquisitionPlan::Candidate(_) + | AcquisitionPlan::Content(_) => approved + .prerequisite_plans() + .map_err(|_| GatewayAttemptError::Corrupt)?, + AcquisitionPlan::Prerequisite(_) => Vec::new(), + }; + keys.extend(prerequisite_dependencies(attempt.key, &prerequisites)?); + Ok(AcquisitionEntryDependencies { + keys, + slot, + native_indices, + native_end, + counter_end, + prerequisites, + }) +} + impl ReservedAcquisition { /// Inspects the reservation without granting entry or reading a provider. /// @@ -805,131 +1025,34 @@ impl ReservedAcquisition { validation: crate::entry::EntryValidation, authorization_started_at: u64, ) -> Result<(GrantedAcquisition, AcquisitionEntryPermit), GatewayAttemptError> { - let (plan, request) = match &self.attempt.record.state.plan { - AcquisitionPlan::Content(_) => ( - AcquisitionPlan::Content( - approved - .content_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?, - ), - AcquisitionRequest::Content( - approved - .content_target() - .ok_or(GatewayAttemptError::InvalidTransition)? - .closed_read() - .clone(), - ), - ), - AcquisitionPlan::Recovery(_) => { - let target = approved - .recovery_target() - .ok_or(GatewayAttemptError::InvalidTransition)?; - ( - AcquisitionPlan::Recovery( - approved - .recovery_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?, - ), - AcquisitionRequest::Recovery(target.closed_request().clone()), - ) - } - AcquisitionPlan::Candidate(_) => ( - AcquisitionPlan::Candidate( - approved - .candidate_plan() - .map_err(|_| GatewayAttemptError::Corrupt)?, - ), - AcquisitionRequest::Prerequisite( - approved - .candidate_target() - .ok_or(GatewayAttemptError::InvalidTransition)? - .final_request() - .clone(), - ), - ), - AcquisitionPlan::Prerequisite(plan) => { - let kind = plan.kind().map_err(|_| GatewayAttemptError::Corrupt)?; - let (plan, read) = approved - .prerequisite(kind) - .map_err(|_| GatewayAttemptError::BindingConflict)?; - ( - AcquisitionPlan::Prerequisite(plan), - AcquisitionRequest::Prerequisite(read), - ) - } - }; + let (plan, request) = approved_request(&self.attempt.record.state.plan, &approved)?; blocking(move || { let mut attempt = self.attempt; - let capacity = plan.capacity().map_err(|_| GatewayAttemptError::Corrupt)?; - let slot = attempt - .record - .state - .allocation - .ok_or(GatewayAttemptError::Corrupt)?; - let dependencies = validation.dependencies(); - let mut keys = vec![ - (GatewayRecordKind::Attempt, attempt.key), - ( - if matches!( - plan, - AcquisitionPlan::Candidate(_) | AcquisitionPlan::Content(_) - ) { - GatewayRecordKind::Connection - } else { - GatewayRecordKind::Attempt - }, - self.source_key, - ), - ( - GatewayRecordKind::EffectAllocation, - capacity::allocation_key(&capacity, slot), - ), - ]; - let native_indices = append_dependencies(&mut keys, &dependencies); - let native_end = keys.len(); - keys.extend(capacity::dependencies(&attempt.record.state.counters)?); - let counter_end = keys.len(); - let prerequisites = match &plan { - AcquisitionPlan::Recovery(_) - | AcquisitionPlan::Candidate(_) - | AcquisitionPlan::Content(_) => approved - .prerequisite_plans() - .map_err(|_| GatewayAttemptError::Corrupt)?, - AcquisitionPlan::Prerequisite(_) => Vec::new(), - }; - keys.extend(prerequisite_dependencies(attempt.key, &prerequisites)?); + let AcquisitionEntryDependencies { + keys, + slot, + native_indices, + native_end, + counter_end, + prerequisites, + } = acquisition_entry_dependencies( + &attempt, + &plan, + &approved, + &validation, + self.source_key, + )?; let mut committed = None; attempt.store.fenced_replace(&keys, &mut |snapshots| { - if snapshots.len() != keys.len() - || snapshots[0].as_deref() != Some(attempt.stored.as_slice()) - { - return Err(GatewayAttemptError::Conflict); - } - let current: Record = decode_as( - snapshots[0] - .as_deref() - .ok_or(GatewayAttemptError::Corrupt)?, + let current = validate_reserved_acquisition( + &attempt, + &plan, + &approved, + self.source_key, + slot, + keys.len(), + snapshots, )?; - if !matches!(current.state.phase, AcquisitionPhase::Reserved) - || current.state.plan != plan - || current.binding_canonical.as_bytes() - != approved - .effect() - .binding() - .to_private_bytes() - .map_err(|_| GatewayAttemptError::Corrupt)? - .as_slice() - { - return Err(GatewayAttemptError::BindingConflict); - } - let (source_matches, _) = - eligible_source(&plan, snapshots[1].as_deref(), self.source_key, attempt.key)?; - if !source_matches - || snapshots[2].as_deref() - != Some(canonical(&allocation(&plan, attempt.key, slot)?)?.as_slice()) - { - return Err(GatewayAttemptError::BindingConflict); - } let now = validation .validate( &approved, @@ -990,9 +1113,7 @@ impl ReservedAcquisition { committed = Some((next, bytes.clone())); Ok(bytes) })?; - let (record, stored) = committed.ok_or(GatewayAttemptError::Unavailable)?; - attempt.record = record; - attempt.stored = stored; + (attempt.record, attempt.stored) = committed.ok_or(GatewayAttemptError::Unavailable)?; Ok(( GrantedAcquisition { attempt }, AcquisitionEntryPermit { diff --git a/product/runtime/auths-gateway/src/store/acquisition/candidate.rs b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs index 5d84e3f77..b5a8e7f5a 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/candidate.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/candidate.rs @@ -1,7 +1,12 @@ //! Publication is an explicit operator action over retained candidate evidence. //! It changes only the connection row; acquisition facts and charges stay immutable. -use super::*; +use super::{ + AcquisitionPlan, AcquisitionState, ApprovedEffect, Arc, GatewayAttemptError, GatewayAttempts, + GatewayInsert, GatewayRecordEntry, GatewayRecordKind, LogicalOperationId, OperatorNamespace, + Record, Serialize, allocation, append_dependencies, blocking, canonical, capacity, decode_as, + prerequisite_dependencies, select_snapshots, validate_prerequisites, +}; /// Result of an explicit operator publication; neither variant grants I/O. #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] @@ -15,19 +20,22 @@ pub enum CandidatePublication { AlreadyCurrent, } -impl GatewayAttempts { - /// No public/application route may call this as a substitute for operator - /// publication authority. The native read proof authorizes only its reads. - pub(crate) async fn publish_candidate( - &self, - approved: Arc, - validation: crate::entry::EntryValidation, - authorization_started_at: u64, - ) -> Result { +struct PublicationTarget { + plan: crate::effect::CandidatePlan, + capacity: super::SourceCapacity, + replacement: Vec, + is_first: bool, + kind: super::PrerequisiteKind, + connection_key: super::GatewayAttemptKey, + key: super::GatewayAttemptKey, +} + +impl PublicationTarget { + fn new( + approved: &ApprovedEffect, + attempts: &GatewayAttempts, + ) -> Result { let binding = approved.effect().binding(); - if !self.policy.contains(binding) { - return Err(GatewayAttemptError::BindingConflict); - } let target = approved .candidate_target() .ok_or(GatewayAttemptError::InvalidTransition)?; @@ -47,10 +55,47 @@ impl GatewayAttempts { .source_key() .map_err(|_| GatewayAttemptError::Corrupt)?; let (namespace, operation, _, _) = binding.journal_identity(); - let key = self.key( + let key = attempts.key( &OperatorNamespace::parse(namespace).map_err(|_| GatewayAttemptError::Corrupt)?, &LogicalOperationId::parse(operation).map_err(|_| GatewayAttemptError::Corrupt)?, )?; + Ok(Self { + plan, + capacity, + replacement, + is_first, + kind, + connection_key, + key, + }) + } +} + +type PublicationDecision<'a> = + dyn FnMut(&[Option>]) -> Result, GatewayAttemptError> + 'a; + +impl GatewayAttempts { + /// No public/application route may call this as a substitute for operator + /// publication authority. The native read proof authorizes only its reads. + pub(crate) async fn publish_candidate( + &self, + approved: Arc, + validation: crate::entry::EntryValidation, + authorization_started_at: u64, + ) -> Result { + let binding = approved.effect().binding(); + if !self.policy.contains(binding) { + return Err(GatewayAttemptError::BindingConflict); + } + let PublicationTarget { + plan, + capacity, + replacement, + is_first, + kind, + connection_key, + key, + } = PublicationTarget::new(&approved, self)?; let store = Arc::clone(&self.store); blocking(move || { let root_bytes = store @@ -129,39 +174,54 @@ impl GatewayAttempts { .map_err(|_| GatewayAttemptError::InvalidTransition)?; Ok(replacement.clone()) }; - if is_first { - let entry = GatewayRecordEntry { - kind: GatewayRecordKind::Connection, - key: connection_key, - record: replacement.clone(), - expires_at: None, - }; - // The insertion target itself is held absent by the same fence. - // Reconstruct that explicit snapshot for the shared decision. - match store.fenced_insert_all(&[entry], &keys[1..], &mut |snapshots| { - let mut all = Vec::with_capacity(snapshots.len() + 1); - all.push(None); - all.extend_from_slice(snapshots); - decide(&all) - })? { - GatewayInsert::Inserted => {} - GatewayInsert::Exists { index: 0 } => { - if store - .load(GatewayRecordKind::Connection, &connection_key)? - .as_deref() - != Some(replacement.as_slice()) - { - return Err(GatewayAttemptError::BindingConflict); - } - return Ok(CandidatePublication::AlreadyCurrent); - } - GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), - } - } else { - store.fenced_replace(&keys, &mut decide)?; + if publish_connection(&*store, &keys, &replacement, is_first, &mut decide)? { + return Ok(CandidatePublication::AlreadyCurrent); } Ok(disposition) }) .await } } + +/// Returns true only when a competing publisher already installed the exact record. +fn publish_connection( + store: &dyn super::GatewayAttemptStore, + keys: &[(GatewayRecordKind, super::GatewayAttemptKey)], + replacement: &[u8], + is_first: bool, + decide: &mut PublicationDecision<'_>, +) -> Result { + let connection_key = keys[0].1; + if is_first { + let entry = GatewayRecordEntry { + kind: GatewayRecordKind::Connection, + key: connection_key, + record: replacement.to_vec(), + expires_at: None, + }; + // The insertion target itself is held absent by the same fence. + // Reconstruct that explicit snapshot for the shared decision. + match store.fenced_insert_all(&[entry], &keys[1..], &mut |snapshots| { + let mut all = Vec::with_capacity(snapshots.len() + 1); + all.push(None); + all.extend_from_slice(snapshots); + decide(&all) + })? { + GatewayInsert::Inserted => {} + GatewayInsert::Exists { index: 0 } => { + if store + .load(GatewayRecordKind::Connection, &connection_key)? + .as_deref() + != Some(replacement) + { + return Err(GatewayAttemptError::BindingConflict); + } + return Ok(true); + } + GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), + } + } else { + store.fenced_replace(keys, decide)?; + } + Ok(false) +} diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index 15b257954..5d8410555 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -356,14 +356,13 @@ impl GatewayAttempts { acquisition: read.snapshot()?, disposition, }); - match next { - Some(bytes) => Ok(bytes), - None => { - unchanged = true; - // Abort the write transaction: an inspection/replay must - // not rewrite state or acquire a new journal revision. - Err(GatewayAttemptError::Replay) - } + if let Some(bytes) = next { + Ok(bytes) + } else { + unchanged = true; + // Abort the write transaction: an inspection/replay must + // not rewrite state or acquire a new journal revision. + Err(GatewayAttemptError::Replay) } }); match persisted { diff --git a/product/runtime/auths-gateway/src/store/disclosure.rs b/product/runtime/auths-gateway/src/store/disclosure.rs index a9e5b3d1d..26e4b2957 100644 --- a/product/runtime/auths-gateway/src/store/disclosure.rs +++ b/product/runtime/auths-gateway/src/store/disclosure.rs @@ -74,11 +74,11 @@ impl DisclosurePhase { impl JournalProtocol for DisclosureState { fn wrap(self) -> ProtocolState { - ProtocolState::Disclosure(self) + ProtocolState::Disclosure(Box::new(self)) } fn extract(state: ProtocolState) -> Result { match state { - ProtocolState::Disclosure(state) => Ok(state), + ProtocolState::Disclosure(state) => Ok(*state), _ => Err(GatewayAttemptError::BindingConflict), } } @@ -449,7 +449,7 @@ impl GatewayAttempts { .ok_or(GatewayAttemptError::Corrupt)? .advance(&*store, index - 2)?; } - _ => return Err(GatewayAttemptError::Corrupt), + GatewayInsert::Exists { .. } => return Err(GatewayAttemptError::Corrupt), } } Err(GatewayAttemptError::Conflict) @@ -522,7 +522,7 @@ impl GatewayAttempts { .await { Ok(attempt) => return attempt.record.disclosure_snapshot(), - Err(GatewayAttemptError::Conflict) => continue, + Err(GatewayAttemptError::Conflict) => {} Err(error) => return Err(error), } } diff --git a/product/runtime/auths-gateway/src/submit.rs b/product/runtime/auths-gateway/src/submit.rs index 0f63f0a21..72ae2df4f 100644 --- a/product/runtime/auths-gateway/src/submit.rs +++ b/product/runtime/auths-gateway/src/submit.rs @@ -199,23 +199,20 @@ pub(crate) async fn acquire_prerequisite( .grant_entry(std::sync::Arc::clone(approved), validation, entry_started) .await .ok()?; - match io.acquisition_send(lease, permit).await { - Some(response) => { - let received_at = io.acquisition_clock()?; - granted - .record_response( - response.status, - response.version_ok, - &response.body, - received_at, - ) - .await - .ok()?; - } - None => { - let _ = granted.record_unknown().await; - return None; - } + if let Some(response) = io.acquisition_send(lease, permit).await { + let received_at = io.acquisition_clock()?; + granted + .record_response( + response.status, + response.version_ok, + &response.body, + received_at, + ) + .await + .ok()?; + } else { + let _ = granted.record_unknown().await; + return None; } } crate::AcquisitionClaim::Existing(_) => {} @@ -420,6 +417,7 @@ struct Run<'a, I: SubmitIo> { written: Option<(u16, [u8; 32], Vec, bool)>, refusal: Option<&'static str>, result: Option, + unresolved_prerequisite: Option, in_flight: Option>, } @@ -440,6 +438,7 @@ impl<'a, I: SubmitIo> Run<'a, I> { written: None, refusal: None, result: None, + unresolved_prerequisite: None, in_flight: None, } } @@ -702,10 +701,6 @@ impl Run<'_, I> { self.result = Some(not_entered(code)); ClaimResult::Refused } - Ok(BoundedClaim::Contended) => { - self.result = Some(self.stored_result().await); - ClaimResult::Unavailable - } Err(GatewayAttemptError::Replay) => { self.result = Some(self.stored_result().await); ClaimResult::Replay @@ -714,7 +709,7 @@ impl Run<'_, I> { self.refuse_before_claim(not_entered("gateway.effect.operation-conflict")); ClaimResult::Refused } - Err(_) => { + Ok(BoundedClaim::Contended) | Err(_) => { self.result = Some(self.stored_result().await); ClaimResult::Unavailable } @@ -747,7 +742,7 @@ impl Run<'_, I> { .await } - async fn read_account(&self) -> AccountResult { + async fn read_account(&mut self) -> AccountResult { let Some(pointer) = self .guard .as_ref() @@ -756,6 +751,9 @@ impl Run<'_, I> { return AccountResult::Unavailable; }; let acquired = self.acquire_prerequisite(PrerequisiteKind::Account).await; + if acquired.is_none() { + self.unresolved_prerequisite = Some(PrerequisiteKind::Account); + } account_result( acquired.as_ref().map(|acquired| &acquired.response), pointer, @@ -763,7 +761,7 @@ impl Run<'_, I> { ) } - async fn denied_read(&self, index: usize) -> DeniedResult { + async fn denied_read(&mut self, index: usize) -> DeniedResult { let Some(refused) = self .guard .as_ref() @@ -777,6 +775,9 @@ impl Run<'_, I> { let acquired = self .acquire_prerequisite(PrerequisiteKind::DeniedCapability(index)) .await; + if acquired.is_none() { + self.unresolved_prerequisite = Some(PrerequisiteKind::DeniedCapability(index)); + } denied_result( acquired.as_ref().map(|acquired| &acquired.response), refused, @@ -795,6 +796,7 @@ impl Run<'_, I> { return PreEntryResult::Unavailable; }; let Some(acquired) = self.acquire_prerequisite(PrerequisiteKind::PreEntry).await else { + self.unresolved_prerequisite = Some(PrerequisiteKind::PreEntry); return PreEntryResult::Unavailable; }; let observed_at = acquired.observed_at; @@ -832,6 +834,7 @@ impl Run<'_, I> { .acquire_prerequisite(PrerequisiteKind::RelativeCeiling) .await else { + self.unresolved_prerequisite = Some(PrerequisiteKind::RelativeCeiling); return CeilingRead::Unavailable; }; let read_at = acquired.observed_at; @@ -853,9 +856,8 @@ impl Run<'_, I> { } async fn grant_entry(&mut self) -> bool { - let validation = match self.io.entry_validation() { - Ok(validation) => validation, - Err(_) => return false, + let Ok(validation) = self.io.entry_validation() else { + return false; }; let Some(approved) = &self.verified else { return false; @@ -866,7 +868,7 @@ impl Run<'_, I> { let Some(claim) = self.claim.take() else { return false; }; - let (claim, permit) = match claim + let Ok((claim, permit)) = claim .grant_entry( std::sync::Arc::clone(approved), validation, @@ -874,15 +876,12 @@ impl Run<'_, I> { &self.pre_entry, ) .await - { - Ok(granted) => granted, + else { // The grant may have committed without its acknowledgement. // A fresh authoritative read may report reserved or unknown, never // manufacture a permit. Unavailable state is indeterminate. - Err(_) => { - self.result = Some(self.stored_result().await); - return false; - } + self.result = Some(self.stored_result().await); + return false; }; self.claim = Some(claim); self.permit = Some(permit); @@ -931,6 +930,12 @@ impl Run<'_, I> { } async fn record_not_entered(&mut self, refusal: Refusal) -> bool { + if self.unresolved_prerequisite.is_some() { + // Preserve the durable reservation. Recording a terminal predicate + // failure here could poison a concurrent owner's valid read/write. + self.result = Some(self.stored_result().await); + return false; + } let Some(claim) = self.claim.take() else { return false; }; @@ -964,7 +969,8 @@ impl Run<'_, I> { Stop::NotEntered => self .refusal .map_or(GatewaySubmitResult::Unknown, not_entered), - Stop::Unknown | Stop::Halted => GatewaySubmitResult::Unknown, + Stop::Unknown => self.result.unwrap_or(GatewaySubmitResult::Unknown), + Stop::Halted => GatewaySubmitResult::Unknown, } } } diff --git a/product/runtime/auths-gateway/src/transport.rs b/product/runtime/auths-gateway/src/transport.rs index cca02e982..cbbe5423f 100644 --- a/product/runtime/auths-gateway/src/transport.rs +++ b/product/runtime/auths-gateway/src/transport.rs @@ -826,6 +826,70 @@ mod tests { .collect() } + async fn write_fixture_permit( + recipe: &CompiledRecipe, + arguments: &Value, + ) -> ( + std::sync::Arc, + crate::store::ProviderEntryPermit, + ) { + let command = crate::scenario_tests::admitted( + recipe, + arguments.as_object().expect("arguments"), + [1; 32], + Vec::new(), + 60, + Vec::new(), + 1000, + ) + .expect("command"); + let approved = std::sync::Arc::new( + crate::effect::approve_driver_fixture(command, *recipe.digest(), 1000, None) + .expect("approval"), + ); + let attempts = + crate::store_testkit::TestAttempts::open(crate::store_testkit::Backend::File); + let crate::store::BoundedClaim::Claimed(claim) = attempts + .attempts() + .claim_bounded( + &approved, + 1000, + crate::entry::EntryValidation::Oracle { now: 1000 }, + ) + .await + .expect("claim") + else { + panic!("claim refused") + }; + let (_granted, permit) = claim + .grant_entry( + std::sync::Arc::clone(&approved), + crate::entry::EntryValidation::Oracle { now: 1000 }, + 1000, + &crate::GatewayPreEntry::default(), + ) + .await + .expect("durable grant"); + (approved, permit) + } + + fn assert_idempotency_heads(heads: &[String], recipe: &CompiledRecipe, declared: bool) { + let expected = idempotency_key( + recipe.namespace(), + &LogicalOperationId::parse("run-1").expect("operation"), + ); + let sent = if declared { + vec![expected.as_str()] + } else { + Vec::new() + }; + assert_eq!(idempotency_values(&heads[0]), sent, "declared={declared}"); + assert!( + idempotency_values(&heads[1]).is_empty(), + "the read-back never sends the key" + ); + } + #[tokio::test] async fn write_sends_the_derived_idempotency_key_only_when_declared_and_read_back_never_does() { let lease = test_lease().await; @@ -846,43 +910,7 @@ mod tests { let arguments = json!({"operation_id": "run-1", "record_id": "recTEST0000000001", "replacement": "Approved", "operator_namespace": recipe.namespace().as_str(), "recipe_digest": recipe.digest_hex()}); - let command = crate::scenario_tests::admitted( - &recipe, - arguments.as_object().expect("arguments"), - [1; 32], - Vec::new(), - 60, - Vec::new(), - 1000, - ) - .expect("command"); - let approved = std::sync::Arc::new( - crate::effect::approve_driver_fixture(command, *recipe.digest(), 1000, None) - .expect("approval"), - ); - let attempts = - crate::store_testkit::TestAttempts::open(crate::store_testkit::Backend::File); - let crate::store::BoundedClaim::Claimed(claim) = attempts - .attempts() - .claim_bounded( - &approved, - 1000, - crate::entry::EntryValidation::Oracle { now: 1000 }, - ) - .await - .expect("claim") - else { - panic!("claim refused") - }; - let (_granted, permit) = claim - .grant_entry( - std::sync::Arc::clone(&approved), - crate::entry::EntryValidation::Oracle { now: 1000 }, - 1000, - &crate::GatewayPreEntry::default(), - ) - .await - .expect("durable grant"); + let (approved, permit) = write_fixture_permit(&recipe, &arguments).await; let request = &approved.command().expect("mutation command").request; let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)) .await @@ -952,20 +980,7 @@ mod tests { let heads = provider.await.expect("provider"); assert!(heads[0].starts_with("patch /v0/"), "{}", heads[0]); assert!(heads[1].starts_with("get /v0/"), "{}", heads[1]); - let expected = idempotency_key( - recipe.namespace(), - &LogicalOperationId::parse("run-1").expect("operation"), - ); - let sent = if declared { - vec![expected.as_str()] - } else { - Vec::new() - }; - assert_eq!(idempotency_values(&heads[0]), sent, "declared={declared}"); - assert!( - idempotency_values(&heads[1]).is_empty(), - "the read-back never sends the key" - ); + assert_idempotency_heads(&heads, &recipe, declared); } } diff --git a/product/runtime/auths-gateway/tests/application_content_cli.rs b/product/runtime/auths-gateway/tests/application_content_cli.rs index c34618827..7dc362871 100644 --- a/product/runtime/auths-gateway/tests/application_content_cli.rs +++ b/product/runtime/auths-gateway/tests/application_content_cli.rs @@ -20,7 +20,7 @@ fn serve(listener: UnixListener, reply: Value) -> std::thread::JoinHandle if error.kind() == std::io::ErrorKind::WouldBlock && std::time::Instant::now() < deadline => { - std::thread::sleep(std::time::Duration::from_millis(5)) + std::thread::sleep(std::time::Duration::from_millis(5)); } Err(error) => panic!("CLI did not connect: {error}"), } diff --git a/product/runtime/auths-gateway/tests/application_recovery_cli.rs b/product/runtime/auths-gateway/tests/application_recovery_cli.rs index cdae73c0e..f34b834d5 100644 --- a/product/runtime/auths-gateway/tests/application_recovery_cli.rs +++ b/product/runtime/auths-gateway/tests/application_recovery_cli.rs @@ -47,7 +47,7 @@ fn native_application_recovery_cli_fixture_is_current() { if error.kind() == std::io::ErrorKind::WouldBlock && std::time::Instant::now() < until => { - std::thread::sleep(std::time::Duration::from_millis(5)) + std::thread::sleep(std::time::Duration::from_millis(5)); } Err(error) => panic!("CLI did not connect: {error}"), } diff --git a/product/runtime/auths-gateway/tests/candidate_cli.rs b/product/runtime/auths-gateway/tests/candidate_cli.rs index bef8cb069..ebb9880c8 100644 --- a/product/runtime/auths-gateway/tests/candidate_cli.rs +++ b/product/runtime/auths-gateway/tests/candidate_cli.rs @@ -76,10 +76,205 @@ async fn native_candidate_cli_fixture_is_current() { let policy = auths_gateway::effect::EffectPolicy::new("candidate-cli-test".to_owned(), 1, public) .expect("policy"); + let fixture = rotation_installation(&source, &lock, &trust, &policy, &recipe).await; + let RotationInstallation { + root, + shared, + record, + id, + .. + } = &fixture; + let proposal = competing_staging_processes(root); + let proposal_bytes = std::fs::read(&proposal).expect("proposal"); + assert_eq!( + std::fs::metadata(&proposal) + .expect("metadata") + .permissions() + .mode() + & 0o777, + 0o600 + ); + let target = auths_gateway::effect::CandidateCredentialTarget::from_private_bytes( + &recipe, + &proposal_bytes, + ) + .expect("target"); + assert_eq!( + shared + .load() + .await + .expect("load") + .expect("current") + .record(), + record + ); + let repeat = stage(root, &proposal, b"rk_test_other\n"); + assert!(!repeat.status.success()); + assert_eq!( + std::fs::read(&proposal).expect("same proposal"), + proposal_bytes + ); + let conflict = stage(root, &root.join("conflict.json"), b"rk_test_other\n"); + assert!(!conflict.status.success()); + assert!(!root.join("conflict.json").exists()); + let reopened = PersistentCredentialStore::open(root.join("credentials.cbor")).expect("reopen"); + assert_eq!( + reopened.stored_generations(id).expect("generations"), + vec![NonZeroU64::MIN, NonZeroU64::new(2).expect("two")] + ); + let proposed: Value = serde_json::from_slice(&proposal_bytes).expect("proposal JSON"); + let staged = ConnectionRecord::from_canonical_cbor( + &hex::decode(proposed["candidate"].as_str().expect("hex")).expect("bytes"), + ) + .expect("candidate record"); + assert!(reopened.holds(&staged.credential_binding()).await.is_ok()); + let custody_lock = std::fs::OpenOptions::new() + .read(true) + .write(true) + .open(root.join("credentials.cbor.lock")) + .expect("custody lock"); + custody_lock.try_lock().expect("hold custody fence"); + let blocked = stage(root, &root.join("blocked.json"), b"rk_test_blocked\n"); + assert!(!blocked.status.success()); + assert!(!root.join("blocked.json").exists()); + drop(custody_lock); + assert_call_authoring(root, &proposal, &target, &recipe); + let first_installation = first_installation(&source, &lock, &trust, &policy, &recipe).await; + let fixture = serde_json::to_vec_pretty(&json!({ + "first_installation": first_installation, + "schema": "auths.candidate-cli-fixture/1", "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", + "competing_processes_one_staging_winner": true, "held_custody_fence_refuses_without_proposal": true, + "staged_generation": 2, "current_record_unchanged": true, "proposal_and_call_mode": "0600", + "existing_proposal_refused_without_overwrite": true, "different_secret_same_generation_refused": true, + "reopened_custody_holds_exact_candidate": true, "authored_call_matches_native": true, + "permissive_proposal_refused": true + })).expect("fixture"); + let path = fixtures.join("candidate-cli.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &fixture).expect("fixture write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), fixture); +} + +async fn first_installation( + source: &[u8], + lock: &[u8], + trust: &[u8], + policy: &auths_gateway::effect::EffectPolicy, + recipe: &CompiledRecipe, +) -> Value { + let directory = tempfile::tempdir().expect("installation directory"); + let root = std::fs::canonicalize(directory.path()).expect("path"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); + for (name, bytes) in [ + ("source.json", source), + ("lock.json", lock), + ("trust.cbor", trust), + ( + "policy.json", + policy.to_private_bytes().expect("policy").as_slice(), + ), + ] { + private(&root.join(name), bytes); + } + let state = root.join("state"); + install_candidate_cli(&root, &state, recipe); + let proposal = state.join("candidate-installation.json"); + let bytes = std::fs::read(&proposal).expect("proposal"); + let json: Value = serde_json::from_slice(&bytes).expect("proposal JSON"); + assert!(json["previous"].is_null()); + let candidate = ConnectionRecord::from_canonical_cbor( + &hex::decode(json["candidate"].as_str().expect("candidate hex")).expect("hex"), + ) + .expect("record"); + let shared = SharedConnection::new( + Arc::new(FileGatewayAttemptStore::open(state.join("attempts")).expect("store")), + candidate.provider_kind().clone(), + candidate.alias().clone(), + ); + assert!(shared.load().await.expect("load").is_none()); + let custody = PersistentCredentialStore::open(state.join("credentials.cbor")).expect("custody"); + assert!(custody.holds(&candidate.credential_binding()).await.is_ok()); + auths_gateway::GenerationFloor::new(state.clone()) + .accept(&candidate) + .expect("floor"); + assert_eq!( + auths_gateway::CredentialJournal::new(state.clone()) + .generations(candidate.connection_id()) + .expect("notes"), + vec![NonZeroU64::MIN] + ); + let resume = |out: &Path, secret: &[u8]| { + let mut child = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) + .arg("candidate-stage-installation") + .arg("--state-dir") + .arg(&state) + .arg("--proposal-out") + .arg(out) + .arg("--credential-stdin") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("resume process"); + child + .stdin + .take() + .expect("stdin") + .write_all(secret) + .expect("secret"); + child.wait_with_output().expect("resume output") + }; + let repeated = state.join("resumed.json"); + let result = resume(&repeated, b"rk_test_initial_install\n"); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + assert_eq!(std::fs::read(&repeated).expect("resumed bytes"), bytes); + let conflict = resume(&state.join("conflict.json"), b"rk_test_different\n"); + assert!(!conflict.status.success()); + assert!(!state.join("conflict.json").exists()); + assert!( + !resume(&proposal, b"rk_test_initial_install\n") + .status + .success() + ); + assert_eq!(std::fs::read(&proposal).expect("preserved"), bytes); + for path in [ + &proposal, + &repeated, + &state.join("candidate-installation.cbor"), + ] { + assert_eq!( + std::fs::metadata(path).expect("mode").permissions().mode() & 0o777, + 0o600 + ); + } + assert!(shared.load().await.expect("load").is_none()); + json!({"production_install_stages_without_publication":true,"private_draft_and_proposal":true,"exact_floor_and_cleanup_note":true,"independent_resume_process_reuses_exact_proposal":true,"different_secret_refused":true,"existing_output_preserved":true,"no_approved_provider_execution_claim":true}) +} + +struct RotationInstallation { + _directory: tempfile::TempDir, + root: std::path::PathBuf, + shared: SharedConnection, + record: ConnectionRecord, + id: ConnectionId, +} + +async fn rotation_installation( + source: &[u8], + lock: &[u8], + trust: &[u8], + policy: &auths_gateway::effect::EffectPolicy, + recipe: &CompiledRecipe, +) -> RotationInstallation { let directory = tempfile::tempdir().expect("directory"); let root = std::fs::canonicalize(directory.path()).expect("path"); std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); - let store = Arc::new(FileGatewayAttemptStore::open(&root.join("attempts")).expect("store")); + let store = Arc::new(FileGatewayAttemptStore::open(root.join("attempts")).expect("store")); let attempts = GatewayAttempts::new(store.clone(), policy.clone()).expect("attempts"); let provider = ProviderKind::parse("stripe").expect("provider"); let alias = ConnectionAlias::parse("synthetic").expect("alias"); @@ -102,7 +297,7 @@ async fn native_candidate_cli_fixture_is_current() { id.clone(), SemanticId::parse("auths.gateway-operation/1").expect("contract"), SemanticId::parse("auths.gateway-connection-descriptor/1").expect("schema"), - auths_gateway::GatewayConnectionDescriptor::approve(&recipe, "Authorization") + auths_gateway::GatewayConnectionDescriptor::approve(recipe, "Authorization") .expect("descriptor") .to_bytes() .expect("bytes"), @@ -125,15 +320,47 @@ async fn native_candidate_cli_fixture_is_current() { let journal = auths_gateway::CredentialJournal::new(root.clone()); journal.initialize(&id).expect("journal"); journal.register(&id, NonZeroU64::MIN).expect("note"); + initialize_configuration(recipe, trust, policy, &record, credentials, attempts); + for (name, bytes) in [ + ("recipe.json", &source), + ("profile.lock.json", &lock), + ("trusted.context.cbor", &trust), + ] { + private(&root.join(name), bytes); + } + private(&root.join("installation.json"), &serde_json_canonicalizer::to_vec(&json!({ + "schema": "auths.gateway-installation/6", "recipe_digest": recipe.digest_hex(), + "profile_lock_sha256": hex::encode(Sha256::digest(lock)), "trusted_context_sha256": hex::encode(Sha256::digest(trust)), + "effect_policy": policy, "provider": "stripe", "alias": "synthetic", "deployment": "development", + "operator_attestation_sha256": null, "attempt_store": root.join("attempts"), + "credential_store": {"kind": "local-file-v1"}, "qualification": {"policy": "optional"} + })).expect("manifest")); + RotationInstallation { + _directory: directory, + root, + shared, + record, + id, + } +} + +fn initialize_configuration( + recipe: &CompiledRecipe, + trust: &[u8], + policy: &auths_gateway::effect::EffectPolicy, + record: &ConnectionRecord, + credentials: Arc, + attempts: GatewayAttempts, +) { let engine = GatewayEngine::new( recipe.clone(), *recipe.digest(), - &trust, + trust, policy.clone(), - provider, - alias, + record.provider_kind().clone(), + record.alias().clone(), "gateway".to_owned(), - profile, + record.allowed_profiles()[0].clone(), credentials, attempts, ) @@ -160,24 +387,13 @@ async fn native_candidate_cli_fixture_is_current() { engine .initialize_effect_configuration() .expect("configuration"); - for (name, bytes) in [ - ("recipe.json", &source), - ("profile.lock.json", &lock), - ("trusted.context.cbor", &trust), - ] { - private(&root.join(name), bytes); - } - private(&root.join("installation.json"), &serde_json_canonicalizer::to_vec(&json!({ - "schema": "auths.gateway-installation/6", "recipe_digest": recipe.digest_hex(), - "profile_lock_sha256": hex::encode(Sha256::digest(&lock)), "trusted_context_sha256": hex::encode(Sha256::digest(&trust)), - "effect_policy": policy, "provider": "stripe", "alias": "synthetic", "deployment": "development", - "operator_attestation_sha256": null, "attempt_store": root.join("attempts"), - "credential_store": {"kind": "local-file-v1"}, "qualification": {"policy": "optional"} - })).expect("manifest")); +} + +fn competing_staging_processes(root: &Path) -> std::path::PathBuf { let first_path = root.join("candidate-a.json"); let second_path = root.join("candidate-b.json"); - let mut first = spawn_stage(&root, &first_path); - let mut second = spawn_stage(&root, &second_path); + let mut first = spawn_stage(root, &first_path); + let mut second = spawn_stage(root, &second_path); first .stdin .take() @@ -199,71 +415,26 @@ async fn native_candidate_cli_fixture_is_current() { String::from_utf8_lossy(&first.stderr), String::from_utf8_lossy(&second.stderr) ); - let proposal = if first.status.success() { + if first.status.success() { first_path } else { second_path - }; - let proposal_bytes = std::fs::read(&proposal).expect("proposal"); - assert_eq!( - std::fs::metadata(&proposal) - .expect("metadata") - .permissions() - .mode() - & 0o777, - 0o600 - ); - let target = auths_gateway::effect::CandidateCredentialTarget::from_private_bytes( - &recipe, - &proposal_bytes, - ) - .expect("target"); - assert_eq!( - shared - .load() - .await - .expect("load") - .expect("current") - .record(), - &record - ); - let repeat = stage(&root, &proposal, b"rk_test_other\n"); - assert!(!repeat.status.success()); - assert_eq!( - std::fs::read(&proposal).expect("same proposal"), - proposal_bytes - ); - let conflict = stage(&root, &root.join("conflict.json"), b"rk_test_other\n"); - assert!(!conflict.status.success()); - assert!(!root.join("conflict.json").exists()); - let reopened = PersistentCredentialStore::open(root.join("credentials.cbor")).expect("reopen"); - assert_eq!( - reopened.stored_generations(&id).expect("generations"), - vec![NonZeroU64::MIN, NonZeroU64::new(2).expect("two")] - ); - let proposed: Value = serde_json::from_slice(&proposal_bytes).expect("proposal JSON"); - let staged = ConnectionRecord::from_canonical_cbor( - &hex::decode(proposed["candidate"].as_str().expect("hex")).expect("bytes"), - ) - .expect("candidate record"); - assert!(reopened.holds(&staged.credential_binding()).await.is_ok()); - let custody_lock = std::fs::OpenOptions::new() - .read(true) - .write(true) - .open(root.join("credentials.cbor.lock")) - .expect("custody lock"); - custody_lock.try_lock().expect("hold custody fence"); - let blocked = stage(&root, &root.join("blocked.json"), b"rk_test_blocked\n"); - assert!(!blocked.status.success()); - assert!(!root.join("blocked.json").exists()); - drop(custody_lock); + } +} + +fn assert_call_authoring( + root: &Path, + proposal: &Path, + target: &auths_gateway::effect::CandidateCredentialTarget, + recipe: &CompiledRecipe, +) { let call_out = root.join("call.json"); let call = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) .arg("effect-candidate-call") .arg("--state-dir") - .arg(&root) + .arg(root) .arg("--candidate") - .arg(&proposal) + .arg(proposal) .arg("--operation") .arg("candidate-cli-1") .arg("--call-out") @@ -277,7 +448,7 @@ async fn native_candidate_cli_fixture_is_current() { ); let expected = target .authorization_call( - &recipe, + recipe, &auths_gateway::LogicalOperationId::parse("candidate-cli-1").expect("operation"), ) .expect("call"); @@ -293,17 +464,17 @@ async fn native_candidate_cli_fixture_is_current() { & 0o777, 0o600 ); - let mut wide = std::fs::metadata(&proposal) + let mut wide = std::fs::metadata(proposal) .expect("proposal mode") .permissions(); wide.set_mode(0o644); - std::fs::set_permissions(&proposal, wide).expect("wide mode"); + std::fs::set_permissions(proposal, wide).expect("wide mode"); let refused = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) .arg("effect-candidate-call") .arg("--state-dir") - .arg(&root) + .arg(root) .arg("--candidate") - .arg(&proposal) + .arg(proposal) .arg("--operation") .arg("candidate-cli-2") .arg("--call-out") @@ -312,49 +483,13 @@ async fn native_candidate_cli_fixture_is_current() { .expect("refusal CLI"); assert!(!refused.status.success()); assert!(!root.join("refused.json").exists()); - let first_installation = first_installation(&source, &lock, &trust, &policy, &recipe).await; - let fixture = serde_json::to_vec_pretty(&json!({ - "first_installation": first_installation, - "schema": "auths.candidate-cli-fixture/1", "scope": "production staging and call-authoring CLI with real file custody, cleanup journal and generation floor; synthetic installation/trust; no approved provider acquisition or publication claim", - "competing_processes_one_staging_winner": true, "held_custody_fence_refuses_without_proposal": true, - "staged_generation": 2, "current_record_unchanged": true, "proposal_and_call_mode": "0600", - "existing_proposal_refused_without_overwrite": true, "different_secret_same_generation_refused": true, - "reopened_custody_holds_exact_candidate": true, "authored_call_matches_native": true, - "permissive_proposal_refused": true - })).expect("fixture"); - let path = fixtures.join("candidate-cli.json"); - if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { - std::fs::write(&path, &fixture).expect("fixture write"); - } - assert_eq!(std::fs::read(path).expect("fixture"), fixture); } -async fn first_installation( - source: &[u8], - lock: &[u8], - trust: &[u8], - policy: &auths_gateway::effect::EffectPolicy, - recipe: &CompiledRecipe, -) -> Value { - let directory = tempfile::tempdir().expect("installation directory"); - let root = std::fs::canonicalize(directory.path()).expect("path"); - std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("mode"); - for (name, bytes) in [ - ("source.json", source), - ("lock.json", lock), - ("trust.cbor", trust), - ( - "policy.json", - policy.to_private_bytes().expect("policy").as_slice(), - ), - ] { - private(&root.join(name), bytes); - } - let state = root.join("state"); +fn install_candidate_cli(root: &Path, state: &Path, recipe: &CompiledRecipe) { let mut child = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) .arg("install") .arg("--state-dir") - .arg(&state) + .arg(state) .arg("--recipe") .arg(root.join("source.json")) .arg("--profile-lock") @@ -391,79 +526,4 @@ async fn first_installation( "{}", String::from_utf8_lossy(&output.stderr) ); - let proposal = state.join("candidate-installation.json"); - let bytes = std::fs::read(&proposal).expect("proposal"); - let json: Value = serde_json::from_slice(&bytes).expect("proposal JSON"); - assert!(json["previous"].is_null()); - let candidate = ConnectionRecord::from_canonical_cbor( - &hex::decode(json["candidate"].as_str().expect("candidate hex")).expect("hex"), - ) - .expect("record"); - let shared = SharedConnection::new( - Arc::new(FileGatewayAttemptStore::open(&state.join("attempts")).expect("store")), - candidate.provider_kind().clone(), - candidate.alias().clone(), - ); - assert!(shared.load().await.expect("load").is_none()); - let custody = PersistentCredentialStore::open(state.join("credentials.cbor")).expect("custody"); - assert!(custody.holds(&candidate.credential_binding()).await.is_ok()); - auths_gateway::GenerationFloor::new(state.clone()) - .accept(&candidate) - .expect("floor"); - assert_eq!( - auths_gateway::CredentialJournal::new(state.clone()) - .generations(candidate.connection_id()) - .expect("notes"), - vec![NonZeroU64::MIN] - ); - let resume = |out: &Path, secret: &[u8]| { - let mut child = Command::new(env!("CARGO_BIN_EXE_auths-gateway")) - .arg("candidate-stage-installation") - .arg("--state-dir") - .arg(&state) - .arg("--proposal-out") - .arg(out) - .arg("--credential-stdin") - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn() - .expect("resume process"); - child - .stdin - .take() - .expect("stdin") - .write_all(secret) - .expect("secret"); - child.wait_with_output().expect("resume output") - }; - let repeated = state.join("resumed.json"); - let result = resume(&repeated, b"rk_test_initial_install\n"); - assert!( - result.status.success(), - "{}", - String::from_utf8_lossy(&result.stderr) - ); - assert_eq!(std::fs::read(&repeated).expect("resumed bytes"), bytes); - let conflict = resume(&state.join("conflict.json"), b"rk_test_different\n"); - assert!(!conflict.status.success()); - assert!(!state.join("conflict.json").exists()); - assert!( - !resume(&proposal, b"rk_test_initial_install\n") - .status - .success() - ); - assert_eq!(std::fs::read(&proposal).expect("preserved"), bytes); - for path in [ - &proposal, - &repeated, - &state.join("candidate-installation.cbor"), - ] { - assert_eq!( - std::fs::metadata(path).expect("mode").permissions().mode() & 0o777, - 0o600 - ); - } - assert!(shared.load().await.expect("load").is_none()); - json!({"production_install_stages_without_publication":true,"private_draft_and_proposal":true,"exact_floor_and_cleanup_note":true,"independent_resume_process_reuses_exact_proposal":true,"different_secret_refused":true,"existing_output_preserved":true,"no_approved_provider_execution_claim":true}) } diff --git a/product/runtime/auths-gateway/tests/candidate_journey.rs b/product/runtime/auths-gateway/tests/candidate_journey.rs index 6f02671a1..3b7663a17 100644 --- a/product/runtime/auths-gateway/tests/candidate_journey.rs +++ b/product/runtime/auths-gateway/tests/candidate_journey.rs @@ -1,6 +1,6 @@ //! Real CLI processes, native signatures, file custody/journal and a counting //! local HTTP provider. Fixed public test keys simulate the external reviewer; -//! this is no human-presence, live-provider, isolation or PostgreSQL claim. +//! this is no human-presence, live-provider, isolation or `PostgreSQL` claim. #![cfg(all(unix, feature = "testkit-harness", feature = "loopback-provider"))] use auths_connections::{ConnectionAlias, ConnectionRecord, ProviderKind}; diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index 4d9a64f5b..b8fd135e7 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -1,6 +1,6 @@ //! Production daemon and client processes with native proof/approval and a real //! counting HTTP double. Public fixed keys simulate reviewer/agent/recipient; -//! this is not human-presence, UID isolation, installed-language or PostgreSQL evidence. +//! this is not human-presence, UID isolation, installed-language or `PostgreSQL` evidence. #![cfg(all(unix, feature = "testkit-harness", feature = "loopback-provider"))] use auths_gateway::{ @@ -13,6 +13,7 @@ use auths_gateway::{ harness::authoring::{tool_fixture, tools_context}, }; use auths_profile_mcp::McpToolCall; +use base64ct::{Base64UrlUnpadded, Encoding as _}; use ed25519_dalek::{Signer as _, SigningKey}; use serde_json::{Value, json}; use std::{ @@ -315,7 +316,7 @@ fn approve( EffectApprovalRequest::from_private_bytes(&std::fs::read(&request).expect("request")) .expect("native signing request"); let message = signing.signing_message().expect("message"); - assert_eq!(review["signing_message_hex"], hex::encode(&message)); + assert_eq!(review["signing_message_hex"], hex::encode(message)); private( &approval, &success(cli( @@ -367,7 +368,6 @@ fn recipient_without_ack_process() { }; let root = PathBuf::from(root); let state = root.join("state"); - use base64ct::{Base64UrlUnpadded, Encoding as _}; let request = auths_gateway::app::AppDisclosure { schema: auths_gateway::app::APP_DISCLOSURE_SCHEMA.to_owned(), target: serde_json::from_slice(&std::fs::read(root.join("target.json")).expect("target")) diff --git a/product/tools/auths-openapi-derive/tests/corpus.rs b/product/tools/auths-openapi-derive/tests/corpus.rs index bb12c82f8..be3f1e1a0 100644 --- a/product/tools/auths-openapi-derive/tests/corpus.rs +++ b/product/tools/auths-openapi-derive/tests/corpus.rs @@ -102,7 +102,7 @@ fn check_file(path: &Path, actual: &str) { assert_eq!(expected, actual, "{} differs", path.display()); } -/// Test-only semantic declarations, independent of the untrusted OpenAPI text. +/// Test-only semantic declarations, independent of the untrusted `OpenAPI` text. /// They permit compiler/differential tests, not installed human-review claims. fn complete_synthetic_review(recipe: &[u8]) -> Vec { let mut value: Value = serde_json::from_slice(recipe).unwrap(); diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index dab2b9c84..a273284e6 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 392 +freeze_version = 393 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -19,7 +19,7 @@ freeze_version = 392 "auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 60 "auths.frozen-bytes/formal/qualification/aeneas/generated" = 19 "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 16 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 102 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 103 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -45,7 +45,7 @@ freeze_version = 392 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 138 +"auths.identity.protocol" = 139 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 124 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 392 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 135 +"auths.product.public-sdk-contract" = 136 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 -"auths.release.evolution-contract" = 81 -"auths.release.public-surface" = 392 +"auths.release.evolution-contract" = 82 +"auths.release.public-surface" = 393 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index ad74e4ffe..2a3afb8fa 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 392, + "freezeVersion": 393, "publicSurface": { "rustRoots": [ "auths", @@ -238,7 +238,7 @@ }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 102, + "version": 103, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "e0d7b1b305ab8377a2126ac68c3271a07c8a17b960114e6a428d3a3c67b4c2ee" + "sha256": "0b3d14c09cc6c50e6c6d9d1167447d6ac46d745e6d41014ef40d889ac5c0ff91" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 138, + "version": 139, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "74036623cbc194bc962b80cdc9a26027202836c51a279ed03f372df42f7cd473" + "sha256": "a54efb0206b19e48d9f26a295cd3e8b1657057edea21c3efaea8d2c1d059dda0" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 135, + "version": 136, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "db2459807340c9aa3d0ea76dafd6018685c30678e1a908b36d73cd10cd31d7a8" + "sha256": "415904ac0bf46f0d5bdf2a15ba4eaddef29a1706e6deccf8b41d4da0822bf7ee" }, { "id": "auths.product.receipts", @@ -986,7 +986,7 @@ }, { "id": "auths.release.evolution-contract", - "version": 81, + "version": 82, "classification": "frozen-meaning", "categories": [ "version-axes", @@ -1007,11 +1007,11 @@ "release/fixtures/evolution", "xtask/src/evolution_policy.rs" ], - "sha256": "03adbcadcbbc9426f3be6add48e7be41e1ea12a2feed62bfa67befc3b2e899fc" + "sha256": "331714ab88c45d0bf818fa3610503e6cc86d228cdbdcf57aa20d8faf0fc34948" }, { "id": "auths.release.public-surface", - "version": 392, + "version": 393, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "eb046187abd685bec8238ba3e69f823b5cedb14ab13fdce7a19d2872fd121f2a" + "sha256": "b24f958b71cbff00bed20da6b21cdeaf3dd9227ce95db4f50fabcf61ab3b57d9" } ] } From 4408f5981a0d3ebc4a5bed2450ba3ea380051e1e Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 00:48:55 +0000 Subject: [PATCH 069/136] fix(demos): require native approvals and explicit recovery reads --- compliance.toml | 28 ++- demos/airtable-gateway/README.md | 39 ++- demos/airtable-gateway/app.py | 62 ++++- demos/airtable-gateway/contract.json | 2 +- demos/airtable-gateway/operate.py | 286 +++++++++++++++++++++- demos/airtable-gateway/selftest.py | 168 +++++++++++-- demos/airtable-gateway/submit.mts | 4 +- demos/airtable-gateway/tests/browser.py | 4 +- demos/airtable-gateway/web/app.js | 10 +- demos/airtable-gateway/web/index.html | 6 +- demos/airtable-gateway/web/styles.css | 2 + demos/stripe-gateway/README.md | 35 ++- demos/stripe-gateway/app.py | 62 ++++- demos/stripe-gateway/contract.json | 2 +- demos/stripe-gateway/operate.py | 287 ++++++++++++++++++++++- demos/stripe-gateway/selftest.py | 145 ++++++++++-- demos/stripe-gateway/submit.mts | 4 +- demos/stripe-gateway/tests/browser.py | 4 +- demos/stripe-gateway/web/app.js | 10 +- demos/stripe-gateway/web/index.html | 2 +- demos/stripe-gateway/web/styles.css | 2 + docs/plans/0074-implementation-status.md | 102 ++++++++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 24 files changed, 1172 insertions(+), 116 deletions(-) diff --git a/compliance.toml b/compliance.toml index b9075cd3f..cd3987cb2 100644 --- a/compliance.toml +++ b/compliance.toml @@ -2121,19 +2121,23 @@ kind = "npm" layer = "demos" path = "demos/stripe-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3"] -wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1"] +wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport"] fixture_suites = ["demos/stripe-gateway", "qualification/simulation/live/stripe-platform"] principal_families = ["raw-key-v1"] signature_families = ["ed25519-v1"] profiles = ["auths.mcp/2", "stripe-platform-refund-v1"] transports = ["unix", "http-local-demo", "https-provider-test-mode"] -configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket"] -security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history"] +configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel"] +security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history"] [packages.auths-stripe-gateway-demo.claims] demo-conformance-fixture = ["demos/stripe-gateway/selftest.py#test_native_refusals_replay_race_and_loss"] -runtime-enforcement-boundary = ["demos/stripe-gateway/selftest.py#test_application_isolation_and_native_audit"] +runtime-enforcement-boundary = [ + "demos/stripe-gateway/selftest.py#test_application_isolation_and_native_audit", + "demos/stripe-gateway/selftest.py#test_private_reviewer_refuses_unlisted_inputs", + "demos/stripe-gateway/selftest.py#test_exact_operator_consent_binding", +] receipt-producer-consumer = ["demos/stripe-gateway/tests/browser.py#test_packaged_workbench_and_unsigned_evidence"] [packages.auths-airtable-gateway-demo] @@ -2141,19 +2145,23 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3"] -wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1"] +wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] signature_families = ["ed25519-v1"] profiles = ["auths.mcp/2", "airtable-record-update-v1"] transports = ["unix", "http-local-demo", "https-provider-disposable-table"] -configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket"] -security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history"] +configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel"] +security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history"] [packages.auths-airtable-gateway-demo.claims] demo-conformance-fixture = ["demos/airtable-gateway/selftest.py#test_native_refusals_replay_race_and_loss"] -runtime-enforcement-boundary = ["demos/airtable-gateway/selftest.py#test_application_isolation_and_native_audit"] +runtime-enforcement-boundary = [ + "demos/airtable-gateway/selftest.py#test_application_isolation_and_native_audit", + "demos/airtable-gateway/selftest.py#test_private_reviewer_refuses_unlisted_inputs", + "demos/airtable-gateway/selftest.py#test_exact_operator_consent_binding", +] receipt-producer-consumer = ["demos/airtable-gateway/tests/browser.py#test_packaged_workbench_and_unsigned_evidence"] [packages.auths-google-employee-delegation-demo] diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index 247fcad38..4b74da91b 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -2,7 +2,7 @@ The maintained monorepo demo uses a fixed-table, data-only recipe and installed public Python/TypeScript SDKs. The application has its own signing key and sends -proof/action bytes to the gateway socket. Only the operator and gateway hold +proof/action/exact-approval bytes to the gateway socket. Only the operator and gateway hold provider credentials. The older field-lab `airtable-cli` app-owned-PAT mode is a self-hosted reference; its token holder can bypass enforcement. @@ -15,6 +15,32 @@ The workbench shows the native review fields and includes insufficient-quorum and duplicate-response cases. This local simulator is integration evidence, not a human approval inbox: simulator state or a UI click never authorizes an action. +The operator additionally requests the complete native exact-effect review and +signs its canonical request. Simulation supplies this signature from a separate +operator-only ephemeral development key. The app forwards the approval unchanged; +it holds neither that key nor the private actor used for candidate/recovery reads. +Credential-checking installs stage a candidate, acquire separately authorized +checks, and publish from retained evidence before peers join. Adding the software +observer requires explicit native configuration review and CAS activation. + +A write returns `response-recorded` when its HTTP response is retained. Choose +**Separately approve and observe the exact operation** to authorize a distinct +read. Its native report separates original-write facts, read charges and evidence +disposition. Replaying a mutation returns retained facts without a read or write; +unknown outcomes never cause an automatic read, resend or refund. + +Live mode never uses the scripted exact-effect reviewer. Startup and each new +recovery read pause for at most ten minutes on an owner-only consent FIFO. In a +separate trusted operator shell, use `docker exec CONTAINER cat REVIEW_PATH` to +read the **entire** `literal-review.txt` and its `literal-review.json` signing +request at the private paths printed by the operator. After +checking its exact destination, units, consequences and signing request, use +`docker exec CONTAINER sh -c 'printf "approve OPERATION\n" > CONSENT_PATH'` with +the exact operation and consent path printed there. The application UID cannot +read or write this private channel. Missing or different consent fails closed. +This is local Docker-operator development custody, not a remote human approval +inbox, independent-human trial or production signing-custody claim. + ## Source-free local demo Download `airtable-gateway-demo.tgz` and its checksum from the **Airtable gateway @@ -40,8 +66,9 @@ actual gateway audit-bundle format. Missing evidence remains missing. Default mode is clearly labeled **simulation**. An independent HTTP double counts real native reads and PATCH entries; it never reaches Airtable. Two -native processes race through one operation store; a third uses a fresh -challenge. Each installation independently checks its custody setup. The web +native processes race through one operation store; a third joins the same +connection, trust and configuration with independent custody. Substituting a +fresh challenge is refused under the unchanged installed trust. The web app runs as UID 62004/GID 62005; private state/root/observer keys remain root-only. The source recipe is the reviewed Airtable fixture with exactly the fixed base/table substitutions authorized by the release reference. The shipping @@ -59,9 +86,9 @@ does not establish a linked observation. **Lose PATCH response** actually drops the socket after the provider applies the write. The result stays unknown while fresh reads lack its value/echo. The original proof/action replay returns retained history without another read -or PATCH. The demo's recovery UI still needs the AP074 independent read-authority -cutover; it must not be treated as evidence of the completed recovery journey. -Fresh observations require a new native bounded read proof and exact approval. +or PATCH. The recovery UI explicitly requests a new native bounded read proof +and exact approval from the separate operator channel; its tagged native report +retains the original write stage and the independently charged read facts. There is no automatic recovery or write retry. **Competing writer** makes a second actual HTTP actor write the same value with diff --git a/demos/airtable-gateway/app.py b/demos/airtable-gateway/app.py index f23d58181..841457936 100644 --- a/demos/airtable-gateway/app.py +++ b/demos/airtable-gateway/app.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Application: public SDK authoring and proof/action-only gateway submission.""" +"""Application: public SDK authoring and proof/action/exact-approval gateway submission.""" import argparse import asyncio from dataclasses import asdict, dataclass @@ -7,6 +7,8 @@ import os from pathlib import Path import secrets +import socket +import struct import threading import time from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer @@ -29,7 +31,7 @@ 'lost-response', 'competing-writer', 'rate-limit', 'provider-error', 'malformed-response', 'oversized-response', 'encoded-segment', 'typescript-positive', 'crash-before', 'crash-after', 'approval-insufficient') -EXPERIMENTS = LABELS + ('replay', 'fresh-replay', 'observe', 'typescript', 'recover-loss', 'recover-competing') +EXPERIMENTS = tuple('recover-' + label for label in LABELS) + LABELS + ('replay', 'fresh-replay', 'observe', 'typescript', 'recover-loss', 'recover-competing') EXPERIMENTS += ('approval-duplicate',) FAULTS = ('lost-response', 'competing-writer', 'rate-limit', 'provider-error', 'malformed-response', 'oversized-response') @@ -103,7 +105,7 @@ def summary(self): 'effect': 'Set DemoStatus and action-derived auths_echo; no compare-and-swap', 'grant_limits': {'budgets': 'No numeric budget capability in this reviewed profile'}, 'experiments': [value for value in EXPERIMENTS if value not in OPERATOR_CASES], - 'approval': self.plan['approval'], + 'approval': self.plan['approval'], 'effect_review': self.plan['effect_review'], 'sdk_version': importlib.metadata.version('auths'), 'proposals': {label: case['arguments'] for label, case in self.plan['cases'].items()}, 'records': self.records[-64:]} @@ -163,6 +165,7 @@ async def packet(self, label, *, fresh=False): async def exchange(self, packet, host=0, *, typescript=False): proof, action, operation = packet + approval = unb64(self.plan['effect_approvals'][operation]) if typescript: completed = await asyncio.create_subprocess_exec( '/usr/local/bin/node', str(HERE / 'submit.mjs'), @@ -171,12 +174,13 @@ async def exchange(self, packet, host=0, *, typescript=False): stderr=asyncio.subprocess.DEVNULL, env={'PATH': '/usr/local/bin:/usr/bin:/bin'}) output, _ = await asyncio.wait_for(completed.communicate( - canonical({'proof_b64': b64(proof), 'action_b64': b64(action)})), 60) + canonical({'proof_b64': b64(proof), 'action_b64': b64(action), + 'approval_b64': b64(approval)})), 60) require(completed.returncode == 0 and len(output) <= 65536, 'demo.typescript-unavailable') result = decode(output) else: try: - result = asdict(await self.clients[host].submit(proof=proof, action=action)) + result = asdict(await self.clients[host].submit(proof=proof, action=action, approval=approval)) except GatewayProtocolError: # The IPC request may have entered. Never retry automatically. result = {'outcome': 'transport-unconfirmed', 'code': 'demo.gateway-unavailable'} @@ -207,8 +211,56 @@ async def remember(self, packet, record): self.approval_responses.append({'operation_id': operation, 'response': response}) recorded.add((operation, response)) + async def recover(self, source): + """Request independent operator consent, then submit its native read proof.""" + require(source in self.plan['cases'], 'demo.unknown-recovery-source') + def request_review(): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as channel: + channel.settimeout(660 if self.plan['mode'] == 'live' else 90) + channel.connect(str(self.sockets[0].parent / 'review.sock')) + payload = canonical({'source': source}) + channel.sendall(struct.pack('>I', len(payload)) + payload) + def receive(length): + output = b'' + while len(output) < length: + block = channel.recv(length - len(output)) + require(bool(block), 'demo.review-response-incomplete') + output += block + return output + length = struct.unpack('>I', receive(4))[0] + require(0 < length <= 4 * 1024 * 1024, 'demo.review-response-bound') + return decode(receive(length)) + approved = await asyncio.to_thread(request_review) + if set(approved) == {'code'}: + return {'operation_id': source, 'language': 'python', 'result': { + 'outcome': 'not-submitted', 'code': 'demo.operator-recovery-review-refused'}} + require(set(approved) == {'proof', 'action', 'approval', 'literal_review'}, + 'demo.operator-review-unavailable') + raw = await self.clients[0].recover(source, proof=unb64(approved['proof']), + action=unb64(approved['action']), approval=unb64(approved['approval'])) + report = decode(raw) + require(report.get('outcome') in ('recovery-report', 'refused'), 'demo.recovery-refused') + # The native report is retained unchanged. The UI label does not infer + # an observation or causation from a provider response. + return {'operation_id': source, 'language': 'python', 'result': { + **report, 'literal_review': approved['literal_review']}} + async def execute(self, experiment): require(experiment in EXPERIMENTS, 'demo.unknown-experiment') + if experiment.startswith('recover-'): + source = experiment[len('recover-'):] + source = {'loss': 'lost-response', 'competing': 'competing-writer'}.get(source, source) + record = await self.recover(source) + result = {'schema': 'auths.airtable-gateway-demo-result/1', + 'experiment': experiment, 'action': self.plan['cases'][source]['arguments'], + 'records': [record], 'decided_by': ('operator-review' + if record['result']['outcome'] == 'not-submitted' else 'gateway'), + 'production_qualified': False, + 'display_signature': 'unsigned', 'recorded_at': int(time.time())} + require(len(self.records) < 256, 'demo.session-full') + self.records.append(result) + write(self.directory / 'results.json', canonical(self.records)) + return result if experiment == 'approval-duplicate': records = [self.approval_duplicate()] result = {'schema': 'auths.airtable-gateway-demo-result/1', 'experiment': experiment, diff --git a/demos/airtable-gateway/contract.json b/demos/airtable-gateway/contract.json index 586ed9f5c..bc86f33d2 100644 --- a/demos/airtable-gateway/contract.json +++ b/demos/airtable-gateway/contract.json @@ -2,7 +2,7 @@ "schema": "auths.gateway-demo-contract/1", "platform": "airtable", "family": "airtable-record-update-v1", - "application_boundary": "installed public GatewayClient; proof and action only", + "application_boundary": "installed public GatewayClient; proof, action and native exact-effect approval", "recipe_source": "bindings/fixtures/gateway/airtable/recipe.json; fixed base/table reviewed by qualification/reference/airtable_record.py", "profile_source": "bindings/fixtures/gateway/airtable/profile.toml", "qualification_workflow": ".github/workflows/recipe-qualification.yml", diff --git a/demos/airtable-gateway/operate.py b/demos/airtable-gateway/operate.py index 9e083cac7..6fd0ba04b 100644 --- a/demos/airtable-gateway/operate.py +++ b/demos/airtable-gateway/operate.py @@ -2,22 +2,31 @@ """Separate operator: disposable resources, independent trust, gateway installation.""" import argparse import asyncio +from dataclasses import dataclass import os import re from pathlib import Path import secrets import signal +import socketserver +import struct +import threading import subprocess import sys import time +from typing import Optional -from auths.authoring import approval_requests, approve, open_approval_request, propose_mcp_approval -from auths.self_hosted import (ApprovalRequirement, ApproverAnchor, AssurancePolicy, +from auths.adapters.custody import PublicControlEvidence +from auths.authoring import (GrantEvidence, approval_requests, approve, collect_approvals, + open_approval_request, propose_mcp_approval, sign_approval_action) +from auths.testkit import development_ed25519_identity_key +from auths.self_hosted import (ExactMcpTool, StringField, IntegerField, OptionalField, + ApprovalRequirement, ApproverAnchor, AssurancePolicy, AssuranceRequirement, Permission, Profile, TrustAnchor, TrustedContextRequest, author_root_grant, compile_trusted_context, load_signer_file) from demo_common import Refusal, b64, canonical, decode, digest, read, require, unb64, write -from app import LABELS, approval_target +from app import Application, LABELS, approval_target HERE = Path(__file__).resolve().parent HOME = Path('/run/demo') @@ -27,6 +36,7 @@ APP_UID, APP_GID = 62004, 62005 ENVIRONMENT = {'PATH': '/opt/consumer/bin:/usr/local/bin:/usr/bin:/bin', 'PYTHONNOUSERSITE': '1'} MANAGERS = ('manager-a', 'manager-b', 'manager-c') +READ_TOOLS = ('auths_gateway_candidate_check_v1', 'auths_gateway_recovery_read_v1') APPROVALS_REQUIRED = 2 ACTION_VALIDITY_SECONDS = 1800 @@ -75,7 +85,7 @@ async def authority(binary, resources, directory, mode): app.mkdir(mode=0o700) require(private.is_dir() and not private.is_symlink() and private.stat().st_uid == 0 and private.stat().st_mode & 0o777 == 0o700, 'demo.operator-private-directory-required') - for name, parent in [('root', private), ('actor', app), + for name, parent in [('root', private), ('reader', private), ('actor', app), *((name, private) for name in MANAGERS)]: write(parent / (name + '.seed'), secrets.token_bytes(32), new=True) write(parent / (name + '.json'), canonical({'schema': 'auths.approval-signer/1', @@ -88,6 +98,8 @@ async def authority(binary, resources, directory, mode): now, expires = int(time.time()), int(time.time()) + 3600 audience = 'mcp://airtable-gateway-demo' permission = Permission('tools/call', audience + '/tools/set_demo_status_v1') + permissions = (permission,) + tuple(Permission('tools/call', audience + '/tools/' + tool) + for tool in READ_TOOLS) policy = AssurancePolicy('raw-key-baseline', tuple(AssuranceRequirement(*row) for row in [ ('root', 'every', 'self-certifying-identifier'), ('actor', 'every', 'self-certifying-identifier'), @@ -102,7 +114,7 @@ async def authority(binary, resources, directory, mode): {'type': item.evidence_type, 'media_type': item.media_type, 'bytes': b64(item.bytes)} for item in grant.evidence]} anchors = [TrustAnchor('operator-root', root.descriptor.principal, ('raw-key-v1',), - (Profile('auths.mcp', 2),), (permission,), (audience,), (audience,), + (Profile('auths.mcp', 2),), permissions, (audience,), (audience,), now - 3600, expires, 1, 'raw-key-baseline')] approver_principals = tuple(managers[name].descriptor.principal for name in MANAGERS) options = {'anchors': anchors, 'assurance': policy, @@ -112,6 +124,17 @@ async def authority(binary, resources, directory, mode): now - 3600, expires) for principal in approver_principals), 'approval_requirements': (ApprovalRequirement(approver_principals, APPROVALS_REQUIRED),)} + reader = load_signer_file(private / 'reader.json').signer + try: + read_grant = await author_root_grant(signer=root, subject=reader.descriptor.principal, + profile=Profile('auths.mcp', 2), permissions=permissions[1:], audiences=[audience], + not_before=now - 3600, expires_at=expires, remaining_depth=0, + assurance_floor='raw-key-baseline', requested_at=now) + write(private / 'read-grant.json', canonical({'bytes': b64(read_grant.signed_grant), + 'evidence': [{'type': item.evidence_type, 'media_type': item.media_type, + 'bytes': b64(item.bytes)} for item in read_grant.evidence]}), new=True) + finally: + await reader.aclose() template = compile_trusted_context(**options) challenges = [secrets.token_bytes(32), secrets.token_bytes(32)] contexts = [compile_trusted_context(**options, @@ -184,6 +207,76 @@ async def approval_bundle(label, *, fresh=False): await signer.aclose() +@dataclass(frozen=True) +class CandidateCheck: + operation_id: str + operator_namespace: str + recipe_digest: str + candidate_connection: str + expected_previous: Optional[str] + read_contract: str + maximum_response_bytes: int + + +@dataclass(frozen=True) +class RecoveryRead: + operation_id: str + operator_namespace: str + recipe_digest: str + source_effect: str + source_operation: str + read_contract: str + maximum_response_bytes: int + + +def read_contract(call): + """Closed transport shape only; the native gateway owns every read binding.""" + name = call['name'] + require(name in READ_TOOLS, 'demo.unlisted-read-tool') + command_type = CandidateCheck if name == READ_TOOLS[0] else RecoveryRead + fields = {key: StringField(min_length=1, max_length=128) + for key in command_type.__annotations__} + fields['maximum_response_bytes'] = IntegerField(1, 1048576) + if command_type is CandidateCheck: + fields['expected_previous'] = OptionalField(StringField(min_length=64, max_length=64)) + contract = ExactMcpTool(service=call['service'], name=name, + command_type=command_type, fields=fields) + return contract, contract.validate_arguments(call['arguments']) + + +def operator_consent(directory, name): + """Bounded owner-only consent for the already saved exact native review. + + The Docker operator reads the complete literal review and signing request + and writes one exact token to this private FIFO. The app cannot access it. + This is development custody, not an authenticated remote approval inbox. + """ + consent = directory / 'consent' + os.mkfifo(consent, mode=0o600) + descriptor = os.open(consent, os.O_RDONLY | os.O_NONBLOCK | os.O_NOFOLLOW) + try: + print('Operator review required: read ' + str(directory / 'literal-review.txt') + + ' and its literal-review.json signing request through the trusted container operator shell; then write "approve ' + + name + '" followed by a newline to ' + str(consent), flush=True) + deadline, response = time.monotonic() + 600, b'' + while time.monotonic() < deadline: + require(len(response) < 256, 'demo.operator-review-response-bound') + try: + part = os.read(descriptor, 256 - len(response)) + except BlockingIOError: + part = b'' + response += part + if b'\n' in response: + require(response == ('approve ' + name + '\n').encode(), + 'demo.operator-review-declined') + return + time.sleep(0.05) + raise Refusal('demo.operator-review-expired') + finally: + os.close(descriptor) + consent.unlink(missing_ok=True) + + class Operator: def __init__(self, mode): require(os.getuid() == 0, 'demo.operator-root-required') @@ -196,6 +289,7 @@ def __init__(self, mode): self.sockets.mkdir(mode=0o750) os.chown(self.sockets, 0, APP_GID) self.port = None + self.effect_reviewer = development_ed25519_identity_key() def start_gateway(self, host): socket_path = self.sockets / ('app' + str(host) + '.sock') @@ -262,30 +356,194 @@ def prepare(self): plan = asyncio.run(authority(self.binary, resources, HOME, self.mode)) attempts = HOME / 'attempts' attempts.mkdir(mode=0o700) + effect_policy = PRIVATE / 'effect-policy.json' + write(effect_policy, gateway(self.binary, 'effect-policy', '--partition', 'airtable-demo', + '--epoch', '1', '--approver-public-key', self.effect_reviewer.public_key.hex()), new=True) for host in range(3): state = HOME / ('gateway' + str(host)) args = [self.binary, 'install', '--state-dir', state, '--recipe', HERE / 'recipe.json', '--profile-lock', HERE / 'profile.lock.json', '--trusted-context', - HOME / 'private' / ('context-' + str(1 if host == 2 else 0) + '.cbor'), '--approve-digest', plan['recipe_digest'], - '--provider', 'airtable', '--alias', 'demo' + str(host), '--credential-stdin', - '--attempt-store', attempts, '--account-label', resources['base']] - # All three share operation claims. Airtable has no recipe account - # guard; live resource access is checked separately during setup. - if self.port is not None: - args.extend(['--loopback-provider', self.port]) + PRIVATE / 'context-0.cbor', '--effect-policy', effect_policy, + '--approve-digest', plan['recipe_digest'], '--provider', 'airtable', + '--alias', 'demo', '--credential-stdin', '--attempt-store', attempts] + args.extend(['--account-label', resources['base']] if host == 0 else ['--join']) child(args, stdin=(self.keys['runtime'] + '\n').encode()) + proposal = state / 'candidate-installation.json' + if proposal.exists(): + call = PRIVATE / 'candidate-call.json' + gateway(self.binary, 'effect-candidate-call', '--state-dir', state, + '--candidate', proposal, '--operation', 'install-check', '--call-out', call) + proof, action = asyncio.run(self.read_packet(decode(read(call)), plan)) + approved = self.exact_approval(state, 'install-check', proof, action, + '--candidate', proposal) + require(approved is not None, 'demo.candidate-effect-approval-unavailable') + arguments = ['--state-dir', state, '--candidate', proposal, '--proof', approved[0], + '--action', approved[1], '--approval', approved[2]] + local = ['--loopback-provider', self.port] if self.port is not None else [] + gateway(self.binary, 'candidate-acquire', *arguments, *local) + gateway(self.binary, 'candidate-publish', *arguments) # A shared software observer exists only in this labeled development # deployment. It is never a production signing-custody claim. gateway(self.binary, 'observer-init', '--state-dir', HOME / 'gateway0') for host in [1, 2]: write(HOME / ('gateway' + str(host)) / 'observer.seed', read(HOME / 'gateway0' / 'observer.seed'), new=True) self.observer = decode(gateway(self.binary, 'observer-show', '--state-dir', HOME / 'gateway0')) + configuration = gateway(self.binary, 'effect-configuration-review', + '--state-dir', HOME / 'gateway0') + write(PRIVATE / 'configuration-review.json', configuration, new=True) + reviewed = decode(configuration) + gateway(self.binary, 'effect-configuration-activate', '--state-dir', HOME / 'gateway0', + '--expected-revision', reviewed['previous_revision_hex'], + '--expected-candidate', reviewed['candidate_hex']) write(HOME / 'private' / 'pins.json', canonical({'trusted_context_sha256': digest(read(HOME / 'private' / 'context-0.cbor')), 'observer': self.observer}), new=True) for host in range(3): self.start_gateway(host) + self.prepare_exact_approvals(plan) + self.start_recovery_reviews(plan) return plan + async def read_packet(self, call, plan): + """Managers simulate separately authorizing a native-authored read call.""" + contract, command = read_contract(call) + grant = decode(read(PRIVATE / 'read-grant.json')) + reader = load_signer_file(PRIVATE / 'reader.json').signer + managers = [load_signer_file(PRIVATE / (name + '.json')).signer for name in MANAGERS] + try: + proposal = propose_mcp_approval(contract=contract, command=command, + required=APPROVALS_REQUIRED, approvers=plan['approval']['principals'], + actor=reader.descriptor.principal, actor_grant=unb64(grant['bytes']), + challenge=unb64(plan['challenges'][0]), evaluation_time=int(time.time()), + validity_seconds=ACTION_VALIDITY_SECONDS) + responses = [] + for signer in managers[:APPROVALS_REQUIRED]: + request = next(item for item in approval_requests(proposal) + if item.approver == signer.descriptor.principal) + responses.append((await approve(open_approval_request(request.text, + now=int(time.time())), signer)).text) + signed = await sign_approval_action(proposal, reader, grants=[ + GrantEvidence(unb64(grant['bytes']), tuple(PublicControlEvidence( + item['type'], item['media_type'], unb64(item['bytes'])) + for item in grant['evidence']))]) + return collect_approvals(proposal, responses).assemble(signed), proposal.action + finally: + await reader.aclose() + for signer in managers: + await signer.aclose() + + def exact_approval(self, state, name, proof, action, *mode): + """Scripted reviewer over complete native literal output; no human-trial claim.""" + directory = PRIVATE / name + directory.mkdir(mode=0o700) + proof_path, action_path = directory / 'proof', directory / 'action' + request, approval = directory / 'request', directory / 'approval' + write(proof_path, proof, new=True) + write(action_path, action, new=True) + now = int(time.time()) + output = child([self.binary, 'effect-review', '--state-dir', state, + '--proof', proof_path, '--action', action_path, '--not-before', str(now - 1), + '--expires-at', str(now + ACTION_VALIDITY_SECONDS), '--request-out', request, + *mode], check=False) + if output.returncode != 0: + return None + review = decode(output.stdout) + require(review['schema'] == 'auths.private-effect-signing/2' + and review['renderer'] == 'auths.literal-complete-review/1' + and type(review['literal_review']) is str and review['literal_review'], + 'demo.native-effect-review-required') + write(directory / 'literal-review.json', output.stdout, new=True) + write(directory / 'literal-review.txt', review['literal_review'].encode('utf-8'), new=True) + if self.mode == 'live': + operator_consent(directory, name) + signature = self.effect_reviewer.sign(bytes.fromhex(review['signing_message_hex'])) + write(approval, gateway(self.binary, 'effect-approval', '--request', request, + '--signature-hex', signature.hex()), new=True) + return proof_path, action_path, approval + + def prepare_exact_approvals(self, plan): + """Preapprove finite scripted mutations; refusals use an explicitly substituted approval.""" + application = Application(HOME / 'app', [self.sockets / ('app' + str(host) + '.sock') + for host in range(3)]) + values, reviews = {}, {} + for label in LABELS: + proof, action, _ = asyncio.run(application.packet(label)) + result = self.exact_approval(HOME / 'gateway0', 'effect-' + label, proof, action) + if result is not None: + values[label] = b64(read(result[2])) + review = decode(read(result[2].parent / 'literal-review.json')) + reviews[label] = review['literal_review'] + require('exact' in values, 'demo.exact-effect-approval-unavailable') + for label in LABELS: + # A malformed/unauthorized action cannot be reviewed. Sending an + # approval for another effect is an adversarial binding substitution, + # never an application-created authority or a bypass. + values.setdefault(label, values['exact']) + values['exact:fresh'] = values['exact'] + plan['effect_approvals'] = values + plan['effect_review'] = {'mode': ('scripted operator reviewer; not an independent human trial' + if self.mode == 'simulation' else 'separate private operator consent; development signing custody'), + 'renderer': 'auths.literal-complete-review/1', 'reviews': reviews} + write(HOME / 'app/application.json', canonical(plan)) + for path in (HOME / 'app').iterdir(): + os.chown(path, APP_UID, APP_GID) + + def prepare_recovery(self, source, sequence, plan): + """Produce separate read authority; deriving a call never grants entry.""" + operation = 'read-' + source + '-' + str(sequence) + call = decode(gateway(self.binary, 'effect-recovery-call', '--state-dir', HOME / 'gateway0', + '--source-operation', source, '--recovery-operation', operation)) + proof, action = asyncio.run(self.read_packet(call, plan)) + approved = self.exact_approval(HOME / 'gateway0', operation, proof, action, + '--recovery-of', source) + require(approved is not None, 'demo.recovery-review-refused') + return {'proof': b64(proof), 'action': b64(action), 'approval': b64(read(approved[2])), + 'literal_review': decode(read(approved[2].parent / 'literal-review.json'))['literal_review']} + + def start_recovery_reviews(self, plan): + """Finite development reviewer, isolated from the application's UID. + + This is an explicit operator signing channel, not native recovery + semantics. Live mode requires private operator consent in exact_approval. + """ + operator = self + counts = {} + + class Handler(socketserver.BaseRequestHandler): + def handle(self): + self.request.settimeout(660 if operator.mode == 'live' else 30) + def receive(length): + output = b'' + while len(output) < length: + block = self.request.recv(length - len(output)) + require(bool(block), 'demo.review-request-incomplete') + output += block + return output + try: + length = struct.unpack('>I', receive(4))[0] + require(0 < length <= 1024, 'demo.review-request-bound') + request = decode(receive(length)) + require(type(request) is dict and set(request) == {'source'} + and type(request['source']) is str + and request['source'] in plan['cases'], 'demo.review-source-refused') + source = request['source'] + sequence = counts.get(source, 0) + 1 + require(sequence <= 4, 'demo.review-attempt-limit') + counts[source] = sequence + response = operator.prepare_recovery(source, sequence, plan) + except (Refusal, ValueError, OSError, TimeoutError): + response = {'code': 'demo.operator-recovery-review-refused'} + raw = canonical(response) + require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') + self.request.sendall(struct.pack('>I', len(raw)) + raw) + + path = self.sockets / 'review.sock' + server = socketserver.UnixStreamServer(str(path), Handler) + os.chown(path, 0, APP_GID) + os.chmod(path, 0o660) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + self.review_server, self.review_thread = server, thread + def application(self, *arguments): return subprocess.run(['/opt/consumer/bin/python', str(HERE / 'app.py'), *arguments], env=ENVIRONMENT, capture_output=True, user=APP_UID, group=APP_GID, extra_groups=[], timeout=90) @@ -301,6 +559,10 @@ def witnesses(self): return values def stop(self): + if hasattr(self, 'review_server'): + self.review_server.shutdown() + self.review_server.server_close() + self.review_thread.join(timeout=5) for process, log, _ in self.processes: if process.poll() is None: process.terminate() diff --git a/demos/airtable-gateway/selftest.py b/demos/airtable-gateway/selftest.py index 396f4bf50..b2264981a 100644 --- a/demos/airtable-gateway/selftest.py +++ b/demos/airtable-gateway/selftest.py @@ -1,5 +1,8 @@ """Actual installed SDK/native journey with independent HTTP and execution counters.""" import base64 +import os +import tempfile +import time from pathlib import Path import subprocess import urllib.request @@ -59,9 +62,27 @@ def execute(label): 'demo.selftest-path-injection-effect-claim') for label in ['exact', 'pending', 'typescript-positive']: result, records, traffic = execute(label) - require(records[0]['outcome'] == 'observed-by-provider', 'demo.selftest-observation:' + label) + require(records[0]['outcome'] == 'response-recorded' and records[0]['status'] == 200, + 'demo.selftest-response-is-not-observation:' + label) + _, recovery, recovery_traffic = execute('recover-' + label) + report = recovery[0]['report'] + require(recovery[0]['outcome'] == 'recovery-report' + and report['source']['stage'] == 'observed-by-provider' + and report['source']['provider_linked'] is True + and report['acquisition']['stage'] == 'response-recorded' + and report['disposition'] == 'recorded' + and not any(item['kind'] == 'write' for item in recovery_traffic) + and cases[-1]['native_counters']['write_transport_entries'] == 0, + 'demo.selftest-independent-native-observation:' + label) + inspect_before, inspect_traffic = operator.witnesses(), len(entries()) + inspected = operator.application('submit', '--experiment', label) + require(inspect_before == operator.witnesses() and inspect_traffic == len(entries()), + 'demo.selftest-source-inspection-must-not-enter-provider') + require(inspected.returncode == 0, 'demo.selftest-source-inspection-refused') + records = [item['result'] for item in decode(inspected.stdout)['records']] + require(records[0]['outcome'] == 'observed-by-provider', 'demo.selftest-source-observation') writes = [item for item in traffic if item['kind'] == 'write'] - require(len(writes) == 1 and cases[-1]['native_counters']['write_transport_entries'] == 1, + require(len(writes) == 1 and cases[-2]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-write-count:' + label) action = result['action'] echo = records[0]['evidence']['echo'] @@ -77,18 +98,33 @@ def execute(label): require(value['id'] == action['record_id'] and value['fields'] == { 'DemoStatus': action['replacement'], 'auths_echo': echo}, 'demo.selftest-independent-read-back') cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(raw)} - for label in ['replay', 'fresh-replay', 'typescript']: + for label in ['replay', 'typescript']: _, records, traffic = execute(label) - require(records[0]['outcome'] == 'not-entered' and records[0]['code'] == 'gateway.attempt.replay' - and not traffic and cases[-1]['native_counters']['credential_lease_calls'] == 0, - 'demo.selftest-replay:' + label) + require(records[0]['outcome'] == 'observed-by-provider' + and not traffic and not any(cases[-1]['native_counters'].values()), + 'demo.selftest-replay-retains-observation-without-new-entry:' + label) + _, records, traffic = execute('fresh-replay') + require(records[0]['outcome'] == 'denied' and records[0]['code'] == 'challenge-mismatch' + and not traffic and not any(cases[-1]['native_counters'].values()), + 'demo.selftest-substituted-challenge-under-installed-trust') _, records, traffic = execute('race') - require(sorted(item['outcome'] for item in records) == ['not-entered', 'observed-by-provider'] + require(any(item['outcome'] == 'response-recorded' for item in records) + and all(item['outcome'] in ('reserved', 'unknown', 'response-recorded') for item in records) and sum(item['kind'] == 'write' for item in traffic) == 1 and cases[-1]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-two-process-race') + # A contender can inspect the winner after durable entry but before its + # response is recorded, so Unknown is a truthful interim projection. Once + # both calls finish, exact replay must converge without any external I/O. + race_before, race_entries = operator.witnesses(), len(entries()) + replayed = operator.application('submit', '--experiment', 'race') + require(replayed.returncode == 0 + and decode(replayed.stdout)['records'][0]['result']['outcome'] == 'response-recorded' + and race_before == operator.witnesses() and race_entries == len(entries()), + 'demo.selftest-race-final-history-without-new-entry') operator.restart(0) _, records, traffic = execute('replay') - require(records[0]['code'] == 'gateway.attempt.replay' and not traffic, 'demo.selftest-restart-replay') + require(records[0]['outcome'] == 'observed-by-provider' and not traffic + and not any(cases[-1]['native_counters'].values()), 'demo.selftest-restart-replay') cases[-1]['case'] = 'restart-replay' _, records, traffic = execute('lost-response') require(records[0]['outcome'] == 'unknown' and cases[-1]['native_counters']['write_transport_entries'] == 1 @@ -96,17 +132,23 @@ def execute(label): with operator.fixture.lock: operator.fixture.hidden_until[record_ids()[10]] = float('inf') _, records, traffic = execute('recover-loss') - require(records[0]['outcome'] != 'observed-by-provider' and not any(item['kind'] == 'write' for item in traffic), + require(records[0]['outcome'] == 'recovery-report' + and records[0]['report']['source']['stage'] == 'unknown' + and records[0]['report']['source']['provider_linked'] is False + and not any(item['kind'] == 'write' for item in traffic), 'demo.selftest-delayed-visibility-not-confirmed') operator.fixture.release_visibility(record_ids()[10]) _, records, traffic = execute('recover-loss') - require(records[0]['outcome'] == 'observed-by-provider' and traffic + require(records[0]['outcome'] == 'recovery-report' + and records[0]['report']['source']['stage'] == 'observed-by-provider' + and records[0]['report']['source']['provider_linked'] is True and traffic and cases[-1]['native_counters']['write_transport_entries'] == 0, 'demo.selftest-read-only-recovery') _, records, traffic = execute('competing-writer') require(records[0]['outcome'] == 'unknown' and cases[-1]['other_actor_writes'] == 1, 'demo.selftest-competing-writer-fixture') _, records, traffic = execute('recover-competing') - require(records[0]['outcome'] != 'observed-by-provider' and traffic + require(records[0]['outcome'] == 'recovery-report' + and records[0]['report']['source']['provider_linked'] is False and traffic and cases[-1]['native_counters']['write_transport_entries'] == 0 and operator.fixture.records[record_ids()[11]]['auths_echo'] == 'external-writer-echo', 'demo.selftest-matching-value-wrong-echo-not-confirmed') @@ -118,8 +160,8 @@ def execute(label): 'demo.selftest-provider-error-not-confirmed:' + label) _, records, traffic = execute(label) require(records[0]['outcome'] != 'observed-by-provider' - and cases[-1]['native_counters']['write_transport_entries'] == 0 - and not any(item['kind'] == 'write' for item in traffic), 'demo.selftest-provider-error-never-rewrites') + and not traffic and not any(cases[-1]['native_counters'].values()), + 'demo.selftest-provider-error-never-refetches-or-rewrites') return cases @@ -142,7 +184,7 @@ def kill_gateway(): and writes() == before, 'demo.selftest-crash-before-entry') operator.restart(0) completed = operator.application('submit', '--experiment', 'crash-before') - require(completed.returncode == 0 and decode(completed.stdout)['records'][0]['result']['outcome'] == 'observed-by-provider' + require(completed.returncode == 0 and decode(completed.stdout)['records'][0]['result']['outcome'] == 'response-recorded' and writes() == before + 1, 'demo.selftest-confirmed-pre-entry-restart') before, witness = writes(), operator.witnesses()[0] with ThreadPoolExecutor(max_workers=1) as pool: @@ -161,8 +203,18 @@ def kill_gateway(): fresh = operator.witnesses()[0] require(fresh['scope'] != entered['scope'], 'demo.selftest-crash-counter-scope-not-renewed') completed = operator.application('submit', '--experiment', 'crash-after') + replay = operator.witnesses()[0] + require(completed.returncode == 0 and decode(completed.stdout)['records'][0]['result']['outcome'] == 'unknown' + and writes() == before + 1 + and replay['write_transport_entries'] == fresh['write_transport_entries'] + and replay['read_transport_entries'] == fresh['read_transport_entries'], + 'demo.selftest-crash-replay-cannot-read-or-write') + completed = operator.application('submit', '--experiment', 'recover-crash-after') after = operator.witnesses()[0] - require(completed.returncode == 0 and decode(completed.stdout)['records'][0]['result']['outcome'] == 'observed-by-provider' + native = decode(completed.stdout)['records'][0]['result'] + require(completed.returncode == 0 and native['outcome'] == 'recovery-report' + and native['report']['source']['stage'] == 'observed-by-provider' + and native['report']['source']['provider_linked'] is True and writes() == before + 1 and after['write_transport_entries'] == fresh['write_transport_entries'] and after['read_transport_entries'] == fresh['read_transport_entries'] + 1, 'demo.selftest-crash-recovery-must-only-read') @@ -175,7 +227,8 @@ def kill_gateway(): def test_application_isolation_and_native_audit(operator): from operate import APP_UID, APP_GID, ENVIRONMENT, HOME, child - private = [HOME / 'private' / 'root.seed', + private = [HOME / 'private' / 'root.seed', HOME / 'private' / 'reader.seed', + HOME / 'private' / 'read-grant.json', *(HOME / 'private' / (name + '.seed') for name in ['manager-a', 'manager-b', 'manager-c']), HOME / 'gateway0' / 'credentials.cbor', @@ -210,15 +263,94 @@ def test_application_isolation_and_native_audit(operator): return {'doctor': doctor_value, 'audit': result} +def test_exact_operator_consent_binding(operator): + """Exercise private consent transport; scripted input is not a human trial.""" + from operate import HOME, operator_consent + from demo_common import Refusal + before = operator.witnesses() + for accepted in [False, True]: + with tempfile.TemporaryDirectory(prefix='consent-test-', dir=HOME / 'private') as temporary: + directory = Path(temporary) + write(directory / 'literal-review.json', + read(HOME / 'private/effect-exact/literal-review.json'), new=True) + write(directory / 'literal-review.txt', + read(HOME / 'private/effect-exact/literal-review.txt'), new=True) + with ThreadPoolExecutor(max_workers=1) as pool: + pending = pool.submit(operator_consent, directory, 'exact-consent-test') + fifo, deadline = directory / 'consent', time.monotonic() + 5 + while not fifo.exists() and time.monotonic() < deadline: + time.sleep(0.01) + require(fifo.exists() and fifo.stat().st_mode & 0o777 == 0o600, + 'demo.selftest-consent-not-private') + # The trusted operator channel supplies the exact operation + # token; changing it cannot approve the saved native request. + with fifo.open('wb', buffering=0) as stream: + stream.write(b'approve exact-consent-test\n' if accepted else b'approve another-operation\n') + if accepted: + require(pending.result(timeout=5) is None, 'demo.selftest-consent-not-accepted') + else: + try: + pending.result(timeout=5) + raise AssertionError('substituted operator consent accepted') + except Refusal as error: + require(str(error) == 'demo.operator-review-declined', + 'demo.selftest-consent-wrong-refusal') + require(not fifo.exists() and not (directory / 'approval').exists(), + 'demo.selftest-consent-created-authority') + require(before == operator.witnesses(), 'demo.selftest-consent-entered-provider') + return {'cases': 2, 'changed_operation_refused': True, 'owner_only_fifo': True, + 'provider_entries': 0, 'human_trial': False} + + +def test_private_reviewer_refuses_unlisted_inputs(operator): + """Unlisted or malformed app requests receive no read proof or exact approval.""" + from operate import APP_UID, APP_GID, ENVIRONMENT, HOME + script = r""" +import json, socket, struct, sys +results = [] +for value in [{'source': 'unlisted'}, {'source': []}, {'source': 'exact', 'url': 'https://other.example'}]: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as channel: + channel.settimeout(5) + channel.connect(sys.argv[1]) + raw = json.dumps(value).encode() + channel.sendall(struct.pack('>I', len(raw)) + raw) + def receive(length): + output = b'' + while len(output) < length: + part = channel.recv(length - len(output)) + if not part: + raise RuntimeError('incomplete reviewer response') + output += part + return output + length = struct.unpack('>I', receive(4))[0] + if not 0 < length <= 1024: + raise RuntimeError('reviewer response bound') + results.append(json.loads(receive(length))) +print(json.dumps(results)) +""" + before = operator.witnesses() + result = subprocess.run(['/opt/consumer/bin/python', '-c', script, + str(HOME / 'sockets/review.sock')], user=APP_UID, group=APP_GID, extra_groups=[], + env=ENVIRONMENT, capture_output=True, timeout=20) + require(result.returncode == 0, 'demo.selftest-review-channel-unavailable') + refusals = decode(result.stdout) + require(refusals == [{'code': 'demo.operator-recovery-review-refused'}] * 3 + and before == operator.witnesses(), 'demo.selftest-review-channel-minted-authority') + return {'cases': 3, 'app_uid': APP_UID, 'native_counters_unchanged': True, + 'returned_proof_or_approval': False} + + def run(operator): from operate import HOME + consent = test_exact_operator_consent_binding(operator) + reviewer = test_private_reviewer_refuses_unlisted_inputs(operator) cases = test_native_refusals_replay_race_and_loss(operator) cases.extend(test_native_process_crashes(operator)) verified = test_application_isolation_and_native_audit(operator) report = {'schema': 'auths.airtable-gateway-demo-evidence/1', 'mode': 'simulation', 'production_qualification': False, 'independent_human_trial': False, 'source_commit': decode(read(Path(__file__).parent / 'manifest.json'))['source_commit'], - 'cases': cases, **verified, + 'operator_consent': consent, 'operator_review_channel': reviewer, 'cases': cases, **verified, 'excluded': ['live Airtable writes', 'production AWS custody and PostgreSQL', 'protected full-corpus qualification', 'provider key rotation', 'independent security review', 'GitHub release installation']} @@ -229,7 +361,7 @@ def run(operator): require(support.returncode == 0, 'demo.selftest-support-refused') published = data + audit + support.stdout private_seeds = [read(HOME / 'private' / (name + '.seed')) - for name in ['root', 'manager-a', 'manager-b', 'manager-c']] + for name in ['root', 'reader', 'manager-a', 'manager-b', 'manager-c']] for secret in list(operator.keys.values()) + private_seeds + [read(HOME / 'app/actor.seed')]: raw = secret.encode() if isinstance(secret, str) else secret for encoded in [raw, raw.hex().encode(), base64.b64encode(raw), base64.urlsafe_b64encode(raw)]: diff --git a/demos/airtable-gateway/submit.mts b/demos/airtable-gateway/submit.mts index 23ce5ce65..4a6088389 100644 --- a/demos/airtable-gateway/submit.mts +++ b/demos/airtable-gateway/submit.mts @@ -10,7 +10,7 @@ for await (const chunk of process.stdin) { if (input.length > 8 * 1024 * 1024) throw new Error('demo.packet-bound'); } const packet = JSON.parse(input) as Record; -if (Object.keys(packet).sort().join(',') !== 'action_b64,proof_b64') throw new Error('demo.invalid-packet'); +if (Object.keys(packet).sort().join(',') !== 'action_b64,approval_b64,proof_b64') throw new Error('demo.invalid-packet'); function bytes(value: unknown): Uint8Array { if (typeof value !== 'string' || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error('demo.invalid-packet'); const result = Buffer.from(value, 'base64url'); @@ -18,4 +18,4 @@ function bytes(value: unknown): Uint8Array { return result; } const client = new GatewayClient(new GatewayEndpoint(socket)); -console.log(JSON.stringify(await client.submit({proof: bytes(packet.proof_b64), action: bytes(packet.action_b64)}))); +console.log(JSON.stringify(await client.submit({proof: bytes(packet.proof_b64), action: bytes(packet.action_b64), approval: bytes(packet.approval_b64)}))); diff --git a/demos/airtable-gateway/tests/browser.py b/demos/airtable-gateway/tests/browser.py index 5454911ad..75d2654f6 100644 --- a/demos/airtable-gateway/tests/browser.py +++ b/demos/airtable-gateway/tests/browser.py @@ -16,8 +16,8 @@ def test_packaged_workbench_and_unsigned_evidence(): expect(page.locator('#approval-review')).to_contain_text('set_demo_status_v1') for case, outcome in [('approval-insufficient', 'DENIED'), ('approval-duplicate', 'NOT-SUBMITTED'), - ('unsupported-value', 'NOT-ENTERED'), ('rate-limit', 'FIELD READ · VALUE MISMATCH'), ('exact', 'OBSERVED-BY-PROVIDER'), - ('replay', 'NOT-ENTERED'), ('lost-response', 'UNKNOWN')]: + ('unsupported-value', 'NOT-ENTERED'), ('rate-limit', 'RESPONSE-RECORDED'), ('exact', 'RESPONSE-RECORDED'), ('recover-exact', 'RECOVERY-REPORT'), + ('replay', 'OBSERVED-BY-PROVIDER'), ('lost-response', 'UNKNOWN')]: page.locator('#experiment').select_option(case) page.locator('#submit').click() expect(page.locator('#outcome')).to_have_text(outcome, timeout=45000) diff --git a/demos/airtable-gateway/web/app.js b/demos/airtable-gateway/web/app.js index b520d7cf2..670b7a690 100644 --- a/demos/airtable-gateway/web/app.js +++ b/demos/airtable-gateway/web/app.js @@ -3,6 +3,9 @@ const element = id => document.getElementById(id); const descriptions = { 'observed-by-provider': 'A fresh provider read matched the verified value and this action’s echo. The link assumes no other writer copied the echo.', observed: 'The gateway read the declared field. Value equality alone does not link that value to this action or establish its effect.', + 'recovery-report': 'A separately authorized read completed. Inspect the original write stage, read facts and evidence disposition below; a state match alone is not causation.', + refused: 'The gateway refused this recovery action. No new write was authorized.', + reserved: 'The operation is reserved. Another process may still be working; this is not permission to repeat delivery.', 'response-recorded': 'The gateway recorded an HTTP response. This alone does not establish an effect.', unknown: 'The outcome remains unknown. The provider may have received the write; its response or matching fresh value and echo is unavailable. Authority remains consumed; no automatic retry is allowed.', 'not-entered': 'The gateway refused before write transport. A provider-read guard may already have acquired a credential and read evidence.', @@ -20,6 +23,8 @@ function display(record) { : item.result.outcome.toUpperCase()).join(' / '); element('explanation').textContent = outcomes.map(value => descriptions[value] || 'Inspect the exact gateway result below.').join(' '); element('result-json').textContent = JSON.stringify(record, null, 2); + const reviewed = record.records.find(item => item.result.literal_review); + if (reviewed) element('approval-review').textContent = reviewed.result.literal_review; } async function initialize() { const response = await fetch('/api/status'); @@ -54,8 +59,9 @@ async function initialize() { const original = value === 'recover-loss' ? 'lost-response' : value === 'recover-competing' ? 'competing-writer' : 'exact'; const action = status.proposals[value] || status.proposals[original]; element('proposal').textContent = `${action.record_id} → ${action.replacement} · operation ${action.operation_id}`; - const review = status.approval.reviews[value] || status.approval.reviews[original]; - element('approval-review').textContent = `${review.title} · ${review.fields.map(([label, field]) => `${label}: ${field}`).join(' · ')} · expires ${new Date(review.valid_until * 1000).toLocaleTimeString()}`; + const source = value.startsWith('recover-') ? value.slice(8) : value; + const review = status.effect_review.reviews[source] || (['replay', 'typescript', 'observe'].includes(value) ? status.effect_review.reviews.exact : null); + element('approval-review').textContent = value.startsWith('recover-') ? 'A separate native read review and operator consent are required. The exact read review is retained with its result.' : review || 'Native review refused this hostile input. This experiment substitutes another effect’s approval and must be rejected.'; const link = element('provider-link'); link.hidden = status.mode !== 'live' || !/^rec[A-Za-z0-9]{14}$/.test(action.record_id); if (!link.hidden) { diff --git a/demos/airtable-gateway/web/index.html b/demos/airtable-gateway/web/index.html index 1cecae5f3..a02b347fa 100644 --- a/demos/airtable-gateway/web/index.html +++ b/demos/airtable-gateway/web/index.html @@ -29,12 +29,12 @@

Let the app propose a status.
Keep the Airtable token out of its hands.Provider returns 429 -

Each experiment fixes its record, operation and signed arguments.

+

Each experiment fixes its record, operation and signed arguments.

The native review binds the exact action, authority and expiry.

-

Run the exact update before replay. Recovery resubmits the original operation to the native replay boundary; -only another read can occur. Wait three seconds after response loss before observing again. The local simulator supplies signed responses only for this closed fixture; its UI state is never authority.

+

Run the exact update before replay. Recovery requests a separate native proof and exact approval for a bounded read. +Replaying the original operation only inspects retained history. Wait three seconds after response loss before observing again. The local simulator supplies signed responses only for this closed fixture; its UI state is never authority.

Measured native result

No action submitted

  1. Verify proof
  2. Claim operation
  3. Enter provider
  4. Record response
  5. Observe value + echo

Authorization, a recorded HTTP response and a matching fresh value/echo are separate facts.

diff --git a/demos/airtable-gateway/web/styles.css b/demos/airtable-gateway/web/styles.css index cafb35838..ddd8ea6fc 100644 --- a/demos/airtable-gateway/web/styles.css +++ b/demos/airtable-gateway/web/styles.css @@ -1,3 +1,5 @@ :root{font-family:Inter,ui-sans-serif,system-ui,sans-serif;color:#122035;background:#f7f8fa;font-synthesis:none}*{box-sizing:border-box}body{margin:0}header,footer{padding:24px max(24px,calc((100vw - 1120px)/2));display:flex;justify-content:space-between;gap:20px;border-bottom:1px solid #dde2ea}header a{font-weight:800;letter-spacing:.08em;text-decoration:none;color:#122035}header span{font-size:11px;letter-spacing:.09em;font-weight:700;color:#25615a}main{max-width:1120px;margin:auto;padding:64px 24px}.eyebrow{font-size:12px;text-transform:uppercase;letter-spacing:.15em;color:#416489;font-weight:700}h1{font-size:clamp(30px,4vw,49px);line-height:1.16;letter-spacing:-.045em;margin:14px 0 22px}h2{font-size:21px;margin-top:0}.intro{font-size:18px;line-height:1.6;max-width:750px;color:#4a5c72}#connection{margin:30px 0;padding:14px 18px;border-left:3px solid #3574d5;background:#eef3fb;font-size:14px}.workbench{display:grid;grid-template-columns:1fr 1fr;gap:24px;margin:32px 0}article,.result{border:1px solid #dbe2ed;background:white;border-radius:12px;padding:28px}article p,.limits p{font-size:14px;line-height:1.7;color:#526074}dl{display:grid;grid-template-columns:1fr 1.4fr;gap:14px;font-size:13px}dt{color:#637389}dd{margin:0;font-weight:650;overflow-wrap:anywhere}.digest{font-family:ui-monospace,monospace;font-size:11px}label{display:block;font-size:13px;font-weight:700;margin:24px 0 10px}select{width:100%;padding:14px;background:#f7f9fd;border:1px solid #b7c6da;border-radius:7px;font:inherit;font-size:14px}button{width:100%;padding:16px;border:0;border-radius:7px;background:#2563eb;color:white;font:inherit;font-size:14px;font-weight:700;cursor:pointer}button:disabled{opacity:.5;cursor:wait}.small{font-size:12px!important}.stages{display:flex;flex-wrap:wrap;gap:8px;list-style:none;padding:0;color:#55708c;font-size:12px}.stages li{border:1px solid #dde5ef;padding:8px;border-radius:5px}.result #outcome{overflow-wrap:anywhere;font-size:26px}.result p{line-height:1.7;color:#526074}pre{white-space:pre-wrap;overflow-wrap:anywhere;background:#111f34;color:#d7e5f7;border-radius:8px;padding:22px;font:12px/1.65 ui-monospace,monospace;max-height:450px;overflow:auto}.result a{display:inline-block;padding-top:12px;font-size:14px;font-weight:700;color:#2563eb}.limits{padding:34px 2px 0;max-width:860px}footer{border-top:1px solid #dde2ea;font-size:12px;color:#637389;justify-content:center}@media(max-width:760px){main{padding-top:34px}.workbench{grid-template-columns:1fr}header{flex-direction:column}article,.result{padding:22px}dl{grid-template-columns:1fr 1fr}.result #outcome{font-size:21px}} #provider-link{display:block;margin:14px 0;color:#2563eb;font-weight:700;font-size:14px}#provider-link[hidden]{display:none} + +#approval-review { white-space: pre-wrap; overflow-wrap: anywhere; } diff --git a/demos/stripe-gateway/README.md b/demos/stripe-gateway/README.md index a9a65727c..94f7b6f5b 100644 --- a/demos/stripe-gateway/README.md +++ b/demos/stripe-gateway/README.md @@ -1,7 +1,7 @@ # Stripe refunds through the general gateway The maintained Stripe demo uses a data-only platform-refund recipe and installed -Auths SDKs. The app holds its own scoped signing identity, submits proof/action +Auths SDKs. The app holds its own scoped signing identity, submits proof/action/exact-approval bytes over the gateway application socket, and has no Stripe key or private gateway state. No coupled Stripe vertical service executes this demo. @@ -19,6 +19,32 @@ The workbench shows the native review fields and includes insufficient-quorum and duplicate-response cases. This local simulator is integration evidence, not a human approval inbox: simulator state or a UI click never authorizes an action. +The operator additionally requests the complete native exact-effect review and +signs its canonical request. Simulation supplies this signature from a separate +operator-only ephemeral development key. The app forwards the approval unchanged; +it holds neither that key nor the private actor used for candidate/recovery reads. +Credential-checking installs stage a candidate, acquire separately authorized +checks, and publish from retained evidence before peers join. Adding the software +observer requires explicit native configuration review and CAS activation. + +A write returns `response-recorded` when its HTTP response is retained. Choose +**Separately approve and observe the exact operation** to authorize a distinct +read. Its native report separates original-write facts, read charges and evidence +disposition. Replaying a mutation returns retained facts without a read or write; +unknown outcomes never cause an automatic read, resend or refund. + +Live mode never uses the scripted exact-effect reviewer. Startup and each new +recovery read pause for at most ten minutes on an owner-only consent FIFO. In a +separate trusted operator shell, use `docker exec CONTAINER cat REVIEW_PATH` to +read the **entire** `literal-review.txt` and its `literal-review.json` signing +request at the private paths printed by the operator. After +checking its exact destination, units, consequences and signing request, use +`docker exec CONTAINER sh -c 'printf "approve OPERATION\n" > CONSENT_PATH'` with +the exact operation and consent path printed there. The application UID cannot +read or write this private channel. Missing or different consent fails closed. +This is local Docker-operator development custody, not a remote human approval +inbox, independent-human trial or production signing-custody claim. + ## Source-free Docker quick start Download `stripe-gateway-demo.tgz` and its checksum from the **Stripe gateway demo** @@ -40,8 +66,9 @@ Open . Start with **Exact refund**, then replay, approval boundary, altered proof/action, two-gateway race and budget experiments. Each choice has one fixed operation and payment. Run the count/sum positive before its overflow. The separate operator starts two native gateway processes for the race and a -third installation for the second challenge. Each installation checks its own -credential and account; all three share the operation/budget store. The web app runs +third joined installation. All three pin the same connection, trust and +configuration and share the operation/budget store. The fresh-challenge +experiment deliberately substitutes an uninstalled challenge and is refused. The web app runs as UID 62004. Gateway state and root/observer keys remain root-private. Default mode is clearly labeled **simulation**. A counting Stripe double measures @@ -167,7 +194,7 @@ production claim. Never rename its evidence as AWS/PostgreSQL evidence. The workflow builds a digest-listed handoff, installs its actual SDK artifacts outside the checkout and runs the native simulation plus a real browser. `selftest.py` verifies independent wire mapping/read-back, pre-custody refusals, -post-lease guards, count/sum boundaries, two-process race, fresh-challenge replay, +post-lease guards, count/sum boundaries, two-process race, fresh-challenge refusal, process restart, actual response drop after effect, UID isolation, doctor and offline audit. Provider traffic is counted independently of the app display. Reports and desktop/mobile screenshots are retained as artifacts. diff --git a/demos/stripe-gateway/app.py b/demos/stripe-gateway/app.py index bf02e990b..a0e53c49c 100644 --- a/demos/stripe-gateway/app.py +++ b/demos/stripe-gateway/app.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Application: public SDK authoring and proof/action-only gateway submission.""" +"""Application: public SDK authoring and proof/action/exact-approval gateway submission.""" import argparse import asyncio from dataclasses import asdict @@ -7,6 +7,8 @@ import os from pathlib import Path import secrets +import socket +import struct import threading import time from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer @@ -27,7 +29,7 @@ 'altered-action', 'forged-proof', 'expired-action', 'race', 'lost-response', 'count-positive', 'count-overflow', 'sum-positive', 'sum-overflow', 'approval-insufficient') -EXPERIMENTS = LABELS + ('replay', 'fresh-replay', 'observe', 'typescript', +EXPERIMENTS = tuple('recover-' + label for label in LABELS) + LABELS + ('replay', 'fresh-replay', 'observe', 'typescript', 'approval-duplicate') @@ -73,7 +75,7 @@ def summary(self): 'platform': self.plan['platform'], 'expires_at': self.plan['expires_at'], 'relative_limit': '50% of independently read amount_received', 'grant_limits': self.plan['limits'], 'experiments': list(EXPERIMENTS), - 'approval': self.plan['approval'], + 'approval': self.plan['approval'], 'effect_review': self.plan['effect_review'], 'sdk_version': importlib.metadata.version('auths'), 'proposals': {label: case['arguments'] for label, case in self.plan['cases'].items()}, 'records': self.records[-64:]} @@ -133,6 +135,7 @@ async def packet(self, label, *, fresh=False): async def exchange(self, packet, host=0, *, typescript=False): proof, action, operation = packet + approval = unb64(self.plan['effect_approvals'][operation]) if typescript: completed = await asyncio.create_subprocess_exec( '/usr/local/bin/node', str(HERE / 'submit.mjs'), @@ -141,12 +144,13 @@ async def exchange(self, packet, host=0, *, typescript=False): stderr=asyncio.subprocess.DEVNULL, env={'PATH': '/usr/local/bin:/usr/bin:/bin'}) output, _ = await asyncio.wait_for(completed.communicate( - canonical({'proof_b64': b64(proof), 'action_b64': b64(action)})), 60) + canonical({'proof_b64': b64(proof), 'action_b64': b64(action), + 'approval_b64': b64(approval)})), 60) require(completed.returncode == 0 and len(output) <= 65536, 'demo.typescript-unavailable') result = decode(output) else: try: - result = asdict(await self.clients[host].submit(proof=proof, action=action)) + result = asdict(await self.clients[host].submit(proof=proof, action=action, approval=approval)) except GatewayProtocolError: # The IPC request may have entered. Never retry automatically. result = {'outcome': 'transport-unconfirmed', 'code': 'demo.gateway-unavailable'} @@ -176,8 +180,56 @@ async def remember(self, packet, record): self.approval_responses.append({'operation_id': operation, 'response': response}) recorded.add((operation, response)) + async def recover(self, source): + """Request independent operator consent, then submit its native read proof.""" + require(source in self.plan['cases'], 'demo.unknown-recovery-source') + def request_review(): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as channel: + channel.settimeout(660 if self.plan['mode'] == 'live' else 90) + channel.connect(str(self.sockets[0].parent / 'review.sock')) + payload = canonical({'source': source}) + channel.sendall(struct.pack('>I', len(payload)) + payload) + def receive(length): + output = b'' + while len(output) < length: + block = channel.recv(length - len(output)) + require(bool(block), 'demo.review-response-incomplete') + output += block + return output + length = struct.unpack('>I', receive(4))[0] + require(0 < length <= 4 * 1024 * 1024, 'demo.review-response-bound') + return decode(receive(length)) + approved = await asyncio.to_thread(request_review) + if set(approved) == {'code'}: + return {'operation_id': source, 'language': 'python', 'result': { + 'outcome': 'not-submitted', 'code': 'demo.operator-recovery-review-refused'}} + require(set(approved) == {'proof', 'action', 'approval', 'literal_review'}, + 'demo.operator-review-unavailable') + raw = await self.clients[0].recover(source, proof=unb64(approved['proof']), + action=unb64(approved['action']), approval=unb64(approved['approval'])) + report = decode(raw) + require(report.get('outcome') in ('recovery-report', 'refused'), 'demo.recovery-refused') + # The native report is retained unchanged. The UI label does not infer + # an observation or causation from a provider response. + return {'operation_id': source, 'language': 'python', 'result': { + **report, 'literal_review': approved['literal_review']}} + async def execute(self, experiment): require(experiment in EXPERIMENTS, 'demo.unknown-experiment') + if experiment.startswith('recover-'): + source = experiment[len('recover-'):] + source = {'loss': 'lost-response', 'competing': 'competing-writer'}.get(source, source) + record = await self.recover(source) + result = {'schema': 'auths.stripe-gateway-demo-result/1', + 'experiment': experiment, 'action': self.plan['cases'][source]['arguments'], + 'records': [record], 'decided_by': ('operator-review' + if record['result']['outcome'] == 'not-submitted' else 'gateway'), + 'production_qualified': False, + 'display_signature': 'unsigned', 'recorded_at': int(time.time())} + require(len(self.records) < 256, 'demo.session-full') + self.records.append(result) + write(self.directory / 'results.json', canonical(self.records)) + return result if experiment == 'approval-duplicate': records = [self.approval_duplicate()] result = {'schema': 'auths.stripe-gateway-demo-result/1', 'experiment': experiment, diff --git a/demos/stripe-gateway/contract.json b/demos/stripe-gateway/contract.json index c0d37f8d5..6f1d39898 100644 --- a/demos/stripe-gateway/contract.json +++ b/demos/stripe-gateway/contract.json @@ -2,7 +2,7 @@ "schema": "auths.gateway-demo-contract/1", "platform": "stripe", "family": "stripe-platform-refund-v1", - "application_boundary": "installed public GatewayClient; proof and action only", + "application_boundary": "installed public GatewayClient; proof, action and native exact-effect approval", "recipe_source": "qualification/simulation/live/stripe-platform/recipe.json", "profile_source": "qualification/simulation/live/stripe-platform/profile.toml", "qualification_workflow": ".github/workflows/recipe-qualification.yml", diff --git a/demos/stripe-gateway/operate.py b/demos/stripe-gateway/operate.py index 0341dbbb5..566551e86 100644 --- a/demos/stripe-gateway/operate.py +++ b/demos/stripe-gateway/operate.py @@ -2,22 +2,31 @@ """Separate operator: disposable resources, independent trust, gateway installation.""" import argparse import asyncio +from dataclasses import dataclass import os import re from pathlib import Path import secrets import signal +import socketserver +import struct +import threading import subprocess import sys import time +from typing import Optional -from auths.authoring import approval_requests, approve, open_approval_request, propose_mcp_approval -from auths.self_hosted import (ApprovalRequirement, ApproverAnchor, AssurancePolicy, +from auths.adapters.custody import PublicControlEvidence +from auths.authoring import (GrantEvidence, approval_requests, approve, collect_approvals, + open_approval_request, propose_mcp_approval, sign_approval_action) +from auths.testkit import development_ed25519_identity_key +from auths.self_hosted import (ExactMcpTool, StringField, IntegerField, OptionalField, + ApprovalRequirement, ApproverAnchor, AssurancePolicy, AssuranceRequirement, Permission, Profile, TrustAnchor, TrustedContextRequest, author_root_grant, compile_trusted_context, load_signer_file) from demo_common import Refusal, b64, canonical, decode, digest, read, require, unb64, write -from app import LABELS, approval_target +from app import Application, LABELS, approval_target HERE = Path(__file__).resolve().parent HOME = Path('/run/demo') @@ -27,6 +36,7 @@ APP_UID, APP_GID = 62004, 62005 ENVIRONMENT = {'PATH': '/opt/consumer/bin:/usr/local/bin:/usr/bin:/bin', 'PYTHONNOUSERSITE': '1'} MANAGERS = ('manager-a', 'manager-b', 'manager-c') +READ_TOOLS = ('auths_gateway_candidate_check_v1', 'auths_gateway_recovery_read_v1') APPROVALS_REQUIRED = 2 ACTION_VALIDITY_SECONDS = 1800 @@ -73,7 +83,7 @@ async def authority(binary, resources, directory, mode): app.mkdir(mode=0o700) require(private.is_dir() and not private.is_symlink() and private.stat().st_uid == 0 and private.stat().st_mode & 0o777 == 0o700, 'demo.operator-private-directory-required') - for name, parent in [('root', private), ('actor', app), + for name, parent in [('root', private), ('reader', private), ('actor', app), *((name, private) for name in MANAGERS)]: write(parent / (name + '.seed'), secrets.token_bytes(32), new=True) write(parent / (name + '.json'), canonical({'schema': 'auths.approval-signer/1', @@ -86,6 +96,8 @@ async def authority(binary, resources, directory, mode): now, expires = int(time.time()), int(time.time()) + 3600 audience = 'mcp://stripe-platform-refunds' permission = Permission('tools/call', audience + '/tools/create_refund_v1') + permissions = (permission,) + tuple(Permission('tools/call', audience + '/tools/' + tool) + for tool in READ_TOOLS) policy = AssurancePolicy('raw-key-baseline', tuple(AssuranceRequirement(*row) for row in [ ('root', 'every', 'self-certifying-identifier'), ('actor', 'every', 'self-certifying-identifier'), @@ -108,7 +120,7 @@ async def authority(binary, resources, directory, mode): for item in grant.evidence]} limits[name] = {'count': count, 'sum': capacity, 'ceiling': 2000, 'window_seconds': window} anchors = [TrustAnchor('operator-root', root.descriptor.principal, ('raw-key-v1',), - (Profile('auths.mcp', 2),), (permission,), (audience,), (audience,), + (Profile('auths.mcp', 2),), permissions, (audience,), (audience,), now - 3600, expires, 1, 'raw-key-baseline')] approver_principals = tuple(managers[name].descriptor.principal for name in MANAGERS) options = {'anchors': anchors, 'assurance': policy, @@ -118,6 +130,17 @@ async def authority(binary, resources, directory, mode): now - 3600, expires) for principal in approver_principals), 'approval_requirements': (ApprovalRequirement(approver_principals, APPROVALS_REQUIRED),)} + reader = load_signer_file(private / 'reader.json').signer + try: + read_grant = await author_root_grant(signer=root, subject=reader.descriptor.principal, + profile=Profile('auths.mcp', 2), permissions=permissions[1:], audiences=[audience], + not_before=now - 3600, expires_at=expires, remaining_depth=0, + assurance_floor='raw-key-baseline', requested_at=now) + write(private / 'read-grant.json', canonical({'bytes': b64(read_grant.signed_grant), + 'evidence': [{'type': item.evidence_type, 'media_type': item.media_type, + 'bytes': b64(item.bytes)} for item in read_grant.evidence]}), new=True) + finally: + await reader.aclose() template = compile_trusted_context(**options) challenges = [secrets.token_bytes(32), secrets.token_bytes(32)] contexts = [compile_trusted_context(**options, @@ -192,6 +215,76 @@ async def approval_bundle(label, *, fresh=False): await signer.aclose() +@dataclass(frozen=True) +class CandidateCheck: + operation_id: str + operator_namespace: str + recipe_digest: str + candidate_connection: str + expected_previous: Optional[str] + read_contract: str + maximum_response_bytes: int + + +@dataclass(frozen=True) +class RecoveryRead: + operation_id: str + operator_namespace: str + recipe_digest: str + source_effect: str + source_operation: str + read_contract: str + maximum_response_bytes: int + + +def read_contract(call): + """Closed transport shape only; the native gateway owns every read binding.""" + name = call['name'] + require(name in READ_TOOLS, 'demo.unlisted-read-tool') + command_type = CandidateCheck if name == READ_TOOLS[0] else RecoveryRead + fields = {key: StringField(min_length=1, max_length=128) + for key in command_type.__annotations__} + fields['maximum_response_bytes'] = IntegerField(1, 1048576) + if command_type is CandidateCheck: + fields['expected_previous'] = OptionalField(StringField(min_length=64, max_length=64)) + contract = ExactMcpTool(service=call['service'], name=name, + command_type=command_type, fields=fields) + return contract, contract.validate_arguments(call['arguments']) + + +def operator_consent(directory, name): + """Bounded owner-only consent for the already saved exact native review. + + The Docker operator reads the complete literal review and signing request + and writes one exact token to this private FIFO. The app cannot access it. + This is development custody, not an authenticated remote approval inbox. + """ + consent = directory / 'consent' + os.mkfifo(consent, mode=0o600) + descriptor = os.open(consent, os.O_RDONLY | os.O_NONBLOCK | os.O_NOFOLLOW) + try: + print('Operator review required: read ' + str(directory / 'literal-review.txt') + + ' and its literal-review.json signing request through the trusted container operator shell; then write "approve ' + + name + '" followed by a newline to ' + str(consent), flush=True) + deadline, response = time.monotonic() + 600, b'' + while time.monotonic() < deadline: + require(len(response) < 256, 'demo.operator-review-response-bound') + try: + part = os.read(descriptor, 256 - len(response)) + except BlockingIOError: + part = b'' + response += part + if b'\n' in response: + require(response == ('approve ' + name + '\n').encode(), + 'demo.operator-review-declined') + return + time.sleep(0.05) + raise Refusal('demo.operator-review-expired') + finally: + os.close(descriptor) + consent.unlink(missing_ok=True) + + class Operator: def __init__(self, mode): require(os.getuid() == 0, 'demo.operator-root-required') @@ -204,6 +297,7 @@ def __init__(self, mode): self.sockets.mkdir(mode=0o750) os.chown(self.sockets, 0, APP_GID) self.port = None + self.effect_reviewer = development_ed25519_identity_key() def start_gateway(self, host): socket_path = self.sockets / ('app' + str(host) + '.sock') @@ -260,31 +354,194 @@ def prepare(self): plan = asyncio.run(authority(self.binary, resources, HOME, self.mode)) attempts = HOME / 'attempts' attempts.mkdir(mode=0o700) + effect_policy = PRIVATE / 'effect-policy.json' + write(effect_policy, gateway(self.binary, 'effect-policy', '--partition', 'stripe-demo', + '--epoch', '1', '--approver-public-key', self.effect_reviewer.public_key.hex()), new=True) for host in range(3): state = HOME / ('gateway' + str(host)) args = [self.binary, 'install', '--state-dir', state, '--recipe', HERE / 'recipe.json', '--profile-lock', HERE / 'profile.lock.json', '--trusted-context', - HOME / 'private' / ('context-' + str(1 if host == 2 else 0) + '.cbor'), '--approve-digest', plan['recipe_digest'], - '--provider', 'stripe', '--alias', 'demo' + str(host), '--credential-stdin', - '--attempt-store', attempts, '--account-label', resources['platform']] - # Each installation checks the account and restricted credential. - # All three share the operation/budget store; no simulation join - # may accidentally probe the live provider with a synthetic key. - if self.port is not None: - args.extend(['--loopback-provider', self.port]) + PRIVATE / 'context-0.cbor', '--effect-policy', effect_policy, + '--approve-digest', plan['recipe_digest'], '--provider', 'stripe', + '--alias', 'demo', '--credential-stdin', '--attempt-store', attempts] + args.extend(['--account-label', resources['platform']] if host == 0 else ['--join']) child(args, stdin=(self.keys['runtime'] + '\n').encode()) + proposal = state / 'candidate-installation.json' + if proposal.exists(): + call = PRIVATE / 'candidate-call.json' + gateway(self.binary, 'effect-candidate-call', '--state-dir', state, + '--candidate', proposal, '--operation', 'install-check', '--call-out', call) + proof, action = asyncio.run(self.read_packet(decode(read(call)), plan)) + approved = self.exact_approval(state, 'install-check', proof, action, + '--candidate', proposal) + require(approved is not None, 'demo.candidate-effect-approval-unavailable') + arguments = ['--state-dir', state, '--candidate', proposal, '--proof', approved[0], + '--action', approved[1], '--approval', approved[2]] + local = ['--loopback-provider', self.port] if self.port is not None else [] + gateway(self.binary, 'candidate-acquire', *arguments, *local) + gateway(self.binary, 'candidate-publish', *arguments) # A shared software observer exists only in this labeled development # deployment. It is never a production signing-custody claim. gateway(self.binary, 'observer-init', '--state-dir', HOME / 'gateway0') for host in [1, 2]: write(HOME / ('gateway' + str(host)) / 'observer.seed', read(HOME / 'gateway0' / 'observer.seed'), new=True) self.observer = decode(gateway(self.binary, 'observer-show', '--state-dir', HOME / 'gateway0')) + configuration = gateway(self.binary, 'effect-configuration-review', + '--state-dir', HOME / 'gateway0') + write(PRIVATE / 'configuration-review.json', configuration, new=True) + reviewed = decode(configuration) + gateway(self.binary, 'effect-configuration-activate', '--state-dir', HOME / 'gateway0', + '--expected-revision', reviewed['previous_revision_hex'], + '--expected-candidate', reviewed['candidate_hex']) write(HOME / 'private' / 'pins.json', canonical({'trusted_context_sha256': digest(read(HOME / 'private' / 'context-0.cbor')), 'observer': self.observer}), new=True) for host in range(3): self.start_gateway(host) + self.prepare_exact_approvals(plan) + self.start_recovery_reviews(plan) return plan + async def read_packet(self, call, plan): + """Managers simulate separately authorizing a native-authored read call.""" + contract, command = read_contract(call) + grant = decode(read(PRIVATE / 'read-grant.json')) + reader = load_signer_file(PRIVATE / 'reader.json').signer + managers = [load_signer_file(PRIVATE / (name + '.json')).signer for name in MANAGERS] + try: + proposal = propose_mcp_approval(contract=contract, command=command, + required=APPROVALS_REQUIRED, approvers=plan['approval']['principals'], + actor=reader.descriptor.principal, actor_grant=unb64(grant['bytes']), + challenge=unb64(plan['challenges'][0]), evaluation_time=int(time.time()), + validity_seconds=ACTION_VALIDITY_SECONDS) + responses = [] + for signer in managers[:APPROVALS_REQUIRED]: + request = next(item for item in approval_requests(proposal) + if item.approver == signer.descriptor.principal) + responses.append((await approve(open_approval_request(request.text, + now=int(time.time())), signer)).text) + signed = await sign_approval_action(proposal, reader, grants=[ + GrantEvidence(unb64(grant['bytes']), tuple(PublicControlEvidence( + item['type'], item['media_type'], unb64(item['bytes'])) + for item in grant['evidence']))]) + return collect_approvals(proposal, responses).assemble(signed), proposal.action + finally: + await reader.aclose() + for signer in managers: + await signer.aclose() + + def exact_approval(self, state, name, proof, action, *mode): + """Scripted reviewer over complete native literal output; no human-trial claim.""" + directory = PRIVATE / name + directory.mkdir(mode=0o700) + proof_path, action_path = directory / 'proof', directory / 'action' + request, approval = directory / 'request', directory / 'approval' + write(proof_path, proof, new=True) + write(action_path, action, new=True) + now = int(time.time()) + output = child([self.binary, 'effect-review', '--state-dir', state, + '--proof', proof_path, '--action', action_path, '--not-before', str(now - 1), + '--expires-at', str(now + ACTION_VALIDITY_SECONDS), '--request-out', request, + *mode], check=False) + if output.returncode != 0: + return None + review = decode(output.stdout) + require(review['schema'] == 'auths.private-effect-signing/2' + and review['renderer'] == 'auths.literal-complete-review/1' + and type(review['literal_review']) is str and review['literal_review'], + 'demo.native-effect-review-required') + write(directory / 'literal-review.json', output.stdout, new=True) + write(directory / 'literal-review.txt', review['literal_review'].encode('utf-8'), new=True) + if self.mode == 'live': + operator_consent(directory, name) + signature = self.effect_reviewer.sign(bytes.fromhex(review['signing_message_hex'])) + write(approval, gateway(self.binary, 'effect-approval', '--request', request, + '--signature-hex', signature.hex()), new=True) + return proof_path, action_path, approval + + def prepare_exact_approvals(self, plan): + """Preapprove finite scripted mutations; refusals use an explicitly substituted approval.""" + application = Application(HOME / 'app', [self.sockets / ('app' + str(host) + '.sock') + for host in range(3)]) + values, reviews = {}, {} + for label in LABELS: + proof, action, _ = asyncio.run(application.packet(label)) + result = self.exact_approval(HOME / 'gateway0', 'effect-' + label, proof, action) + if result is not None: + values[label] = b64(read(result[2])) + review = decode(read(result[2].parent / 'literal-review.json')) + reviews[label] = review['literal_review'] + require('exact' in values, 'demo.exact-effect-approval-unavailable') + for label in LABELS: + # A malformed/unauthorized action cannot be reviewed. Sending an + # approval for another effect is an adversarial binding substitution, + # never an application-created authority or a bypass. + values.setdefault(label, values['exact']) + values['exact:fresh'] = values['exact'] + plan['effect_approvals'] = values + plan['effect_review'] = {'mode': ('scripted operator reviewer; not an independent human trial' + if self.mode == 'simulation' else 'separate private operator consent; development signing custody'), + 'renderer': 'auths.literal-complete-review/1', 'reviews': reviews} + write(HOME / 'app/application.json', canonical(plan)) + for path in (HOME / 'app').iterdir(): + os.chown(path, APP_UID, APP_GID) + + def prepare_recovery(self, source, sequence, plan): + """Produce separate read authority; deriving a call never grants entry.""" + operation = 'read-' + source + '-' + str(sequence) + call = decode(gateway(self.binary, 'effect-recovery-call', '--state-dir', HOME / 'gateway0', + '--source-operation', source, '--recovery-operation', operation)) + proof, action = asyncio.run(self.read_packet(call, plan)) + approved = self.exact_approval(HOME / 'gateway0', operation, proof, action, + '--recovery-of', source) + require(approved is not None, 'demo.recovery-review-refused') + return {'proof': b64(proof), 'action': b64(action), 'approval': b64(read(approved[2])), + 'literal_review': decode(read(approved[2].parent / 'literal-review.json'))['literal_review']} + + def start_recovery_reviews(self, plan): + """Finite development reviewer, isolated from the application's UID. + + This is an explicit operator signing channel, not native recovery + semantics. Live mode requires private operator consent in exact_approval. + """ + operator = self + counts = {} + + class Handler(socketserver.BaseRequestHandler): + def handle(self): + self.request.settimeout(660 if operator.mode == 'live' else 30) + def receive(length): + output = b'' + while len(output) < length: + block = self.request.recv(length - len(output)) + require(bool(block), 'demo.review-request-incomplete') + output += block + return output + try: + length = struct.unpack('>I', receive(4))[0] + require(0 < length <= 1024, 'demo.review-request-bound') + request = decode(receive(length)) + require(type(request) is dict and set(request) == {'source'} + and type(request['source']) is str + and request['source'] in plan['cases'], 'demo.review-source-refused') + source = request['source'] + sequence = counts.get(source, 0) + 1 + require(sequence <= 4, 'demo.review-attempt-limit') + counts[source] = sequence + response = operator.prepare_recovery(source, sequence, plan) + except (Refusal, ValueError, OSError, TimeoutError): + response = {'code': 'demo.operator-recovery-review-refused'} + raw = canonical(response) + require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') + self.request.sendall(struct.pack('>I', len(raw)) + raw) + + path = self.sockets / 'review.sock' + server = socketserver.UnixStreamServer(str(path), Handler) + os.chown(path, 0, APP_GID) + os.chmod(path, 0o660) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + self.review_server, self.review_thread = server, thread + def application(self, *arguments): return subprocess.run(['/opt/consumer/bin/python', str(HERE / 'app.py'), *arguments], env=ENVIRONMENT, capture_output=True, user=APP_UID, group=APP_GID, extra_groups=[], timeout=90) @@ -300,6 +557,10 @@ def witnesses(self): return values def stop(self): + if hasattr(self, 'review_server'): + self.review_server.shutdown() + self.review_server.server_close() + self.review_thread.join(timeout=5) for process, log, _ in self.processes: if process.poll() is None: process.terminate() diff --git a/demos/stripe-gateway/selftest.py b/demos/stripe-gateway/selftest.py index d6b8ae374..88f64657b 100644 --- a/demos/stripe-gateway/selftest.py +++ b/demos/stripe-gateway/selftest.py @@ -1,6 +1,10 @@ """Installed-client/native-process evidence; expected facts do not come from the UI.""" import base64 +import os +import tempfile +import time from pathlib import Path +from concurrent.futures import ThreadPoolExecutor import subprocess import urllib.request from urllib.parse import urlencode @@ -60,9 +64,27 @@ def execute(label): 'demo.selftest-read-guard:' + label) for label in ['exact', 'boundary']: result, records, traffic = execute(label) - require(records[0]['outcome'] == 'observed-by-provider', 'demo.selftest-observation:' + label) + require(records[0]['outcome'] == 'response-recorded' and records[0]['status'] == 200, + 'demo.selftest-response-is-not-observation:' + label) + _, recovery, recovery_traffic = execute('recover-' + label) + report = recovery[0]['report'] + require(recovery[0]['outcome'] == 'recovery-report' + and report['source']['stage'] == 'observed-by-provider' + and report['source']['provider_linked'] is True + and report['acquisition']['stage'] == 'response-recorded' + and report['disposition'] == 'recorded' + and not any(item['kind'] == 'write' for item in recovery_traffic) + and cases[-1]['native_counters']['write_transport_entries'] == 0, + 'demo.selftest-independent-native-observation:' + label) + inspect_before, inspect_traffic = operator.witnesses(), len(entries()) + inspected = operator.application('submit', '--experiment', label) + require(inspect_before == operator.witnesses() and inspect_traffic == len(entries()), + 'demo.selftest-source-inspection-must-not-enter-provider') + require(inspected.returncode == 0, 'demo.selftest-source-inspection-refused') + records = [item['result'] for item in decode(inspected.stdout)['records']] + require(records[0]['outcome'] == 'observed-by-provider', 'demo.selftest-source-observation') writes = [item for item in traffic if item['kind'] == 'write'] - require(len(writes) == 1 and cases[-1]['native_counters']['write_transport_entries'] == 1, + require(len(writes) == 1 and cases[-2]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-write-count:' + label) action = result['action'] echo = records[0]['evidence']['echo'] @@ -85,22 +107,37 @@ def execute(label): require(refund['amount'] == action['amount'] and refund['payment_intent'] == action['payment_intent'] and refund['metadata']['auths_echo'] == echo, 'demo.selftest-independent-read-back') cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(refund_bytes)} - for label in ['replay', 'fresh-replay', 'typescript']: + for label in ['replay', 'typescript']: _, records, traffic = execute(label) - require(records[0]['outcome'] == 'not-entered' and records[0]['code'] == 'gateway.attempt.replay' - and not traffic and cases[-1]['native_counters']['credential_lease_calls'] == 0, - 'demo.selftest-replay:' + label) + require(records[0]['outcome'] == 'observed-by-provider' + and not traffic and not any(cases[-1]['native_counters'].values()), + 'demo.selftest-replay-retains-observation-without-new-entry:' + label) + _, records, traffic = execute('fresh-replay') + require(records[0]['outcome'] == 'denied' and records[0]['code'] == 'challenge-mismatch' + and not traffic and not any(cases[-1]['native_counters'].values()), + 'demo.selftest-substituted-challenge-under-installed-trust') _, records, traffic = execute('race') - require(sorted(item['outcome'] for item in records) == ['not-entered', 'observed-by-provider'] + require(any(item['outcome'] == 'response-recorded' for item in records) + and all(item['outcome'] in ('reserved', 'unknown', 'response-recorded') for item in records) and sum(item['kind'] == 'write' for item in traffic) == 1 and cases[-1]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-two-process-race') + # A contender can inspect the winner after durable entry but before its + # response is recorded, so Unknown is a truthful interim projection. Once + # both calls finish, exact replay must converge without any external I/O. + race_before, race_entries = operator.witnesses(), len(entries()) + replayed = operator.application('submit', '--experiment', 'race') + require(replayed.returncode == 0 + and decode(replayed.stdout)['records'][0]['result']['outcome'] == 'response-recorded' + and race_before == operator.witnesses() and race_entries == len(entries()), + 'demo.selftest-race-final-history-without-new-entry') operator.restart(0) _, records, traffic = execute('replay') - require(records[0]['code'] == 'gateway.attempt.replay' and not traffic, 'demo.selftest-restart-replay') + require(records[0]['outcome'] == 'observed-by-provider' and not traffic + and not any(cases[-1]['native_counters'].values()), 'demo.selftest-restart-replay') cases[-1]['case'] = 'restart-replay' for name in ['count', 'sum']: _, records, traffic = execute(name + '-positive') - require(records[0]['outcome'] == 'observed-by-provider' + require(records[0]['outcome'] == 'response-recorded' and sum(item['kind'] == 'write' for item in traffic) == 1, 'demo.selftest-budget-positive') _, records, traffic = execute(name + '-overflow') require(records[0]['outcome'] == 'not-entered' and not traffic @@ -111,14 +148,15 @@ def execute(label): and cases[-1]['native_counters']['write_transport_entries'] == 1 and any(item['response_dropped_after_effect'] for item in traffic), 'demo.selftest-loss-after-effect') _, records, traffic = execute('lost-response') - require(records[0]['outcome'] in ['not-entered', 'unknown'] - and not any(item['kind'] == 'write' for item in traffic), 'demo.selftest-unknown-never-retries') + require(records[0]['outcome'] == 'unknown' and not traffic + and not any(cases[-1]['native_counters'].values()), 'demo.selftest-unknown-never-refetches-or-retries') return cases def test_application_isolation_and_native_audit(operator): from operate import APP_UID, APP_GID, ENVIRONMENT, HOME, child - private = [HOME / 'private' / 'root.seed', + private = [HOME / 'private' / 'root.seed', HOME / 'private' / 'reader.seed', + HOME / 'private' / 'read-grant.json', *(HOME / 'private' / (name + '.seed') for name in ['manager-a', 'manager-b', 'manager-c']), HOME / 'gateway0' / 'credentials.cbor', @@ -153,14 +191,93 @@ def test_application_isolation_and_native_audit(operator): return {'doctor': doctor_value, 'audit': result} +def test_exact_operator_consent_binding(operator): + """Exercise private consent transport; scripted input is not a human trial.""" + from operate import HOME, operator_consent + from demo_common import Refusal + before = operator.witnesses() + for accepted in [False, True]: + with tempfile.TemporaryDirectory(prefix='consent-test-', dir=HOME / 'private') as temporary: + directory = Path(temporary) + write(directory / 'literal-review.json', + read(HOME / 'private/effect-exact/literal-review.json'), new=True) + write(directory / 'literal-review.txt', + read(HOME / 'private/effect-exact/literal-review.txt'), new=True) + with ThreadPoolExecutor(max_workers=1) as pool: + pending = pool.submit(operator_consent, directory, 'exact-consent-test') + fifo, deadline = directory / 'consent', time.monotonic() + 5 + while not fifo.exists() and time.monotonic() < deadline: + time.sleep(0.01) + require(fifo.exists() and fifo.stat().st_mode & 0o777 == 0o600, + 'demo.selftest-consent-not-private') + # The trusted operator channel supplies the exact operation + # token; changing it cannot approve the saved native request. + with fifo.open('wb', buffering=0) as stream: + stream.write(b'approve exact-consent-test\n' if accepted else b'approve another-operation\n') + if accepted: + require(pending.result(timeout=5) is None, 'demo.selftest-consent-not-accepted') + else: + try: + pending.result(timeout=5) + raise AssertionError('substituted operator consent accepted') + except Refusal as error: + require(str(error) == 'demo.operator-review-declined', + 'demo.selftest-consent-wrong-refusal') + require(not fifo.exists() and not (directory / 'approval').exists(), + 'demo.selftest-consent-created-authority') + require(before == operator.witnesses(), 'demo.selftest-consent-entered-provider') + return {'cases': 2, 'changed_operation_refused': True, 'owner_only_fifo': True, + 'provider_entries': 0, 'human_trial': False} + + +def test_private_reviewer_refuses_unlisted_inputs(operator): + """Unlisted or malformed app requests receive no read proof or exact approval.""" + from operate import APP_UID, APP_GID, ENVIRONMENT, HOME + script = r""" +import json, socket, struct, sys +results = [] +for value in [{'source': 'unlisted'}, {'source': []}, {'source': 'exact', 'url': 'https://other.example'}]: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as channel: + channel.settimeout(5) + channel.connect(sys.argv[1]) + raw = json.dumps(value).encode() + channel.sendall(struct.pack('>I', len(raw)) + raw) + def receive(length): + output = b'' + while len(output) < length: + part = channel.recv(length - len(output)) + if not part: + raise RuntimeError('incomplete reviewer response') + output += part + return output + length = struct.unpack('>I', receive(4))[0] + if not 0 < length <= 1024: + raise RuntimeError('reviewer response bound') + results.append(json.loads(receive(length))) +print(json.dumps(results)) +""" + before = operator.witnesses() + result = subprocess.run(['/opt/consumer/bin/python', '-c', script, + str(HOME / 'sockets/review.sock')], user=APP_UID, group=APP_GID, extra_groups=[], + env=ENVIRONMENT, capture_output=True, timeout=20) + require(result.returncode == 0, 'demo.selftest-review-channel-unavailable') + refusals = decode(result.stdout) + require(refusals == [{'code': 'demo.operator-recovery-review-refused'}] * 3 + and before == operator.witnesses(), 'demo.selftest-review-channel-minted-authority') + return {'cases': 3, 'app_uid': APP_UID, 'native_counters_unchanged': True, + 'returned_proof_or_approval': False} + + def run(operator): from operate import HOME + consent = test_exact_operator_consent_binding(operator) + reviewer = test_private_reviewer_refuses_unlisted_inputs(operator) cases = test_native_refusals_replay_race_and_loss(operator) verified = test_application_isolation_and_native_audit(operator) report = {'schema': 'auths.stripe-gateway-demo-evidence/1', 'mode': 'simulation', 'production_qualification': False, 'independent_human_trial': False, 'source_commit': decode(read(Path(__file__).parent / 'manifest.json'))['source_commit'], - 'cases': cases, **verified, + 'operator_consent': consent, 'operator_review_channel': reviewer, 'cases': cases, **verified, 'excluded': ['live Stripe writes', 'production AWS custody and PostgreSQL', 'protected full-corpus qualification', 'provider key rotation', 'independent security review', 'GitHub release installation']} @@ -171,7 +288,7 @@ def run(operator): require(support.returncode == 0, 'demo.selftest-support-refused') published = data + audit + support.stdout private_seeds = [read(HOME / 'private' / (name + '.seed')) - for name in ['root', 'manager-a', 'manager-b', 'manager-c']] + for name in ['root', 'reader', 'manager-a', 'manager-b', 'manager-c']] for secret in list(operator.keys.values()) + private_seeds + [read(HOME / 'app/actor.seed')]: raw = secret.encode() if isinstance(secret, str) else secret for encoded in [raw, raw.hex().encode(), base64.b64encode(raw), base64.urlsafe_b64encode(raw)]: diff --git a/demos/stripe-gateway/submit.mts b/demos/stripe-gateway/submit.mts index 4ebe7a679..fdb7e2147 100644 --- a/demos/stripe-gateway/submit.mts +++ b/demos/stripe-gateway/submit.mts @@ -10,7 +10,7 @@ for await (const chunk of process.stdin) { if (input.length > 8 * 1024 * 1024) throw new Error('demo.packet-bound'); } const packet = JSON.parse(input) as Record; -if (Object.keys(packet).sort().join(',') !== 'action_b64,proof_b64') throw new Error('demo.invalid-packet'); +if (Object.keys(packet).sort().join(',') !== 'action_b64,approval_b64,proof_b64') throw new Error('demo.invalid-packet'); function bytes(value: unknown): Uint8Array { if (typeof value !== 'string' || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error('demo.invalid-packet'); const result = Buffer.from(value, 'base64url'); @@ -18,4 +18,4 @@ function bytes(value: unknown): Uint8Array { return result; } const client = new GatewayClient(new GatewayEndpoint(socket)); -console.log(JSON.stringify(await client.submit({proof: bytes(packet.proof_b64), action: bytes(packet.action_b64)}))); +console.log(JSON.stringify(await client.submit({proof: bytes(packet.proof_b64), action: bytes(packet.action_b64), approval: bytes(packet.approval_b64)}))); diff --git a/demos/stripe-gateway/tests/browser.py b/demos/stripe-gateway/tests/browser.py index 1057e887d..bbe635b9e 100644 --- a/demos/stripe-gateway/tests/browser.py +++ b/demos/stripe-gateway/tests/browser.py @@ -16,8 +16,8 @@ def test_packaged_workbench_and_unsigned_evidence(): expect(page.locator('#approval-review')).to_contain_text('create_refund_v1') for case, outcome in [('approval-insufficient', 'DENIED'), ('approval-duplicate', 'NOT-SUBMITTED'), - ('above-boundary', 'NOT-ENTERED'), ('exact', 'OBSERVED-BY-PROVIDER'), - ('replay', 'NOT-ENTERED'), ('lost-response', 'UNKNOWN')]: + ('above-boundary', 'NOT-ENTERED'), ('exact', 'RESPONSE-RECORDED'), ('recover-exact', 'RECOVERY-REPORT'), + ('replay', 'OBSERVED-BY-PROVIDER'), ('lost-response', 'UNKNOWN')]: page.locator('#experiment').select_option(case) page.locator('#submit').click() expect(page.locator('#outcome')).to_have_text(outcome, timeout=45000) diff --git a/demos/stripe-gateway/web/app.js b/demos/stripe-gateway/web/app.js index 219b13925..c06c2e513 100644 --- a/demos/stripe-gateway/web/app.js +++ b/demos/stripe-gateway/web/app.js @@ -3,6 +3,9 @@ const element = id => document.getElementById(id); const descriptions = { 'observed-by-provider': 'A fresh provider read matched the verified value and this action’s echo. The link assumes no other writer copied the echo.', observed: 'The gateway read the declared field. Value equality alone does not link that value to this action or establish its effect.', + 'recovery-report': 'A separately authorized read completed. Inspect the original write stage, read facts and evidence disposition below; a state match alone is not causation.', + refused: 'The gateway refused this recovery action. No new write was authorized.', + reserved: 'The operation is reserved. Another process may still be working; this is not permission to repeat delivery.', 'response-recorded': 'The gateway recorded an HTTP response. This alone does not establish an effect.', unknown: 'The outcome remains unknown. The provider may have received the write; its response or locator is unavailable. Authority remains consumed; no automatic retry is allowed.', 'not-entered': 'The gateway refused before write transport. A provider-read guard may already have acquired a credential and read evidence.', @@ -20,6 +23,8 @@ function display(record) { : item.result.outcome.toUpperCase()).join(' / '); element('explanation').textContent = outcomes.map(value => descriptions[value] || 'Inspect the exact gateway result below.').join(' '); element('result-json').textContent = JSON.stringify(record, null, 2); + const reviewed = record.records.find(item => item.result.literal_review); + if (reviewed) element('approval-review').textContent = reviewed.result.literal_review; } async function initialize() { const response = await fetch('/api/status'); @@ -47,8 +52,9 @@ async function initialize() { const value = element('experiment').value; const action = status.proposals[value] || status.proposals.exact; element('proposal').textContent = `${action.payment_intent} · ${action.amount / 100} ${action.currency.toUpperCase()} · operation ${action.operation_id}`; - const review = status.approval.reviews[value] || status.approval.reviews.exact; - element('approval-review').textContent = `${review.title} · ${review.fields.map(([label, field]) => `${label}: ${field}`).join(' · ')} · expires ${new Date(review.valid_until * 1000).toLocaleTimeString()}`; + const source = value.startsWith('recover-') ? value.slice(8) : value; + const review = status.effect_review.reviews[source] || (['replay', 'typescript', 'observe'].includes(value) ? status.effect_review.reviews.exact : null); + element('approval-review').textContent = value.startsWith('recover-') ? 'A separate native read review and operator consent are required. The exact read review is retained with its result.' : review || 'Native review refused this hostile input. This experiment substitutes another effect’s approval and must be rejected.'; const link = element('provider-link'); link.hidden = status.mode !== 'live' || !/^pi_[A-Za-z0-9]+$/.test(action.payment_intent); if (!link.hidden) link.href = `https://dashboard.stripe.com/test/payments/${action.payment_intent}`; diff --git a/demos/stripe-gateway/web/index.html b/demos/stripe-gateway/web/index.html index be03b5599..e40a9b50b 100644 --- a/demos/stripe-gateway/web/index.html +++ b/demos/stripe-gateway/web/index.html @@ -26,7 +26,7 @@

Let the app request a refund.
Keep the Stripe key out of its hands.

-

Each experiment fixes its payment, operation and signed arguments.

+

Each experiment fixes its payment, operation and signed arguments.

The native review binds the exact action, authority and expiry.

diff --git a/demos/stripe-gateway/web/styles.css b/demos/stripe-gateway/web/styles.css index cafb35838..ddd8ea6fc 100644 --- a/demos/stripe-gateway/web/styles.css +++ b/demos/stripe-gateway/web/styles.css @@ -1,3 +1,5 @@ :root{font-family:Inter,ui-sans-serif,system-ui,sans-serif;color:#122035;background:#f7f8fa;font-synthesis:none}*{box-sizing:border-box}body{margin:0}header,footer{padding:24px max(24px,calc((100vw - 1120px)/2));display:flex;justify-content:space-between;gap:20px;border-bottom:1px solid #dde2ea}header a{font-weight:800;letter-spacing:.08em;text-decoration:none;color:#122035}header span{font-size:11px;letter-spacing:.09em;font-weight:700;color:#25615a}main{max-width:1120px;margin:auto;padding:64px 24px}.eyebrow{font-size:12px;text-transform:uppercase;letter-spacing:.15em;color:#416489;font-weight:700}h1{font-size:clamp(30px,4vw,49px);line-height:1.16;letter-spacing:-.045em;margin:14px 0 22px}h2{font-size:21px;margin-top:0}.intro{font-size:18px;line-height:1.6;max-width:750px;color:#4a5c72}#connection{margin:30px 0;padding:14px 18px;border-left:3px solid #3574d5;background:#eef3fb;font-size:14px}.workbench{display:grid;grid-template-columns:1fr 1fr;gap:24px;margin:32px 0}article,.result{border:1px solid #dbe2ed;background:white;border-radius:12px;padding:28px}article p,.limits p{font-size:14px;line-height:1.7;color:#526074}dl{display:grid;grid-template-columns:1fr 1.4fr;gap:14px;font-size:13px}dt{color:#637389}dd{margin:0;font-weight:650;overflow-wrap:anywhere}.digest{font-family:ui-monospace,monospace;font-size:11px}label{display:block;font-size:13px;font-weight:700;margin:24px 0 10px}select{width:100%;padding:14px;background:#f7f9fd;border:1px solid #b7c6da;border-radius:7px;font:inherit;font-size:14px}button{width:100%;padding:16px;border:0;border-radius:7px;background:#2563eb;color:white;font:inherit;font-size:14px;font-weight:700;cursor:pointer}button:disabled{opacity:.5;cursor:wait}.small{font-size:12px!important}.stages{display:flex;flex-wrap:wrap;gap:8px;list-style:none;padding:0;color:#55708c;font-size:12px}.stages li{border:1px solid #dde5ef;padding:8px;border-radius:5px}.result #outcome{overflow-wrap:anywhere;font-size:26px}.result p{line-height:1.7;color:#526074}pre{white-space:pre-wrap;overflow-wrap:anywhere;background:#111f34;color:#d7e5f7;border-radius:8px;padding:22px;font:12px/1.65 ui-monospace,monospace;max-height:450px;overflow:auto}.result a{display:inline-block;padding-top:12px;font-size:14px;font-weight:700;color:#2563eb}.limits{padding:34px 2px 0;max-width:860px}footer{border-top:1px solid #dde2ea;font-size:12px;color:#637389;justify-content:center}@media(max-width:760px){main{padding-top:34px}.workbench{grid-template-columns:1fr}header{flex-direction:column}article,.result{padding:22px}dl{grid-template-columns:1fr 1fr}.result #outcome{font-size:21px}} #provider-link{display:block;margin:14px 0;color:#2563eb;font-weight:700;font-size:14px}#provider-link[hidden]{display:none} + +#approval-review { white-space: pre-wrap; overflow-wrap: anywhere; } diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index be5f40cb8..605d28aef 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1667,6 +1667,108 @@ closure regeneration passed after that correction (one artifact-generation test) all crash/fault and dependency-race schedules, hostile agent containment and human UI remain open. A04 remains partial; no acceptance row is closed here. +## Holistic CI contract and prerequisite-ownership checkpoint + +- Integrated isolated batch `ce308315` as `08f0064c`, directly after the two + native process-capacity commits. The batch preserves a shared parent's + reservation when a different process owns an unresolved prerequisite read. + Missing/in-flight evidence cannot be recorded as a terminal negative provider + predicate and suppress that owner's valid write. No retry permit is minted. +- Deterministic paused-read regressions on file and TLS PostgreSQL retain + Reserved for the contender, complete ResponseRecorded for the owner and count + exactly one write, three credential reads and one ceiling read, with no + recovery read. These use the post-verification reference driver; the separate + native process cases still establish full native acquisition checking. +- The batch repairs all currently inspected preflight/API/scenario/simulation + roots together: canonical compliance roles with preserved evidence anchors, + Python GatewayReserved snapshot, stale quorum proof fixture, complete review + declarations, native application frames, code/source inventories and strict + workspace lint. No lint suppression, security assertion or store deadline was + weakened. Synthetic qualification reports remain explicitly response-only + references and do not establish independently authorized native recovery. +- In the isolated checkout, actual `xtask ci preflight` passed, including strict + all-target/all-feature workspace clippy and real compliance. The gateway run + passed 277 behavioral tests with ignored TLS PostgreSQL cases enabled and four + test threads; after source-closure regeneration its separate exact check passed + 1/1. Five changed CLI targets passed 8/8 tests. Python API inventory passed. + An earlier unrestricted local run hit the existing file-lock deadline under + I/O saturation; the deadline/assertions were retained, the exact isolated case + and bounded-parallel full behavior run passed. This is not a hosted green claim. +- Remote remains `6009de25` until the next integrated push. Required hosted + formal/authoritative/secret/dependency checks still need the final combined + source. Early green workflow subsets or skipped aggregate wrappers do not + close the goal. + +## Maintained demo native approval and explicit recovery checkpoint + +- Both managed demo installers now create native exact-effect policies, stage + credential-bearing candidates, separately authorize/acquire their native + credential checks and publish retained evidence. Additional hosts join the + same connection/alias, trust, policy and shared store with separate custody. + Installing the software observer explicitly reviews and activates the changed + configuration using native revision/candidate CAS tokens. +- Mutation packets now carry native exact-effect approvals unchanged through + installed Python and TypeScript GatewayClient surfaces. The scripted reviewer + signs the full native literal review/signing request using an operator-only + ephemeral key. Invalid actions that cannot be reviewed are deliberately sent + with a different valid effect's approval as a binding-substitution negative + case; no placeholder or bypass approval is accepted. +- Reserved candidate/recovery reads have their own private actor grant and + native quorum proofs. A bounded development reviewer socket can authorize only + listed fixture sources, at most four explicit read requests per source. The + native owner still determines whether the exact read can be compiled, + admitted, charged, entered or recorded. Python supplies no outcome reducer. +- Simulation labels its automatic reviewer honestly. Live test-provider mode + requires explicit consent on a separate owner-only FIFO for the entire saved + native literal review; the application cannot read/write that channel. A + missing/different token or ten-minute expiry fails closed before signing. + This is development Docker-operator custody, not an independent-human trial, + remote approval inbox or production signing-custody claim. Actual live-provider + execution of this channel has not been run. +- Writes expose ResponseRecorded without implicit read-back. A separate approved + native recovery operation returns the unchanged tagged report with original + mutation facts, independent read charges and evidence disposition. Exact replay + retains current facts without provider I/O. A different challenge under the + unchanged installed context is denied before custody; no second installation + silently activates different trust to make that action eligible. A Stripe + unknown without a retained response locator cannot manufacture an observation. +- Updated evidence keeps independent exact HTTP mapping/read-back, negative + pre-custody checks, budgets, two-process single-write races and process kills. + Airtable crash replay now explicitly proves zero reads/writes before a + separately authorized recovery read establishes the linked observation. The + frontend displays the complete native literal review using textContent and + distinguishes response facts from the separate native recovery report. +- Targeted diagnosis of the known hosted demo failures rebuilt the native + loopback binary at `08f0064c`. Same-UID reproductions passed 23 Stripe cases, + 34 Airtable cases and two Airtable SIGKILL/reopen cases. Both TypeScript clients + compiled and executed their gateway transport. The diagnostic Python native + extension and npm build were the CI checkout's c809-era artifacts, with current + wrappers; these are not fresh exact-head installed-release evidence. Temporary + kit/harness files were outside the repository; no authorization check or native + engine was mocked, while OS ownership wiring was adapted to the current UID. +- A concurrent diagnosis found a truthful interim Unknown projection for a race + contender inspecting the winning process after durable entry but before its + response persistence. The external counter and protected final journal showed + one write and ResponseRecorded. The race tests retain exactly-one-write and + a successful response, accept that interim native projection, and additionally + require final exact replay to converge without any read/write/custody entry. + This does not permit a terminal refusal to poison the parent or an unknown + outcome to retry. The prior prerequisite ownership defect still fails it. +- Owner-only consent mechanics (two exact/substituted-token cases) and malformed/ + unlisted reviewer requests (three cases returning no proof or approval) passed + the same-UID diagnostic with unchanged native counters. They are now authored + as explicit demo selftests. Docker UID containment, complete native + log/output sentinels, browser execution and newly built installed package + evidence remain required in hosted CI. No A01–A22 row is fully closed. The CI + agent continues the separate example/scaffold cutover while core fault, + fixed-window capacity, dependency-race, differential/formal/performance gates + remain open. AP070/AP073 were not changed. + +- Semantic freeze 394 records the updated managed demo/compliance contract; + identity protocol 140, public SDK contract 137 and public surface 394 were + explicitly advanced. Generated source/formal identities were not reclassified + as proved by these inventory updates. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index a273284e6..2b490cc01 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 393 +freeze_version = 394 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 393 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 139 +"auths.identity.protocol" = 140 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 124 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 393 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 136 +"auths.product.public-sdk-contract" = 137 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 393 +"auths.release.public-surface" = 394 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 2a3afb8fa..8f8140820 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 393, + "freezeVersion": 394, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 139, + "version": 140, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "a54efb0206b19e48d9f26a295cd3e8b1657057edea21c3efaea8d2c1d059dda0" + "sha256": "815d6e8ec9ff5d0dbfea3f8eb03f51dcbd012a037ce81387cda0e75f16a1cb95" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 136, + "version": 137, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "415904ac0bf46f0d5bdf2a15ba4eaddef29a1706e6deccf8b41d4da0822bf7ee" + "sha256": "ac1053fd2412b4cceb83f85287cd48b17dd7fe0d2bfc69b714fa1d4b44d6cf38" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 393, + "version": 394, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "b24f958b71cbff00bed20da6b21cdeaf3dd9227ce95db4f50fabcf61ab3b57d9" + "sha256": "7ba758b2e0d287819fe098134599f634a893a28251a60518ab44e8a4b2a67315" } ] } From 8ab0136dc7dd3ab7174c836c97ba641315bd19db Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 00:50:58 +0000 Subject: [PATCH 070/136] fix(examples): authorize native candidate and recovery effects across SDK journeys --- .github/workflows/sdk-recipes.yml | 10 + .../python/python/auths/_enforcement_init.py | 1 + .../stripe-refund-approval/README.md.tmpl | 27 +- .../app/refund_client.py.tmpl | 11 +- .../lib/native_operator.py.tmpl | 455 ++++++++++++++++++ .../lib/operate.py.tmpl | 42 +- .../lib/selftest.py.tmpl | 25 +- .../python/tests/test_enforcement_init.py | 157 +++++- examples/stripe-refund-approval/README.md | 75 +-- examples/stripe-refund-approval/journey.py | 67 ++- .../stripe-refund-approval/native_operator.py | 455 ++++++++++++++++++ examples/stripe-refund-approval/refunds.py | 28 +- .../typescript/journey.ts | 69 ++- .../typescript/refunds.ts | 70 ++- 14 files changed, 1402 insertions(+), 90 deletions(-) create mode 100644 bindings/python/python/auths/_templates/stripe-refund-approval/lib/native_operator.py.tmpl create mode 100644 examples/stripe-refund-approval/native_operator.py diff --git a/.github/workflows/sdk-recipes.yml b/.github/workflows/sdk-recipes.yml index 8774a8ee0..2c75444c5 100644 --- a/.github/workflows/sdk-recipes.yml +++ b/.github/workflows/sdk-recipes.yml @@ -223,6 +223,15 @@ jobs: - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 with: python-version: "3.12" + # The application below consumes the packed npm SDK. The independent + # operator uses the packed Python SDK to authorize native read calls; + # this is deployment tooling, not TypeScript proof-authoring evidence. + - run: python -m venv .operator-venv + - run: .operator-venv/bin/python -m pip install maturin==1.9.6 + - run: >- + .operator-venv/bin/maturin build --profile python-extension --locked + --manifest-path bindings/python/Cargo.toml --out target/operator-wheels + - run: .operator-venv/bin/python -m pip install target/operator-wheels/auths-*.whl - run: npm ci working-directory: bindings/typescript - run: cargo install wasm-pack --version 0.15.0 --locked @@ -248,6 +257,7 @@ jobs: working-directory: examples/stripe-refund-approval/typescript run: >- node build/journey.js + --python "$GITHUB_WORKSPACE/.operator-venv/bin/python" --gateway "$GITHUB_WORKSPACE/target/debug/auths-gateway" --summary "$GITHUB_WORKSPACE/target/journey-artifacts/journey-npm-summary.json" - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 diff --git a/bindings/python/python/auths/_enforcement_init.py b/bindings/python/python/auths/_enforcement_init.py index d6873ba26..66ac975fc 100644 --- a/bindings/python/python/auths/_enforcement_init.py +++ b/bindings/python/python/auths/_enforcement_init.py @@ -62,6 +62,7 @@ ("dev/stripe_double.py", "dev/stripe_double.py.tmpl", 0o644), ("dev/gateway_witness.py", "dev/gateway_witness.py.tmpl", 0o644), ("lib/common.py", "lib/common.py.tmpl", 0o644), + ("lib/native_operator.py", "lib/native_operator.py.tmpl", 0o644), ("lib/operate.py", "lib/operate.py.tmpl", 0o644), ("lib/approve.py", "lib/approve.py.tmpl", 0o644), ("lib/selftest.py", "lib/selftest.py.tmpl", 0o644), diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl index 273c761fc..c9d50afcd 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl @@ -91,7 +91,7 @@ bin/install-gateway < @@KEY_FILE@@ bin/start bin/request --operation-id refund-1 --payment-intent pi_mock_journey --amount 1500 bin/approve @@FIRST_MANAGER@@ requests/refund-1/@@FIRST_MANAGER@@.request # any @@APPROVALS@@ managers -bin/submit --operation-id refund-1 +bin/submit --operation-id refund-1 --recover bin/export bin/audit bin/stop @@ -112,8 +112,11 @@ It runs `auths-gateway review` and `bound-extension`, which contact nothing. It refuses a project that is already set up. **`bin/install-gateway < KEY_FILE`** (operator) installs the gateway with -the Stripe key on standard input, then creates its observer key and -completes `audit/pins.json`. The key reaches only the gateway, which stores +the Stripe key on standard input as an unpublished candidate. It obtains a +separate native candidate-check proof and exact approval, executes those +bounded reads, and publishes only from their retained results. It then creates +the observer key, activates the exact reviewed configuration, and completes +`audit/pins.json`. The key reaches only the gateway, which stores it under `enforcement/gateway/`; no file, argument, environment variable, or log here receives it, and a terminal on standard input is refused. The recipe accepts only a Stripe restricted test key, whose prefix is @@ -125,7 +128,8 @@ test mode it never reads its standard input: the install inherits it. A second install is refused (`gateway.install.already-installed`). **`bin/start`** and **`bin/stop`** (operator) start and stop the gateway, and -in double mode the counting Stripe double on 127.0.0.1. The gateway listens +the separate operator reviewer, and in double mode the counting Stripe double +on 127.0.0.1. The gateway listens on `run/app.sock` for the agent and on `run/admin.sock` for the operator. **`bin/request`**, **`bin/approve`**, **`bin/submit`** (agent and managers). @@ -135,6 +139,7 @@ The agent writes one approval request per manager into `--decline` signs a decline. The agent's own approval never counts. `bin/submit` collects whatever responses exist; once @@APPROVALS@@ managers approved, the agent signs its exact refund and the assembled proof goes to +the separate operator reviewer for a native exact-effect approval and then to the gateway, which alone decides the approval threshold, the ceiling, the per-window count and sum, and whether an operation ID may run again. One decline beside enough approvals does not stop a refund; when too many @@ -142,6 +147,20 @@ managers declined for enough approvals to remain possible, nothing is sent. Ever `decided_by`: `gateway`, `approver`, or `client`. `request --precheck` is an opt-in client-side pre-check, not an enforcement boundary. +The reviewer has its own read-actor grant and exact-effect key under +`operator/effects/`. Double mode is a finite scripted simulation, never a human +approval trial. Stripe test mode saves the exact full text in `literal-review.txt` +and its native request in `signing-request.json`, and waits for the operator's +exact consent through the private FIFO; +`run/operator.log` gives its path. No unattended live effect signature is made. +All roles still share one OS user, so these paths do not establish isolation. + +A successful write reports `response-recorded`. `bin/submit --recover` explicitly +asks for a fresh, separately authorized native recovery read. The unchanged +`recovery.report` must show a provider-linked source before the audit can claim +`observed-by-provider`; a write response alone is insufficient. Plain `submit` +does not recover implicitly. + **`bin/export`** (agent) writes `audit/bundle.json`: one entry per operation ID, the approval responses, the recipe, and the trusted context. diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl index ff052c7a4..076cbb8cc 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl @@ -303,9 +303,17 @@ async def _submit(options: argparse.Namespace) -> Dict[str, Any]: await loaded.signer.aclose() proof = collection.assemble(action) gateway = GatewayClient(GatewayEndpoint(inside(options.socket))) - result = await gateway.submit(proof=proof, action=proposal.action) + from native_operator import request, unb64 + reviewed = request(PROJECT / "run" / "operator.sock", {"kind": "approve", "proof": _b64(proof), + "action": _b64(proposal.action)}) + result = await gateway.submit(proof=proof, action=proposal.action, approval=unb64(reviewed["approval"])) + record["effect_review"] = {key: value for key, value in reviewed.items() if key != "approval"} record.update(dataclasses.asdict(result)) record["decided_by"] = "gateway" + if options.recover and record.get("outcome") == "response-recorded" and record.get("status") == 200: + read = request(PROJECT / "run" / "operator.sock", {"kind": "recover", "source": options.operation_id}) + record["recovery"] = json.loads(await gateway.recover(options.operation_id, + proof=unb64(read["proof"]), action=unb64(read["action"]), approval=unb64(read["approval"]))) observation = await gateway.observe_outcome(options.operation_id) outcome = observation.observation if isinstance(observation, GatewaySignedObservation) else None record["bundle"] = _record_entry( @@ -324,6 +332,7 @@ def submit(arguments: List[str]) -> Dict[str, Any]: parser.add_argument("--operation-id", required=True) parser.add_argument("--responses", help="folder name under requests/; defaults to the operation ID") parser.add_argument("--socket", type=Path, default=PROJECT / "run" / "app.sock") + parser.add_argument("--recover", action="store_true", help="separately authorize a native recovery read after response") options = parser.parse_args(arguments) checked_config(gateway=False) return asyncio.run(_submit(options)) diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/native_operator.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/native_operator.py.tmpl new file mode 100644 index 000000000..ce0a52088 --- /dev/null +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/native_operator.py.tmpl @@ -0,0 +1,455 @@ +"""Development operator tooling for the refund examples and generated scaffold. + +The native gateway authors and reviews every effect. This helper transports +SDK-authored read proofs and external signatures; it decides no gateway verdict. +Simulation is an explicitly finite scripted reviewer. Interactive runs require +consent to each complete native literal review before the exact signature. +Root, read-actor, manager and reviewer keys belong in an operator-private directory. +""" +from __future__ import annotations + +import argparse +import asyncio +import base64 +import binascii +from dataclasses import dataclass +import json +import os +import re +from pathlib import Path +import secrets +import socket +import struct +import subprocess +import sys +import time +from typing import Optional + +from auths.adapters.custody import PublicControlEvidence +from auths.authoring import (GrantEvidence, approval_requests, approve, collect_approvals, + open_approval_request, propose_mcp_approval, sign_approval_action) +from auths.self_hosted import (ExactMcpTool, StringField, IntegerField, OptionalField, + Permission, Profile, author_root_grant, load_signer_file) + +READ_TOOLS = ("auths_gateway_candidate_check_v1", "auths_gateway_recovery_read_v1") +MAX_FRAME = 8 * 1024 * 1024 +MAX_REVIEWS = 128 +MAX_PROOF_BYTES = 4 * 1024 * 1024 +MAX_ACTION_BYTES = 64 * 1024 +PEER_TIMEOUT = 5 +NATIVE_COMMAND_TIMEOUT = 60 +TOKEN = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}") +BASE64URL = re.compile(r"[A-Za-z0-9_-]+") + + +class OperatorRefusal(ValueError): + """A closed local refusal code, safe to return without peer data or paths.""" + + +def strict_object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise OperatorRefusal("operator.duplicate-field") + result[key] = value + return result + + +def reject_constant(_): + raise OperatorRefusal("operator.invalid-json") + + +def validate_request(value): + if not isinstance(value, dict): + raise OperatorRefusal("operator.invalid-request") + if value.get("kind") == "approve" and set(value) == {"kind", "proof", "action"}: + unb64(value["proof"], MAX_PROOF_BYTES) + unb64(value["action"], MAX_ACTION_BYTES) + return value + if value.get("kind") == "recover" and set(value) == {"kind", "source"}: + if not isinstance(value["source"], str) or TOKEN.fullmatch(value["source"]) is None: + raise OperatorRefusal("operator.invalid-source") + return value + raise OperatorRefusal("operator.invalid-request") + + +def b64(value): + return base64.urlsafe_b64encode(value).rstrip(b"=").decode() + + +def unb64(value, maximum=MAX_PROOF_BYTES): + if (not isinstance(value, str) or not 0 < len(value) <= (maximum * 4 + 2) // 3 + or BASE64URL.fullmatch(value) is None): + raise OperatorRefusal("operator.invalid-base64url") + try: + decoded = base64.b64decode(value + "=" * (-len(value) % 4), altchars=b"-_", validate=True) + except (binascii.Error, ValueError): + raise OperatorRefusal("operator.invalid-base64url") from None + if not 0 < len(decoded) <= maximum or b64(decoded) != value: + raise OperatorRefusal("operator.invalid-base64url") + return decoded + + +def write(path, value): + path = Path(path) + path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + with os.fdopen(os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "wb") as out: + out.write(value) + + +def run(binary, *arguments, check=True): + try: + result = subprocess.run([str(binary), *map(str, arguments)], capture_output=True, + timeout=NATIVE_COMMAND_TIMEOUT) + except subprocess.TimeoutExpired: + raise OperatorRefusal("operator.native-command-timeout") from None + except OSError: + raise OperatorRefusal("operator.native-command-unavailable") from None + if check and result.returncode: + raise OperatorRefusal("operator.native-command-refused") + return result + + +@dataclass(frozen=True) +class CandidateCheck: + operation_id: str + operator_namespace: str + recipe_digest: str + candidate_connection: str + expected_previous: Optional[str] + read_contract: str + maximum_response_bytes: int + + +@dataclass(frozen=True) +class RecoveryRead: + operation_id: str + operator_namespace: str + recipe_digest: str + source_effect: str + source_operation: str + read_contract: str + maximum_response_bytes: int + + +def read_contract(call): + if call["name"] not in READ_TOOLS: + raise OperatorRefusal("operator.unlisted-read-tool") + command_type = CandidateCheck if call["name"] == READ_TOOLS[0] else RecoveryRead + fields = {key: StringField(min_length=1, max_length=128) + for key in command_type.__annotations__} + fields["maximum_response_bytes"] = IntegerField(1, 1048576) + if command_type is CandidateCheck: + fields["expected_previous"] = OptionalField(StringField(min_length=64, max_length=64)) + contract = ExactMcpTool(service=call["service"], name=call["name"], + command_type=command_type, fields=fields) + return contract, contract.validate_arguments(call["arguments"]) + + +def signer_file(directory, name, seed): + path = directory / (name + ".json") + write(path, json.dumps({"schema": "auths.approval-signer/1", "custody": "development-ed25519", + "seed_file": str(Path(seed).resolve())}).encode()) + return path + + +async def provision(directory, facts, key_paths, gateway, simulation): + """Called by operator setup before install; grants only the two native read tools.""" + directory.mkdir(mode=0o700, parents=True) + signers = {name: signer_file(directory, name, seed) for name, seed in key_paths.items()} + root = load_signer_file(signers["root"]).signer + reader = load_signer_file(signers["reader"]).signer + now = int(time.time()) + try: + grant = await author_root_grant(signer=root, subject=reader.descriptor.principal, + profile=Profile("auths.mcp", 2), + permissions=[Permission("tools/call", facts["audience"] + "/tools/" + name) + for name in READ_TOOLS], audiences=[facts["audience"]], + not_before=facts["not_before"], expires_at=facts["expires_at"], + remaining_depth=0, assurance_floor="raw-key-baseline", requested_at=now) + finally: + await root.aclose() + await reader.aclose() + write(directory / "read-grant.json", json.dumps({"bytes": b64(grant.signed_grant), + "evidence": [{"type": item.evidence_type, "media_type": item.media_type, + "bytes": b64(item.bytes)} for item in grant.evidence]}).encode()) + seed = secrets.token_bytes(32) + write(directory / "reviewer.seed", seed) + from auths import _native + reviewer = _native.DevelopmentEd25519Key.from_seed(seed) + policy = run(gateway, "effect-policy", "--partition", "refund-development", + "--epoch", "1", "--approver-public-key", bytes(reviewer.public_key).hex()).stdout + write(directory / "effect-policy.json", policy) + write(directory / "configuration.json", json.dumps({"gateway": str(Path(gateway).resolve()), + "facts": facts, "signers": {name: str(path.resolve()) for name, path in signers.items()}, + "simulation": simulation, "maximum_reviews": MAX_REVIEWS}).encode()) + + +def consent(directory, name): + """Exact bounded response through a private operator FIFO, never application input.""" + fifo = directory / "consent" + os.mkfifo(fifo, 0o600) + descriptor = os.open(fifo, os.O_RDONLY | os.O_NONBLOCK | os.O_NOFOLLOW) + try: + print(f"Read the full text {directory / 'literal-review.txt'} and canonical signing request " + f"{directory / 'signing-request.json'} in your trusted operator shell, " + f"then write 'approve {name}' followed by a newline to {fifo}", file=sys.stderr, flush=True) + deadline, response = time.monotonic() + 600, b"" + while time.monotonic() < deadline and len(response) < 256: + try: + response += os.read(descriptor, 256 - len(response)) + except BlockingIOError: + pass + if b"\n" in response: + if response != ("approve " + name + "\n").encode(): + raise OperatorRefusal("operator.review-declined") + return + time.sleep(0.05) + raise OperatorRefusal("operator.review-expired") + finally: + os.close(descriptor) + fifo.unlink(missing_ok=True) + + +class Operator: + def __init__(self, directory, state): + self.directory, self.state = Path(directory), Path(state) + self.config = json.loads((self.directory / "configuration.json").read_text()) + self.facts = self.config["facts"] + self.binary = self.config["gateway"] + from auths import _native + self.reviewer = _native.DevelopmentEd25519Key.from_seed((self.directory / "reviewer.seed").read_bytes()) + self.sequence = len(list(self.directory.glob("review-*"))) + + async def read_packet(self, call): + contract, command = read_contract(call) + grant = json.loads((self.directory / "read-grant.json").read_text()) + names = self.facts.get("approvers", self.facts.get("managers")) + reader = load_signer_file(self.config["signers"]["reader"]).signer + managers = [load_signer_file(self.config["signers"][name]).signer for name in names] + try: + proposal = propose_mcp_approval(contract=contract, command=command, + required=self.facts["approvals_required"], + approvers=[self.facts["principals"][name] for name in names], + actor=reader.descriptor.principal, actor_grant=unb64(grant["bytes"]), + challenge=bytes.fromhex(self.facts["challenge_hex"]), + evaluation_time=int(time.time()), validity_seconds=1800) + responses = [] + for signer in managers[:self.facts["approvals_required"]]: + request = next(item for item in approval_requests(proposal) + if item.approver == signer.descriptor.principal) + responses.append((await approve(open_approval_request(request.text, + now=int(time.time())), signer)).text) + signed = await sign_approval_action(proposal, reader, grants=[GrantEvidence( + unb64(grant["bytes"]), tuple(PublicControlEvidence(item["type"], + item["media_type"], unb64(item["bytes"])) for item in grant["evidence"]))]) + return collect_approvals(proposal, responses).assemble(signed), proposal.action + finally: + await reader.aclose() + for signer in managers: + await signer.aclose() + + def exact_approval(self, proof, action, *mode): + self.sequence += 1 + if self.sequence > self.config["maximum_reviews"]: + raise OperatorRefusal("operator.review-budget-exhausted") + name = f"review-{self.sequence}" + directory = self.directory / name + directory.mkdir(mode=0o700) + write(directory / "proof", proof) + write(directory / "action", action) + now = int(time.time()) + result = run(self.binary, "effect-review", "--state-dir", self.state, + "--proof", directory / "proof", "--action", directory / "action", + "--not-before", now - 1, "--expires-at", now + 1800, + "--request-out", directory / "request", *mode, check=False) + if result.returncode: + return None + review = json.loads(result.stdout) + if (review.get("schema") != "auths.private-effect-signing/2" + or review.get("renderer") != "auths.literal-complete-review/1" + or not isinstance(review.get("literal_review"), str) or not review["literal_review"]): + raise OperatorRefusal("operator.complete-native-review-required") + write(directory / "literal-review.json", result.stdout) + write(directory / "literal-review.txt", review["literal_review"].encode("utf-8")) + write(directory / "signing-request.json", result.stdout) + if not self.config["simulation"]: + consent(directory, name) + signature = self.reviewer.sign(bytes.fromhex(review["signing_message_hex"])) + approval = run(self.binary, "effect-approval", "--request", directory / "request", + "--signature-hex", bytes(signature).hex()).stdout + write(directory / "approval", approval) + return directory + + def publish(self, loopback=None): + candidate = self.state / "candidate-installation.json" + call = self.directory / "candidate-call.json" + run(self.binary, "effect-candidate-call", "--state-dir", self.state, + "--candidate", candidate, "--operation", "install-check", "--call-out", call) + proof, action = asyncio.run(self.read_packet(json.loads(call.read_text()))) + approved = self.exact_approval(proof, action, "--candidate", candidate) + if approved is None: + raise OperatorRefusal("operator.candidate-review-refused") + arguments = ["--state-dir", self.state, "--candidate", candidate, + "--proof", approved / "proof", "--action", approved / "action", + "--approval", approved / "approval"] + run(self.binary, "candidate-acquire", *arguments, + *(["--loopback-provider", loopback] if loopback else [])) + run(self.binary, "candidate-publish", *arguments) + write(self.directory / "adversarial-substitution.approval", (approved / "approval").read_bytes()) + + def activate_configuration(self): + review = run(self.binary, "effect-configuration-review", "--state-dir", self.state).stdout + write(self.directory / "configuration-review.json", review) + exact = json.loads(review) + run(self.binary, "effect-configuration-activate", "--state-dir", self.state, + "--expected-revision", exact["previous_revision_hex"], "--expected-candidate", exact["candidate_hex"]) + + def request(self, request): + request = validate_request(request) + if request.get("kind") == "approve" and set(request) == {"kind", "proof", "action"}: + directory = self.exact_approval(unb64(request["proof"]), unb64(request["action"])) + if directory is not None: + return {"approval": b64((directory / "approval").read_bytes()), + "literal_review": json.loads((directory / "literal-review.json").read_text())["literal_review"]} + if self.config["simulation"]: + # Deliberately mismatched, genuine candidate approval for hostile + # proof tests. Never manufactures valid authority for their effect. + return {"approval": b64((self.directory / "adversarial-substitution.approval").read_bytes()), + "adversarial_substitution": True} + raise OperatorRefusal("operator.mutation-review-refused") + if request.get("kind") == "recover" and set(request) == {"kind", "source"}: + source = request["source"] + call = json.loads(run(self.binary, "effect-recovery-call", "--state-dir", self.state, + "--source-operation", source, "--recovery-operation", f"read-{self.sequence + 1}").stdout) + proof, action = asyncio.run(self.read_packet(call)) + directory = self.exact_approval(proof, action, "--recovery-of", source) + if directory is None: + raise OperatorRefusal("operator.recovery-review-refused") + return {"proof": b64(proof), "action": b64(action), + "approval": b64((directory / "approval").read_bytes())} + raise OperatorRefusal("operator.invalid-request") + + +def exact(connection, count, deadline): + value = b"" + while len(value) < count: + remaining = deadline - time.monotonic() + if remaining <= 0: + raise OperatorRefusal("operator.peer-timeout") + connection.settimeout(remaining) + chunk = connection.recv(count - len(value)) + if not chunk: + raise OperatorRefusal("operator.truncated-frame") + value += chunk + return value + + +def receive(connection, timeout=PEER_TIMEOUT): + deadline = time.monotonic() + timeout + length = struct.unpack(">I", exact(connection, 4, deadline))[0] + if not 0 < length <= MAX_FRAME: + raise OperatorRefusal("operator.frame-bound") + try: + value = json.loads(exact(connection, length, deadline).decode("utf-8"), + object_pairs_hook=strict_object, parse_constant=reject_constant) + except (UnicodeError, json.JSONDecodeError, RecursionError): + raise OperatorRefusal("operator.invalid-json") from None + if not isinstance(value, dict): + raise OperatorRefusal("operator.invalid-request") + return value + + +def send(connection, value): + encoded = json.dumps(value, separators=(",", ":")).encode() + if not 0 < len(encoded) <= MAX_FRAME: + raise OperatorRefusal("operator.frame-bound") + connection.sendall(struct.pack(">I", len(encoded)) + encoded) + + +def request(socket_path, value): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as connection: + connection.settimeout(620) + connection.connect(str(socket_path)) + send(connection, value) + result = receive(connection, timeout=620) + if "error" in result: + raise RuntimeError(result["error"]) + return result + + +def serve_peer(operator, connection): + """One bounded exchange; malformed or disconnected peers never kill the listener.""" + accepted = False + with connection: + connection.settimeout(PEER_TIMEOUT) + try: + request = validate_request(receive(connection)) + accepted = True + result = operator.request(request) + except OperatorRefusal as error: + result = {"error": str(error)} + except (socket.timeout, TimeoutError): + result = {"error": "operator.peer-timeout"} + except OSError: + result = {"error": "operator.peer-unavailable"} + except (ValueError, TypeError, KeyError, AttributeError, RecursionError): + # Native response/signing adapters can also refuse. No diagnostic + # text, submitted content or private filesystem path crosses back. + result = {"error": "operator.request-refused"} + try: + send(connection, result) + except (OSError, OperatorRefusal): + pass # A disconnected peer has no new authority or retry entitlement. + return accepted + + +def serve(operator, socket_path): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server: + old = os.umask(0o177) + try: + server.bind(str(socket_path)) + finally: + os.umask(old) + server.listen(8) + print("ready", flush=True) + accepted = 0 + while accepted < MAX_REVIEWS: + connection, _ = server.accept() + # Malformed peers do not spend the finite valid-request allowance. + accepted += int(serve_peer(operator, connection)) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--directory", type=Path, required=True) + commands = parser.add_subparsers(dest="command", required=True) + setup = commands.add_parser("setup") + setup.add_argument("--facts", type=Path, required=True) + setup.add_argument("--key-directory", type=Path, required=True) + setup.add_argument("--gateway", required=True) + setup.add_argument("--simulation", action="store_true") + publish = commands.add_parser("publish") + publish.add_argument("--state", type=Path, required=True) + publish.add_argument("--loopback-provider") + activate = commands.add_parser("activate-configuration") + activate.add_argument("--state", type=Path, required=True) + listener = commands.add_parser("serve") + listener.add_argument("--state", type=Path, required=True) + listener.add_argument("--socket", type=Path, required=True) + args = parser.parse_args() + if args.command == "setup": + facts = json.loads(args.facts.read_text()) + names = ["root", "reader", *facts.get("approvers", facts.get("managers"))] + asyncio.run(provision(args.directory, facts, + {name: args.key_directory / (name + ".seed") for name in names}, args.gateway, args.simulation)) + elif args.command == "publish": + Operator(args.directory, args.state).publish(args.loopback_provider) + elif args.command == "activate-configuration": + Operator(args.directory, args.state).activate_configuration() + else: + serve(Operator(args.directory, args.state), args.socket) + + +if __name__ == "__main__": + main() diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl index ecfaafd3c..adedcc745 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl @@ -127,7 +127,7 @@ def setup(arguments: List[str]) -> Dict[str, Any]: "connect_account=" + parameters["connect_account"], ) managers: List[str] = list(parameters["managers"]) - homes = {"root": OPERATOR, "agent": AGENT, **{name: MANAGERS / name for name in managers}} + homes = {"root": OPERATOR, "reader": OPERATOR / "reader", "agent": AGENT, **{name: MANAGERS / name for name in managers}} signer_files = {name: _new_key(home) for name, home in homes.items()} principals: Dict[str, str] = {} for name, path in signer_files.items(): @@ -145,7 +145,8 @@ def setup(arguments: List[str]) -> Dict[str, Any]: principals[name], ("raw-key-v1",), (PROFILE,), - (permission,), + (permission, *[Permission("tools/call", audience + "/tools/" + tool) for tool in + ("auths_gateway_candidate_check_v1", "auths_gateway_recovery_read_v1")]), (audience,), (audience,), not_before, @@ -253,6 +254,10 @@ def setup(arguments: List[str]) -> Dict[str, Any]: }, } write_file(OPERATOR / "setup.json", (json.dumps(facts, indent=2) + "\n").encode(), 0o644) + from native_operator import provision + asyncio.run(provision(OPERATOR / "effects", facts, + {name: homes[name] / "signing.seed" for name in ("root", "reader", *managers)}, + config["gateway"]["path"], simulation=config["provider"] == "double")) pins = {"trusted_context_sha256": trusted_context_sha256, "observer": None} write_file(AUDIT / "pins.json", (json.dumps(pins, indent=2) + "\n").encode(), 0o644) return {"setup": facts, "deployment": list(NON_CLAIMS)} @@ -322,6 +327,7 @@ def install_gateway(arguments: List[str]) -> Dict[str, Any]: command = [ config["gateway"]["path"], "install", + "--effect-policy", str(OPERATOR / "effects" / "effect-policy.json"), "--state-dir", str(STATE), "--recipe", @@ -357,7 +363,6 @@ def install_gateway(arguments: List[str]) -> Dict[str, Any]: started = port is None if port is None: port = _start_double(config, token_sha256) - command += ["--loopback-provider", str(port)] installed = subprocess.run(command, input=data, capture_output=True, cwd=PROJECT) if installed.returncode == 0: write_file(RUN / "double.token.sha256", f"{token_sha256}\n".encode(), replace=True) @@ -370,12 +375,20 @@ def install_gateway(arguments: List[str]) -> Dict[str, Any]: installed = subprocess.run(command, stdin=None, capture_output=True, cwd=PROJECT) if installed.returncode != 0: raise CommandFailed(stable_code(installed.stderr.decode(errors="replace"), "auths.install.failed")) + from native_operator import Operator + # Staged credentials cannot enter transport until their own read proof and + # exact approval pass; publication uses only those retained native checks. + if (STATE / "candidate-installation.json").exists(): + Operator(OPERATOR / "effects", STATE).publish(port if config["provider"] == "double" else None) # The gateway's line names the recipe digest; its custody wording does # not describe this development deployment, so it is not repeated. - words = installed.stdout.decode(errors="replace").split() - recipe_digest = words[words.index("recipe") + 1] if "recipe" in words[:-1] else None + recipe_digest = facts["recipe_digest"] observer = gateway_json(config, "observer-init", "--state-dir", str(STATE)) principal = observer["observer_anchor"]["principal"] + reviewed = gateway_json(config, "effect-configuration-review", "--state-dir", str(STATE)) + from native_operator import run as native_command + native_command(config["gateway"]["path"], "effect-configuration-activate", "--state-dir", str(STATE), + "--expected-revision", reviewed["previous_revision_hex"], "--expected-candidate", reviewed["candidate_hex"]) pins = read_json(AUDIT / "pins.json") pins["observer"] = principal write_file(AUDIT / "pins.json", (json.dumps(pins, indent=2) + "\n").encode(), 0o644, replace=True) @@ -445,6 +458,21 @@ def start(arguments: List[str]) -> Dict[str, Any]: time.sleep(0.05) write_file(RUN / "gateway.pid", f"{process.pid}\n".encode(), replace=True) running = process.pid + if pid_alive(RUN / "operator.pid") is None: + reviewer_socket = RUN / "operator.sock" + reviewer_socket.unlink(missing_ok=True) + with open(RUN / "operator.out", "wb") as out, open(RUN / "operator.log", "wb") as err: + reviewer = subprocess.Popen([config["python"], str(PROJECT / "lib" / "native_operator.py"), + "--directory", str(OPERATOR / "effects"), "serve", "--state", str(STATE), + "--socket", str(reviewer_socket)], stdin=subprocess.DEVNULL, stdout=out, stderr=err, + cwd=PROJECT, start_new_session=True) + deadline = time.monotonic() + 15 + while not reviewer_socket.exists(): + if reviewer.poll() is not None or time.monotonic() > deadline: + reviewer.kill() + raise CommandFailed("auths.operator.start-failed", log=str(RUN / "operator.log")) + time.sleep(0.05) + write_file(RUN / "operator.pid", f"{reviewer.pid}\n".encode(), replace=True) return { "started": True, "gateway_pid": running, @@ -460,13 +488,13 @@ def stop(arguments: List[str]) -> Dict[str, Any]: argparse.ArgumentParser(prog="bin/stop").parse_args(arguments) checked_config(gateway=False) stopped = {} - for name in ("witness", "gateway", "double"): + for name in ("witness", "operator", "gateway", "double"): pid = stop_pid(RUN / f"{name}.pid") if pid is not None: stopped[name] = pid # A stopped listener leaves its socket file behind; nothing the project # started still listens on one. - for name in ("relay.sock", "app.sock", "admin.sock"): + for name in ("relay.sock", "operator.sock", "app.sock", "admin.sock"): path = RUN / name if path.is_socket(): path.unlink() diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl index 5d622784d..d8c1d498f 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl @@ -76,7 +76,7 @@ PAYMENT_INTENT = "pi_mock_journey" REFUNDED_PAYMENT_INTENT = "pi_mock_refunded" # A connected account the grant does not list. OTHER_ACCOUNT = "acct_1AuthsOtherAcct" -SUBMIT_SCHEMA = "auths.gateway-submit/1" +SUBMIT_SCHEMA = "auths.gateway-submit/2" # Words only the gateway's submit result may carry. GATEWAY_OUTCOMES = { "denied", @@ -356,16 +356,17 @@ def check_modes() -> Dict[str, int]: wrong.append(f"{path} {oct(path.stat().st_mode & 0o777)}") directories += 1 for name in files: - if name == "signing.seed": + if name in ("signing.seed", "reviewer.seed"): seeds += 1 mode = (path / name).stat().st_mode & 0o777 if mode != 0o600: wrong.append(f"{path / name} {oct(mode)}") expect(not wrong, f"modes: {wrong}") - homes = {"operator", "agent"} | { + homes = {"operator", "operator/reader", "operator/effects", "agent"} | { str(Path("managers") / name) for name in read_json(PROJECT / "operator" / "setup.json")["managers"] } - held = {str(path.parent.relative_to(PROJECT)) for path in PROJECT.glob("**/signing.seed")} + held = {str(path.parent.relative_to(PROJECT)) for pattern in ("**/signing.seed", "**/reviewer.seed") + for path in PROJECT.glob(pattern)} expect(held == homes and seeds == len(homes), f"key homes {sorted(held)}, expected {sorted(homes)}") return {"directories_0700": directories, "key_files_0600": seeds} @@ -558,6 +559,7 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started folder.name, "--socket", str(WITNESS_SOCKET), + "--recover", ) expect(status == 0, f"{case}: bin/submit: {record} {submit_stderr}") return record @@ -603,6 +605,7 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started str(proof), "--action", str(action), + "--approval", str(PROJECT / "operator" / "effects" / "adversarial-substitution.approval"), ], stdin=subprocess.DEVNULL, capture_output=True, @@ -765,6 +768,7 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started str(proof_path), "--action", str(action_path), + "--approval", str(PROJECT / "operator" / "effects" / "adversarial-substitution.approval"), ], stdin=subprocess.DEVNULL, capture_output=True, @@ -816,10 +820,13 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started "refund-1", results["refund-1"], frames["refund-1"], - "observed-by-provider", + "response-recorded", status=200, action_b64=requests["refund-1"]["action_b64"], ) + expect(results["refund-1"]["recovery"]["report"]["source"]["provider_linked"] is True + and results["refund-1"]["recovery"]["report"]["source"]["stage"] == "observed-by-provider", + "refund-1 requires a separate native linked recovery report") expect(results["refund-1"].get("bundle") == "appended", f"refund-1: {results['refund-1']}") expect( results["refund-1"].get("approved") == sorted([manager_a, manager_b]) @@ -1083,9 +1090,11 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started } } - # A second install is refused before the gateway reads a provider: the - # value piped here is not a key. - status, second, stderr = commands.run("install-gateway", stdin=b"not-a-provider-key\n") + # A syntactically eligible synthetic value reaches the already-installed + # guard. No second provider read or publication may occur. + before_install = len(lines(RUN / "ledger.jsonl")) + status, second, stderr = commands.run("install-gateway", stdin=b"rk_test_mock_second_install\n") + expect(len(lines(RUN / "ledger.jsonl")) == before_install, "second install entered provider transport") expect( status != 0 and second.get("error") == "gateway.install.already-installed", f"second install: {status} {second} {stderr.strip()}", diff --git a/bindings/python/tests/test_enforcement_init.py b/bindings/python/tests/test_enforcement_init.py index c8a753ed5..be36b1cd6 100644 --- a/bindings/python/tests/test_enforcement_init.py +++ b/bindings/python/tests/test_enforcement_init.py @@ -50,6 +50,7 @@ "dev/stripe_double.py": 0o644, "dev/gateway_witness.py": 0o644, "lib/common.py": 0o644, + "lib/native_operator.py": 0o644, "lib/operate.py": 0o644, "lib/approve.py": 0o644, "lib/selftest.py": 0o644, @@ -107,6 +108,10 @@ def option(name): sys.exit(1) (state / "installation.json").write_text("{}") print("installed recipe " + __DIGEST__ + " with separate gateway credential custody") +elif command == "effect-configuration-review": + print(json.dumps({"previous_revision_hex": "00" * 32, "candidate_hex": "11" * 32})) +elif command == "effect-configuration-activate": + print(json.dumps({"activated": True})) elif command == "observer-init": print(json.dumps({"observer_anchor": {"principal": "key:sha256:stand-in"}})) elif command == "serve": @@ -205,6 +210,14 @@ def pretend_setup(directory: Path) -> None: for folder in ("operator", "operator/trust", "audit"): (directory / folder).mkdir(mode=0o700) (directory / "operator" / "setup.json").write_text(json.dumps({"recipe_digest": DIGEST})) + # This stand-in exercises process/credential plumbing only. It never + # represents an authorized candidate acquisition or a signed effect. + effects = directory / "operator" / "effects" + effects.mkdir(mode=0o700) + (effects / "reviewer.seed").write_bytes(bytes(32)) + (effects / "effect-policy.json").write_text("{}") + (effects / "configuration.json").write_text(json.dumps({"gateway": "stand-in", + "facts": {}, "simulation": True, "maximum_reviews": 128})) (directory / "operator" / "trust" / "gateway.context.cbor").write_bytes(b"\x00") (directory / "audit" / "pins.json").write_text(json.dumps({"trusted_context_sha256": "00" * 32, "observer": None})) @@ -461,7 +474,8 @@ def test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest( install = next(call for call in calls(short_root) if call[0] == "install") paths = {option: install[install.index(option) + 1] for option in ("--state-dir", "--recipe", "--profile-lock", "--trusted-context")} assert all(Path(value).is_absolute() and Path(value).is_relative_to(directory) for value in paths.values()) - assert "--loopback-provider" in install + assert "--loopback-provider" not in install + assert "--effect-policy" in install for path in directory.rglob("*"): if path.is_file() and not path.is_relative_to(directory / "enforcement"): assert b"rk_test_mock_abc" not in path.read_bytes(), path @@ -479,7 +493,7 @@ def test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest( assert serve[serve.index("--loopback-provider") + 1] == str(started["double_port"]) finally: status, stopped, _ = run(directory, "stop") - assert status == 0 and set(stopped["stopped"]) == {"gateway", "double"} + assert status == 0 and set(stopped["stopped"]) == {"gateway", "double", "operator"} time.sleep(0.2) for pid in stopped["stopped"].values(): with pytest.raises(OSError): @@ -574,3 +588,142 @@ def test_the_installed_command_routes_a_recipe_to_the_enforcement_scaffold(short "known": ["stripe-refund-approval"], "recipe": "no-such-recipe", } + + +def test_native_operator_template_matches_reviewed_example() -> None: + """One authored transport helper; neither copy implements gateway decisions.""" + assert (TEMPLATES / "lib/native_operator.py.tmpl").read_bytes() == (EXAMPLE / "native_operator.py").read_bytes() + + +@pytest.mark.parametrize("review", [ + {"schema": "auths.private-effect-signing/2", "signing_message_hex": "00"}, + {"schema": "auths.private-effect-signing/2", "renderer": "other", "literal_review": "shown", "signing_message_hex": "00"}, + {"schema": "auths.private-effect-signing/2", "renderer": "auths.literal-complete-review/1", "literal_review": "", "signing_message_hex": "00"}, +]) +def test_operator_never_signs_incomplete_native_review(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, review: Dict[str, Any]) -> None: + import runpy + helper = runpy.run_path(str(EXAMPLE / "native_operator.py")) + operator = helper["Operator"].__new__(helper["Operator"]) + operator.directory, operator.state = tmp_path, tmp_path / "gateway" + operator.binary, operator.sequence = "native-test-double", 0 + operator.config = {"maximum_reviews": 1, "simulation": True} + class NoSigner: + def sign(self, _: bytes) -> bytes: + pytest.fail("an incomplete native review reached the signer") + operator.reviewer = NoSigner() + monkeypatch.setitem(operator.exact_approval.__globals__, "run", lambda *args, **kwargs: + subprocess.CompletedProcess(args, 0, stdout=json.dumps(review).encode())) + with pytest.raises(ValueError, match="complete-native-review-required"): + operator.exact_approval(b"test-only-proof", b"test-only-action") + assert not (tmp_path / "review-1" / "approval").exists() + + +def test_live_operator_decline_prevents_exact_signature(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + import runpy + helper = runpy.run_path(str(EXAMPLE / "native_operator.py")) + operator = helper["Operator"].__new__(helper["Operator"]) + operator.directory, operator.state = tmp_path, tmp_path / "gateway" + operator.binary, operator.sequence = "native-test-double", 0 + operator.config = {"maximum_reviews": 1, "simulation": False} + class NoSigner: + def sign(self, _: bytes) -> bytes: + pytest.fail("declined live review reached the signer") + operator.reviewer = NoSigner() + review = {"schema": "auths.private-effect-signing/2", "renderer": "auths.literal-complete-review/1", + "literal_review": "full native test review", "signing_message_hex": "00"} + monkeypatch.setitem(operator.exact_approval.__globals__, "run", lambda *args, **kwargs: + subprocess.CompletedProcess(args, 0, stdout=json.dumps(review).encode())) + def decline(directory: Path, name: str) -> None: + assert json.loads((directory / "literal-review.json").read_text()) == review + assert (directory / "literal-review.txt").read_text() == review["literal_review"] + assert json.loads((directory / "signing-request.json").read_text()) == review + assert name == "review-1" + raise ValueError("operator.review-declined") + monkeypatch.setitem(operator.exact_approval.__globals__, "consent", decline) + with pytest.raises(ValueError, match="review-declined"): + operator.exact_approval(b"test-only-proof", b"test-only-action") + assert not (tmp_path / "review-1" / "approval").exists() + + +def test_operator_bad_peers_leave_listener_available(short_root: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """Real Unix frames exercise the transport only, with no effect-authority claim.""" + import runpy + import socket + import struct + import threading + helper = runpy.run_path(str(EXAMPLE / "native_operator.py")) + approved = {"kind": "approve", "proof": "AA", "action": "AA"} + invalid = [ + b"[]", b"null", b'"text"', + b'{"kind":"recover","kind":"recover","source":"source-1"}', + b'{"kind":"approve","proof":[],"action":"AA"}', + b'{"kind":"approve","proof":"AA","action":1}', + b'{"kind":"approve","proof":"AA=","action":"AA"}', + b'{"kind":"approve","proof":"AB","action":"AA"}', # noncanonical pad bits + b'{"kind":"recover","source":{}}', + b'{"kind":"recover","source":"--unsafe"}', + b'{"kind":"recover","source":"source-1","extra":true}', + b'{"kind":"recover","source":NaN}', + b'{"kind":"recover","source":"' + b'a' * 129 + b'"}', + json.dumps({"kind": "approve", "proof": "AA", "action": "A" * (88 * 1024)}).encode(), + b'{"kind":"approve","proof":"AA","action":"AA","nested":{"x":1,"x":2}}', + b'\xff', b'{', + ] + class TransportOnly: + def __init__(self): + self.calls = [] + def request(self, request): + self.calls.append(request) + return {"accepted_transport_only": True} + operator = TransportOnly() + # Malformed peers cannot exhaust the single valid-request allowance. + monkeypatch.setitem(helper["serve"].__globals__, "MAX_REVIEWS", 1) + path = short_root / "review.sock" + thread = threading.Thread(target=helper["serve"], args=(operator, path), daemon=True) + thread.start() + deadline = time.monotonic() + 5 + while not path.exists(): + assert time.monotonic() < deadline + time.sleep(0.01) + for body in [*invalid, None]: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as peer: + peer.settimeout(5) + peer.connect(str(path)) + peer.sendall(struct.pack(">I", helper["MAX_FRAME"] + 1) if body is None else + struct.pack(">I", len(body)) + body) + result = helper["receive"](peer) + assert set(result) == {"error"} + assert re.fullmatch(r"operator\.[a-z0-9-]+", result["error"]) + assert "unsafe" not in result["error"] and str(short_root) not in result["error"] + assert thread.is_alive() + assert helper["request"](path, approved) == {"accepted_transport_only": True} + thread.join(timeout=5) + assert not thread.is_alive() + assert operator.calls == [approved] + + +def test_operator_peer_and_native_deadlines_are_finite(monkeypatch: pytest.MonkeyPatch) -> None: + import runpy + import socket + import threading + helper = runpy.run_path(str(EXAMPLE / "native_operator.py")) + class NoOperation: + def request(self, _): + pytest.fail("truncated peer reached native operation") + client, server = socket.socketpair() + # receive's explicit deadline covers the whole frame, not each incoming byte. + receive = helper["receive"] + monkeypatch.setitem(helper["serve_peer"].__globals__, "receive", lambda peer: receive(peer, timeout=0.03)) + thread = threading.Thread(target=helper["serve_peer"], args=(NoOperation(), server)) + thread.start() + with client: + client.sendall(b"\x00") + assert receive(client) == {"error": "operator.peer-timeout"} + thread.join(timeout=2) + assert not thread.is_alive() + def timeout(*args, **kwargs): + assert kwargs["timeout"] == helper["NATIVE_COMMAND_TIMEOUT"] + raise subprocess.TimeoutExpired("private command must not be echoed", kwargs["timeout"]) + monkeypatch.setattr(subprocess, "run", timeout) + with pytest.raises(ValueError, match="^operator.native-command-timeout$"): + helper["run"]("private-native-command", "private-input") diff --git a/examples/stripe-refund-approval/README.md b/examples/stripe-refund-approval/README.md index 7b2da4dd8..40a40727e 100644 --- a/examples/stripe-refund-approval/README.md +++ b/examples/stripe-refund-approval/README.md @@ -8,8 +8,8 @@ day. The Stripe key lives only in the Auths gateway, which also checks the key and the payment with Stripe before each refund. An auditor checks every refund afterwards, offline. -**10 steps. The unattended run of all of them (step 10) took 8.1 s on an -Apple-silicon laptop once the wheel and gateway were built.** Building the +**10 steps. Step 10 runs the local double with a finite scripted operator reviewer; +its report records actual timing and does not establish an independent human trial.** Building the gateway the first time takes a few minutes. | Who | Holds | Can do | @@ -131,32 +131,47 @@ python mock_stripe.py --ledger "$WORK/ledger.jsonl" \ # it prints its port, for example 54321 ``` -**5. Install the gateway with the Stripe key on stdin, and start it.** +**5. Stage the credential, independently approve its reads, and start the gateway.** + +The separate development operator owns a read-only actor and an exact-effect +reviewer. For this local double, `--simulation` selects a finite scripted +reviewer; it is not evidence of human review. Omit that flag for interactive +operation: `literal-review.txt` preserves the complete native renderer text and +`signing-request.json` preserves its native request in the private operator +directory; the operator reads both and answers through its owner-only consent FIFO. +Neither mode gives these signing keys to the refund application. ```sh +python native_operator.py --directory "$WORK/operator" setup \ + --facts "$WORK/state/setup.json" --key-directory "$WORK/state/keys" \ + --gateway "$(command -v auths-gateway)" --simulation mkdir -m 700 "$WORK/gateway" printf '%s\n' "$STRIPE_KEY" | auths-gateway install --state-dir "$WORK/gateway" \ --recipe recipe.json --profile-lock profile.lock.json \ --trusted-context "$WORK/state/trust/gateway.context.cbor" \ + --effect-policy "$WORK/operator/effect-policy.json" \ --approve-digest \ - --provider stripe --alias refunds --account-label acct_1AuthsPlatform0 --credential-stdin \ - --loopback-provider 54321 + --provider stripe --alias refunds --account-label acct_1AuthsPlatform0 --credential-stdin unset STRIPE_KEY +python native_operator.py --directory "$WORK/operator" publish \ + --state "$WORK/gateway" --loopback-provider 54321 auths-gateway observer-init --state-dir "$WORK/gateway" +python native_operator.py --directory "$WORK/operator" activate-configuration --state "$WORK/gateway" auths-gateway serve --state-dir "$WORK/gateway" --app-socket "$WORK/app.sock" \ --loopback-provider 54321 & +python native_operator.py --directory "$WORK/operator" serve \ + --state "$WORK/gateway" --socket "$WORK/operator.sock" & ``` -If your state directory has to be long, `serve --admin-socket PATH` moves -the admin socket into another owner-only directory (mode 0700, owned by you, -not reached through a symbolic link); pass the same `--admin-socket` to -`disable`, `revoke`, `rotate`, and `doctor`. +`install` stages the credential and performs no provider read. A key without +`rk_test_` is refused before staging. `publish` obtains a separately authorized +native candidate-check proof, complete exact approval, and retained provider +checks before publishing. `observer-init` changes the reviewed configuration; +activation explicitly compares that exact revision. Keep the printed observer +principal and setup's `trusted_context_sha256` for the auditor. -`install` makes the guard's four reads before it stores the key, and stores -nothing if one fails: a key without `rk_test_` is refused -(`gateway.install.credential-guard`) before any read. `observer-init` prints -`observer_anchor.principal`: the key the gateway signs its outcomes with. -Give it and `trusted_context_sha256` to your auditor. +If state paths are long, `serve --admin-socket PATH` moves the admin socket to +another owner-only directory; pass the same option to operator commands. **6. The agent asks for a refund; managers A and B approve; manager C never answers; the gateway submits.** @@ -194,18 +209,19 @@ agent collects whatever responses exist, signs its exact refund, and submits: ```sh python refunds.py submit --state "$WORK/state" --socket "$WORK/app.sock" \ - --operation-id refund-1 --responses "$WORK/refund-1" + --operation-id refund-1 --responses "$WORK/refund-1" \ + --operator-socket "$WORK/operator.sock" --recover ``` -`submit` sends a refund to the gateway once two managers approved it, and -decides nothing itself: only the gateway enforces the approval threshold, -the ceiling, the per-window count and sum, and at most one run per operation -ID. It prints the gateway's result with `"decided_by": "gateway"`, here -`{"outcome": "observed-by-provider", "status": 200, "decided_by": "gateway", -"bundle": "appended", ...}`: the gateway checked the key and the -PaymentIntent (60.00 received, so at most 30.00 refundable here), sent the -refund, and found its echo token in the refund it read back. The ledger has -one write. The record lists the managers who approved (`"approved"`), those +`submit` asks the separate operator for the native exact-effect approval after +collecting the managers' signed requests, then forwards the unchanged proof, +action and approval. The gateway alone enforces the threshold, ceiling, window +budgets and replay rules. Its write result is `response-recorded` with status +200. The explicit `--recover` requests a second, independently approved native +read. The unchanged `recovery` report must show a provider-linked source at +`observed-by-provider`; an HTTP response alone does not establish that claim. +The audit observes the retained source after recovery. The ledger has one write. +The record lists the managers who approved (`"approved"`), those who have not answered (`"pending"`, here manager C), and any who declined (`"declined"`). One decline beside two approvals does not stop the refund. When too many managers declined for two approvals to remain @@ -363,7 +379,7 @@ that check. It checks every result, including exactly two Stripe writes Stripe call at all for the refusals before the lease, the `Idempotency-Key` each write carried, `Stripe-Version` on every request, `Stripe-Account` on every request about the refund and on none that tests the key, refund 1's -read-back, and the audit's `http_status` of 200 and 400. +separately authorized read-back, and the audit's `http_status` of 200 and 400. It prints timings. It then restores the gateway's store from a backup taken before the first refund, which keeps the shared connection record but no claim, and resubmits refund 1's approved proof. With the claim gone the @@ -389,7 +405,9 @@ The same journey runs from the npm package, `@auths-dev/sdk`, against the same recipe, gateway, and Stripe double. `typescript/refunds.ts` and `typescript/journey.ts` are the TypeScript `refunds.py` and `journey.py`, and `generated.ts` is the command contract the package's `auths generate` -wrote from the same `profile.toml`. You need Node 20.6+ and Rust. From +wrote from the same `profile.toml`. The application needs Node 20.6+ and Rust. Its separate operator helper also +uses the installed Python SDK from step 1; this is not TypeScript read-proof +authoring evidence. From `typescript/`: ```sh @@ -401,11 +419,10 @@ npm --prefix ../../../bindings/typescript run build npm pack ../../../bindings/typescript && mv auths-dev-sdk-*.tgz auths-dev-sdk.tgz npm install && npm run build cargo install --locked --path ../../../product/runtime/auths-gateway --features loopback-provider -node build/journey.js --gateway "$(command -v auths-gateway)" +node build/journey.js --gateway "$(command -v auths-gateway)" --python "$(command -v python)" ``` -The last command took 7.0 s on an Apple-silicon laptop once the package and -gateway were built. Each `python refunds.py …` step above is +The command runs the finite scripted reviewer only against the local double. Each `python refunds.py …` step above is `node build/refunds.js …` with the same flags (`--precheck` included) and prints the same JSON records, each manager runs `npx auths approve …` with the same flags, and `journey.js` takes the same test-mode options as diff --git a/examples/stripe-refund-approval/journey.py b/examples/stripe-refund-approval/journey.py index 725acb271..3becefa36 100644 --- a/examples/stripe-refund-approval/journey.py +++ b/examples/stripe-refund-approval/journey.py @@ -235,6 +235,8 @@ def submit(self, operation: str, folder: Path) -> Dict[str, Any]: operation, "--responses", str(folder), + "--operator-socket", str(self.work / "operator.sock"), + "--recover", ] return json.loads(self.run(*command).stdout) @@ -292,7 +294,7 @@ def expect(condition: bool, message: str) -> None: raise SystemExit(f"journey check failed: {message}") -SUBMIT_SCHEMA = "auths.gateway-submit/1" +SUBMIT_SCHEMA = "auths.gateway-submit/2" # Words only the gateway's submit result may carry. GATEWAY_OUTCOMES = { "denied", @@ -415,11 +417,18 @@ def resubmit(journey: Journey, operation: str) -> Dict[str, Any]: async def submit() -> Any: gateway = GatewayClient(GatewayEndpoint(journey.socket.resolve())) - return await gateway.submit( - proof=unb64(entry["proof_b64"]), action=unb64(entry["action_b64"]) - ) + from native_operator import request + reviewed = request(journey.work / "operator.sock", {"kind": "approve", + "proof": entry["proof_b64"], "action": entry["action_b64"]}) + result = dataclasses.asdict(await gateway.submit(proof=unb64(entry["proof_b64"]), + action=unb64(entry["action_b64"]), approval=unb64(reviewed["approval"]))) + if result.get("outcome") == "response-recorded" and result.get("status") == 200: + read = request(journey.work / "operator.sock", {"kind": "recover", "source": operation}) + result["recovery"] = json.loads(await gateway.recover(operation, + proof=unb64(read["proof"]), action=unb64(read["action"]), approval=unb64(read["approval"]))) + return result - return dataclasses.asdict(asyncio.run(submit())) + return asyncio.run(submit()) def tamper( @@ -463,7 +472,6 @@ def revoke_installed_connection(gateway: str, journey: "Journey", loopback: List def main() -> int: parser = argparse.ArgumentParser() parser.add_argument("--gateway", required=True, help="auths-gateway binary") - parser.add_argument("--effect-policy", type=Path, required=True, help="Operator-installed human approval policy") parser.add_argument("--summary", type=Path, help="write the timing and result summary here") parser.add_argument("--stripe-test-mode", action="store_true") parser.add_argument("--payment-intent", default="pi_mock_journey") @@ -548,6 +556,13 @@ def main() -> int: "4", ), ) + from native_operator import Operator, provision + operator_directory = journey.work / "operator" + asyncio.run(provision(operator_directory, facts, + {name: journey.state / "keys" / f"{name}.seed" for name in ("root", "reader", *MANAGERS)}, + args.gateway, simulation=not live)) + effect_policy = operator_directory / "effect-policy.json" + # The double checks the bearer token by digest; the key itself stays # only in the gateway's credential store. mock_token_sha256 = hashlib.sha256(secret.encode()).hexdigest() @@ -579,7 +594,7 @@ def install(state_dir: Path, key: str) -> subprocess.CompletedProcess[str]: args.gateway, "install", "--effect-policy", - str(args.effect_policy.resolve()), + str(effect_policy.resolve()), "--state-dir", str(state_dir), "--recipe", @@ -597,7 +612,6 @@ def install(state_dir: Path, key: str) -> subprocess.CompletedProcess[str]: "--account-label", args.platform_account, "--credential-stdin", - *loopback, *extra_install, stdin=key + "\n", check=False, @@ -627,6 +641,7 @@ def non_test_key() -> Dict[str, Any]: def install_key() -> None: installed = install(journey.gateway_state, secret) expect(installed.returncode == 0, f"install failed: {installed.stderr.strip()}") + Operator(operator_directory, journey.gateway_state).publish(loopback[-1] if loopback else None) onboarding_from = len(journey.provider_entries()) journey.step("gateway install with the key on stdin", install_key) @@ -644,6 +659,19 @@ def install_key() -> None: )["observer_anchor"]["principal"], ) + configuration = json.loads(journey.run(args.gateway, "effect-configuration-review", + "--state-dir", str(journey.gateway_state)).stdout) + journey.run(args.gateway, "effect-configuration-activate", "--state-dir", str(journey.gateway_state), + "--expected-revision", configuration["previous_revision_hex"], + "--expected-candidate", configuration["candidate_hex"]) + # The rollback test restores this actual active configuration, not an + # unpublished installation that can never grant entry. + shutil.rmtree(attempts_backup) + shutil.copytree(journey.gateway_state / "attempts", attempts_backup) + reviewer = journey.background(PYTHON, "native_operator.py", "--directory", str(operator_directory), + "serve", "--state", str(journey.gateway_state), "--socket", str(journey.work / "operator.sock")) + expect(reviewer.stdout.readline().strip() == "ready", "operator reviewer did not start") + serve = [ args.gateway, "serve", @@ -742,6 +770,7 @@ def reused_approvals() -> Dict[str, Any]: str(proof), "--action", str(action), + "--approval", str(operator_directory / "adversarial-substitution.approval"), ) # The CLI prints the gateway's submit result unchanged. return {"decided_by": "gateway", **json.loads(sent.stdout)} @@ -828,6 +857,7 @@ def self_approval() -> Dict[str, Any]: str(proof_path), "--action", str(action_path), + "--approval", str(operator_directory / "adversarial-substitution.approval"), ) return {"decided_by": "gateway", "sdk": sdk, **json.loads(sent.stdout)} @@ -1033,11 +1063,14 @@ def checked(operation: str, amount: int, control: Dict[str, Any], **extra: str) "refund-1", observed, frames["refund-1"], - "observed-by-provider", + "response-recorded", status=200, action_b64=requests["refund-1"]["action_b64"], ) - expect(observed["evidence"]["channel"] == "read-back", f"refund-1: {observed}") + expect(observed["recovery"]["report"]["source"]["provider_linked"] is True + and observed["recovery"]["report"]["source"]["stage"] == "observed-by-provider" + and observed["recovery"]["report"]["acquisition"]["response_status"] == 200, + f"refund-1 requires separately authorized linked recovery: {observed}") expect(observed["bundle"] == "appended", f"refund-1: {observed}") expect( observed["approved"] == ["manager-a", "manager-b"] @@ -1202,10 +1235,12 @@ def checked(operation: str, amount: int, control: Dict[str, Any], **extra: str) expect(len(writes) == 2, f"expected exactly 2 provider writes, saw {len(writes)}") expect(all(entry["well_formed"] for entry in writes), "provider saw a malformed refund") expect([entry["amount"] for entry in writes] == [1_500, 4_000], f"provider writes {writes}") - expect( - writes[0]["echo"] == observed["evidence"]["echo"], - f"refund-1 echo {writes[0]['echo']} != {observed['evidence']['echo']}", - ) + echo_record, echo_action = journey.work / "echo.json", journey.work / "echo.action" + echo_record.write_text(json.dumps({"echo": writes[0]["echo"]})) + echo_action.write_bytes(unb64(requests["refund-1"]["action_b64"])) + journey.run(args.gateway, "echo-verify", "--record", str(echo_record), "--pointer", "/echo", + "--operation-id", "refund-1", "--namespace", facts["operator_namespace"], + "--action", str(echo_action)) read_back = f"/v1/refunds/{writes[0]['refund']}" expect( any(entry["path"] == read_back and entry["status"] == 200 for entry in entries), @@ -1238,7 +1273,8 @@ def lose_attempts_and_resubmit() -> Dict[str, Any]: lose_attempts_and_resubmit, ) expect( - state_loss["outcome"] == "observed-by-provider" and state_loss["status"] == 200, + state_loss["outcome"] == "response-recorded" and state_loss["status"] == 200 + and state_loss["recovery"]["report"]["source"]["provider_linked"] is True, f"resubmitted refund-1: {state_loss}", ) writes = [entry for entry in journey.provider_entries() if entry["kind"] == "write"] @@ -1529,6 +1565,7 @@ def remove_and_flip(entry: Dict[str, Any]) -> None: writes = [entry for entry in journey.provider_entries() if entry["kind"] == "write"] summary = { "journey": "stripe-refund-approval", + "effect_reviewer": "interactive operator consent; development custody" if live else "finite scripted simulation; no human-trial claim", "provider": "stripe-test-mode" if live else "counting-mock", "credential_store": extra_install[extra_install.index("--credential-store") + 1] if "--credential-store" in extra_install diff --git a/examples/stripe-refund-approval/native_operator.py b/examples/stripe-refund-approval/native_operator.py new file mode 100644 index 000000000..ce0a52088 --- /dev/null +++ b/examples/stripe-refund-approval/native_operator.py @@ -0,0 +1,455 @@ +"""Development operator tooling for the refund examples and generated scaffold. + +The native gateway authors and reviews every effect. This helper transports +SDK-authored read proofs and external signatures; it decides no gateway verdict. +Simulation is an explicitly finite scripted reviewer. Interactive runs require +consent to each complete native literal review before the exact signature. +Root, read-actor, manager and reviewer keys belong in an operator-private directory. +""" +from __future__ import annotations + +import argparse +import asyncio +import base64 +import binascii +from dataclasses import dataclass +import json +import os +import re +from pathlib import Path +import secrets +import socket +import struct +import subprocess +import sys +import time +from typing import Optional + +from auths.adapters.custody import PublicControlEvidence +from auths.authoring import (GrantEvidence, approval_requests, approve, collect_approvals, + open_approval_request, propose_mcp_approval, sign_approval_action) +from auths.self_hosted import (ExactMcpTool, StringField, IntegerField, OptionalField, + Permission, Profile, author_root_grant, load_signer_file) + +READ_TOOLS = ("auths_gateway_candidate_check_v1", "auths_gateway_recovery_read_v1") +MAX_FRAME = 8 * 1024 * 1024 +MAX_REVIEWS = 128 +MAX_PROOF_BYTES = 4 * 1024 * 1024 +MAX_ACTION_BYTES = 64 * 1024 +PEER_TIMEOUT = 5 +NATIVE_COMMAND_TIMEOUT = 60 +TOKEN = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}") +BASE64URL = re.compile(r"[A-Za-z0-9_-]+") + + +class OperatorRefusal(ValueError): + """A closed local refusal code, safe to return without peer data or paths.""" + + +def strict_object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise OperatorRefusal("operator.duplicate-field") + result[key] = value + return result + + +def reject_constant(_): + raise OperatorRefusal("operator.invalid-json") + + +def validate_request(value): + if not isinstance(value, dict): + raise OperatorRefusal("operator.invalid-request") + if value.get("kind") == "approve" and set(value) == {"kind", "proof", "action"}: + unb64(value["proof"], MAX_PROOF_BYTES) + unb64(value["action"], MAX_ACTION_BYTES) + return value + if value.get("kind") == "recover" and set(value) == {"kind", "source"}: + if not isinstance(value["source"], str) or TOKEN.fullmatch(value["source"]) is None: + raise OperatorRefusal("operator.invalid-source") + return value + raise OperatorRefusal("operator.invalid-request") + + +def b64(value): + return base64.urlsafe_b64encode(value).rstrip(b"=").decode() + + +def unb64(value, maximum=MAX_PROOF_BYTES): + if (not isinstance(value, str) or not 0 < len(value) <= (maximum * 4 + 2) // 3 + or BASE64URL.fullmatch(value) is None): + raise OperatorRefusal("operator.invalid-base64url") + try: + decoded = base64.b64decode(value + "=" * (-len(value) % 4), altchars=b"-_", validate=True) + except (binascii.Error, ValueError): + raise OperatorRefusal("operator.invalid-base64url") from None + if not 0 < len(decoded) <= maximum or b64(decoded) != value: + raise OperatorRefusal("operator.invalid-base64url") + return decoded + + +def write(path, value): + path = Path(path) + path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + with os.fdopen(os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "wb") as out: + out.write(value) + + +def run(binary, *arguments, check=True): + try: + result = subprocess.run([str(binary), *map(str, arguments)], capture_output=True, + timeout=NATIVE_COMMAND_TIMEOUT) + except subprocess.TimeoutExpired: + raise OperatorRefusal("operator.native-command-timeout") from None + except OSError: + raise OperatorRefusal("operator.native-command-unavailable") from None + if check and result.returncode: + raise OperatorRefusal("operator.native-command-refused") + return result + + +@dataclass(frozen=True) +class CandidateCheck: + operation_id: str + operator_namespace: str + recipe_digest: str + candidate_connection: str + expected_previous: Optional[str] + read_contract: str + maximum_response_bytes: int + + +@dataclass(frozen=True) +class RecoveryRead: + operation_id: str + operator_namespace: str + recipe_digest: str + source_effect: str + source_operation: str + read_contract: str + maximum_response_bytes: int + + +def read_contract(call): + if call["name"] not in READ_TOOLS: + raise OperatorRefusal("operator.unlisted-read-tool") + command_type = CandidateCheck if call["name"] == READ_TOOLS[0] else RecoveryRead + fields = {key: StringField(min_length=1, max_length=128) + for key in command_type.__annotations__} + fields["maximum_response_bytes"] = IntegerField(1, 1048576) + if command_type is CandidateCheck: + fields["expected_previous"] = OptionalField(StringField(min_length=64, max_length=64)) + contract = ExactMcpTool(service=call["service"], name=call["name"], + command_type=command_type, fields=fields) + return contract, contract.validate_arguments(call["arguments"]) + + +def signer_file(directory, name, seed): + path = directory / (name + ".json") + write(path, json.dumps({"schema": "auths.approval-signer/1", "custody": "development-ed25519", + "seed_file": str(Path(seed).resolve())}).encode()) + return path + + +async def provision(directory, facts, key_paths, gateway, simulation): + """Called by operator setup before install; grants only the two native read tools.""" + directory.mkdir(mode=0o700, parents=True) + signers = {name: signer_file(directory, name, seed) for name, seed in key_paths.items()} + root = load_signer_file(signers["root"]).signer + reader = load_signer_file(signers["reader"]).signer + now = int(time.time()) + try: + grant = await author_root_grant(signer=root, subject=reader.descriptor.principal, + profile=Profile("auths.mcp", 2), + permissions=[Permission("tools/call", facts["audience"] + "/tools/" + name) + for name in READ_TOOLS], audiences=[facts["audience"]], + not_before=facts["not_before"], expires_at=facts["expires_at"], + remaining_depth=0, assurance_floor="raw-key-baseline", requested_at=now) + finally: + await root.aclose() + await reader.aclose() + write(directory / "read-grant.json", json.dumps({"bytes": b64(grant.signed_grant), + "evidence": [{"type": item.evidence_type, "media_type": item.media_type, + "bytes": b64(item.bytes)} for item in grant.evidence]}).encode()) + seed = secrets.token_bytes(32) + write(directory / "reviewer.seed", seed) + from auths import _native + reviewer = _native.DevelopmentEd25519Key.from_seed(seed) + policy = run(gateway, "effect-policy", "--partition", "refund-development", + "--epoch", "1", "--approver-public-key", bytes(reviewer.public_key).hex()).stdout + write(directory / "effect-policy.json", policy) + write(directory / "configuration.json", json.dumps({"gateway": str(Path(gateway).resolve()), + "facts": facts, "signers": {name: str(path.resolve()) for name, path in signers.items()}, + "simulation": simulation, "maximum_reviews": MAX_REVIEWS}).encode()) + + +def consent(directory, name): + """Exact bounded response through a private operator FIFO, never application input.""" + fifo = directory / "consent" + os.mkfifo(fifo, 0o600) + descriptor = os.open(fifo, os.O_RDONLY | os.O_NONBLOCK | os.O_NOFOLLOW) + try: + print(f"Read the full text {directory / 'literal-review.txt'} and canonical signing request " + f"{directory / 'signing-request.json'} in your trusted operator shell, " + f"then write 'approve {name}' followed by a newline to {fifo}", file=sys.stderr, flush=True) + deadline, response = time.monotonic() + 600, b"" + while time.monotonic() < deadline and len(response) < 256: + try: + response += os.read(descriptor, 256 - len(response)) + except BlockingIOError: + pass + if b"\n" in response: + if response != ("approve " + name + "\n").encode(): + raise OperatorRefusal("operator.review-declined") + return + time.sleep(0.05) + raise OperatorRefusal("operator.review-expired") + finally: + os.close(descriptor) + fifo.unlink(missing_ok=True) + + +class Operator: + def __init__(self, directory, state): + self.directory, self.state = Path(directory), Path(state) + self.config = json.loads((self.directory / "configuration.json").read_text()) + self.facts = self.config["facts"] + self.binary = self.config["gateway"] + from auths import _native + self.reviewer = _native.DevelopmentEd25519Key.from_seed((self.directory / "reviewer.seed").read_bytes()) + self.sequence = len(list(self.directory.glob("review-*"))) + + async def read_packet(self, call): + contract, command = read_contract(call) + grant = json.loads((self.directory / "read-grant.json").read_text()) + names = self.facts.get("approvers", self.facts.get("managers")) + reader = load_signer_file(self.config["signers"]["reader"]).signer + managers = [load_signer_file(self.config["signers"][name]).signer for name in names] + try: + proposal = propose_mcp_approval(contract=contract, command=command, + required=self.facts["approvals_required"], + approvers=[self.facts["principals"][name] for name in names], + actor=reader.descriptor.principal, actor_grant=unb64(grant["bytes"]), + challenge=bytes.fromhex(self.facts["challenge_hex"]), + evaluation_time=int(time.time()), validity_seconds=1800) + responses = [] + for signer in managers[:self.facts["approvals_required"]]: + request = next(item for item in approval_requests(proposal) + if item.approver == signer.descriptor.principal) + responses.append((await approve(open_approval_request(request.text, + now=int(time.time())), signer)).text) + signed = await sign_approval_action(proposal, reader, grants=[GrantEvidence( + unb64(grant["bytes"]), tuple(PublicControlEvidence(item["type"], + item["media_type"], unb64(item["bytes"])) for item in grant["evidence"]))]) + return collect_approvals(proposal, responses).assemble(signed), proposal.action + finally: + await reader.aclose() + for signer in managers: + await signer.aclose() + + def exact_approval(self, proof, action, *mode): + self.sequence += 1 + if self.sequence > self.config["maximum_reviews"]: + raise OperatorRefusal("operator.review-budget-exhausted") + name = f"review-{self.sequence}" + directory = self.directory / name + directory.mkdir(mode=0o700) + write(directory / "proof", proof) + write(directory / "action", action) + now = int(time.time()) + result = run(self.binary, "effect-review", "--state-dir", self.state, + "--proof", directory / "proof", "--action", directory / "action", + "--not-before", now - 1, "--expires-at", now + 1800, + "--request-out", directory / "request", *mode, check=False) + if result.returncode: + return None + review = json.loads(result.stdout) + if (review.get("schema") != "auths.private-effect-signing/2" + or review.get("renderer") != "auths.literal-complete-review/1" + or not isinstance(review.get("literal_review"), str) or not review["literal_review"]): + raise OperatorRefusal("operator.complete-native-review-required") + write(directory / "literal-review.json", result.stdout) + write(directory / "literal-review.txt", review["literal_review"].encode("utf-8")) + write(directory / "signing-request.json", result.stdout) + if not self.config["simulation"]: + consent(directory, name) + signature = self.reviewer.sign(bytes.fromhex(review["signing_message_hex"])) + approval = run(self.binary, "effect-approval", "--request", directory / "request", + "--signature-hex", bytes(signature).hex()).stdout + write(directory / "approval", approval) + return directory + + def publish(self, loopback=None): + candidate = self.state / "candidate-installation.json" + call = self.directory / "candidate-call.json" + run(self.binary, "effect-candidate-call", "--state-dir", self.state, + "--candidate", candidate, "--operation", "install-check", "--call-out", call) + proof, action = asyncio.run(self.read_packet(json.loads(call.read_text()))) + approved = self.exact_approval(proof, action, "--candidate", candidate) + if approved is None: + raise OperatorRefusal("operator.candidate-review-refused") + arguments = ["--state-dir", self.state, "--candidate", candidate, + "--proof", approved / "proof", "--action", approved / "action", + "--approval", approved / "approval"] + run(self.binary, "candidate-acquire", *arguments, + *(["--loopback-provider", loopback] if loopback else [])) + run(self.binary, "candidate-publish", *arguments) + write(self.directory / "adversarial-substitution.approval", (approved / "approval").read_bytes()) + + def activate_configuration(self): + review = run(self.binary, "effect-configuration-review", "--state-dir", self.state).stdout + write(self.directory / "configuration-review.json", review) + exact = json.loads(review) + run(self.binary, "effect-configuration-activate", "--state-dir", self.state, + "--expected-revision", exact["previous_revision_hex"], "--expected-candidate", exact["candidate_hex"]) + + def request(self, request): + request = validate_request(request) + if request.get("kind") == "approve" and set(request) == {"kind", "proof", "action"}: + directory = self.exact_approval(unb64(request["proof"]), unb64(request["action"])) + if directory is not None: + return {"approval": b64((directory / "approval").read_bytes()), + "literal_review": json.loads((directory / "literal-review.json").read_text())["literal_review"]} + if self.config["simulation"]: + # Deliberately mismatched, genuine candidate approval for hostile + # proof tests. Never manufactures valid authority for their effect. + return {"approval": b64((self.directory / "adversarial-substitution.approval").read_bytes()), + "adversarial_substitution": True} + raise OperatorRefusal("operator.mutation-review-refused") + if request.get("kind") == "recover" and set(request) == {"kind", "source"}: + source = request["source"] + call = json.loads(run(self.binary, "effect-recovery-call", "--state-dir", self.state, + "--source-operation", source, "--recovery-operation", f"read-{self.sequence + 1}").stdout) + proof, action = asyncio.run(self.read_packet(call)) + directory = self.exact_approval(proof, action, "--recovery-of", source) + if directory is None: + raise OperatorRefusal("operator.recovery-review-refused") + return {"proof": b64(proof), "action": b64(action), + "approval": b64((directory / "approval").read_bytes())} + raise OperatorRefusal("operator.invalid-request") + + +def exact(connection, count, deadline): + value = b"" + while len(value) < count: + remaining = deadline - time.monotonic() + if remaining <= 0: + raise OperatorRefusal("operator.peer-timeout") + connection.settimeout(remaining) + chunk = connection.recv(count - len(value)) + if not chunk: + raise OperatorRefusal("operator.truncated-frame") + value += chunk + return value + + +def receive(connection, timeout=PEER_TIMEOUT): + deadline = time.monotonic() + timeout + length = struct.unpack(">I", exact(connection, 4, deadline))[0] + if not 0 < length <= MAX_FRAME: + raise OperatorRefusal("operator.frame-bound") + try: + value = json.loads(exact(connection, length, deadline).decode("utf-8"), + object_pairs_hook=strict_object, parse_constant=reject_constant) + except (UnicodeError, json.JSONDecodeError, RecursionError): + raise OperatorRefusal("operator.invalid-json") from None + if not isinstance(value, dict): + raise OperatorRefusal("operator.invalid-request") + return value + + +def send(connection, value): + encoded = json.dumps(value, separators=(",", ":")).encode() + if not 0 < len(encoded) <= MAX_FRAME: + raise OperatorRefusal("operator.frame-bound") + connection.sendall(struct.pack(">I", len(encoded)) + encoded) + + +def request(socket_path, value): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as connection: + connection.settimeout(620) + connection.connect(str(socket_path)) + send(connection, value) + result = receive(connection, timeout=620) + if "error" in result: + raise RuntimeError(result["error"]) + return result + + +def serve_peer(operator, connection): + """One bounded exchange; malformed or disconnected peers never kill the listener.""" + accepted = False + with connection: + connection.settimeout(PEER_TIMEOUT) + try: + request = validate_request(receive(connection)) + accepted = True + result = operator.request(request) + except OperatorRefusal as error: + result = {"error": str(error)} + except (socket.timeout, TimeoutError): + result = {"error": "operator.peer-timeout"} + except OSError: + result = {"error": "operator.peer-unavailable"} + except (ValueError, TypeError, KeyError, AttributeError, RecursionError): + # Native response/signing adapters can also refuse. No diagnostic + # text, submitted content or private filesystem path crosses back. + result = {"error": "operator.request-refused"} + try: + send(connection, result) + except (OSError, OperatorRefusal): + pass # A disconnected peer has no new authority or retry entitlement. + return accepted + + +def serve(operator, socket_path): + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server: + old = os.umask(0o177) + try: + server.bind(str(socket_path)) + finally: + os.umask(old) + server.listen(8) + print("ready", flush=True) + accepted = 0 + while accepted < MAX_REVIEWS: + connection, _ = server.accept() + # Malformed peers do not spend the finite valid-request allowance. + accepted += int(serve_peer(operator, connection)) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--directory", type=Path, required=True) + commands = parser.add_subparsers(dest="command", required=True) + setup = commands.add_parser("setup") + setup.add_argument("--facts", type=Path, required=True) + setup.add_argument("--key-directory", type=Path, required=True) + setup.add_argument("--gateway", required=True) + setup.add_argument("--simulation", action="store_true") + publish = commands.add_parser("publish") + publish.add_argument("--state", type=Path, required=True) + publish.add_argument("--loopback-provider") + activate = commands.add_parser("activate-configuration") + activate.add_argument("--state", type=Path, required=True) + listener = commands.add_parser("serve") + listener.add_argument("--state", type=Path, required=True) + listener.add_argument("--socket", type=Path, required=True) + args = parser.parse_args() + if args.command == "setup": + facts = json.loads(args.facts.read_text()) + names = ["root", "reader", *facts.get("approvers", facts.get("managers"))] + asyncio.run(provision(args.directory, facts, + {name: args.key_directory / (name + ".seed") for name in names}, args.gateway, args.simulation)) + elif args.command == "publish": + Operator(args.directory, args.state).publish(args.loopback_provider) + elif args.command == "activate-configuration": + Operator(args.directory, args.state).activate_configuration() + else: + serve(Operator(args.directory, args.state), args.socket) + + +if __name__ == "__main__": + main() diff --git a/examples/stripe-refund-approval/refunds.py b/examples/stripe-refund-approval/refunds.py index 767e372a4..6765adacc 100644 --- a/examples/stripe-refund-approval/refunds.py +++ b/examples/stripe-refund-approval/refunds.py @@ -83,7 +83,7 @@ # The gateway's trusted context requires approvals from this many of the # three managers, any of them. APPROVALS_REQUIRED = 2 -ROLES = ("root", "agent") + MANAGERS +ROLES = ("root", "agent", "reader") + MANAGERS ASSURANCE = "raw-key-baseline" DAY = 86_400 # The test connected account the grant's scope lists; the gateway sends it as @@ -304,7 +304,8 @@ def anchor(name: str, depth: int) -> Any: _native.Principal(principals[name]), ["raw-key-v1"], [("auths.mcp", 2)], - [permission], + [permission, *[("tools/call", f"{audience}/tools/{name}") for name in + ("auths_gateway_candidate_check_v1", "auths_gateway_recovery_read_v1")]], [audience], [audience], not_before, @@ -610,11 +611,25 @@ async def _submit(args: argparse.Namespace) -> Dict[str, Any]: ) proof = collection.assemble(action) gateway = GatewayClient(GatewayEndpoint(args.socket.resolve())) - with args.effect_approval.open("rb") as approval_file: - approval = approval_file.read(4097) + if args.operator_socket: + from native_operator import request, unb64 + reviewed = request(args.operator_socket, {"kind": "approve", "proof": _b64(proof), + "action": _b64(proposal.action)}) + approval = unb64(reviewed["approval"]) + record["effect_review"] = {key: value for key, value in reviewed.items() if key != "approval"} + else: + with args.effect_approval.open("rb") as approval_file: + approval = approval_file.read(4097) result = await gateway.submit(proof=proof, action=proposal.action, approval=approval) record.update(dataclasses.asdict(result)) record["decided_by"] = "gateway" + if args.recover and record.get("outcome") == "response-recorded" and record.get("status") == 200: + if not args.operator_socket: + raise ValueError("--recover requires a separately authorizing --operator-socket") + from native_operator import request, unb64 + read = request(args.operator_socket, {"kind": "recover", "source": args.operation_id}) + record["recovery"] = json.loads(await gateway.recover(args.operation_id, + proof=unb64(read["proof"]), action=unb64(read["action"]), approval=unb64(read["approval"]))) observation = await gateway.observe_outcome(args.operation_id) outcome = observation.observation if isinstance(observation, GatewaySignedObservation) else None entry = { @@ -695,7 +710,10 @@ def main(argv: Optional[List[str]] = None) -> int: submit = commands.add_parser("submit", help="collect the responses and submit through the gateway") submit.add_argument("--state", type=Path, required=True) submit.add_argument("--socket", type=Path, required=True) - submit.add_argument("--effect-approval", type=Path, required=True, help="native exact-effect approval") + approval = submit.add_mutually_exclusive_group(required=True) + approval.add_argument("--effect-approval", type=Path, help="native exact-effect approval") + approval.add_argument("--operator-socket", type=Path, help="separate development operator reviewer") + submit.add_argument("--recover", action="store_true", help="request a separate authorized recovery read after a successful response") submit.add_argument("--operation-id", required=True) submit.add_argument("--responses", type=Path, required=True, help="directory of *.response files") bundle = commands.add_parser("export", help="write the audit bundle") diff --git a/examples/stripe-refund-approval/typescript/journey.ts b/examples/stripe-refund-approval/typescript/journey.ts index 35fc4117a..a5685b7cd 100644 --- a/examples/stripe-refund-approval/typescript/journey.ts +++ b/examples/stripe-refund-approval/typescript/journey.ts @@ -61,7 +61,7 @@ import { setTimeout as sleep } from "node:timers/promises"; import { authorMcpProof, compileTrustedContext, proposeMcpApproval } from "@auths-dev/sdk/self-hosted"; import { CONTRACT, type CreateRefund } from "./generated.js"; -import { ASSURANCE, EXAMPLE, anchor, developmentSigner, roleKey, type SetupFacts } from "./refunds.js"; +import { ASSURANCE, EXAMPLE, anchor, developmentSigner, roleKey, requestOperator, type SetupFacts } from "./refunds.js"; const REFUNDS = fileURLToPath(new URL("./refunds.js", import.meta.url)); // The double's accounts and its already-refunded PaymentIntent. @@ -203,7 +203,7 @@ class Journey { submit(operation: string, folder: string): Json { return JSON.parse(this.run(process.execPath, [ REFUNDS, "submit", "--state", this.state, "--socket", this.witnessSocket, "--operation-id", operation, - "--responses", folder, + "--responses", folder, "--operator-socket", join(this.work, "operator.sock"), "--recover", ]).stdout) as Json; } @@ -255,7 +255,7 @@ function expect(condition: boolean, message: string): asserts condition { if (!condition) throw new Error(`journey check failed: ${message}`); } -const SUBMIT_SCHEMA = "auths.gateway-submit/1"; +const SUBMIT_SCHEMA = "auths.gateway-submit/2"; // Words only the gateway's submit result may carry. const GATEWAY_OUTCOMES = new Set([ "denied", "not-entered", "indeterminate", "unknown", "response-recorded", "observed", "observed-by-provider", @@ -384,7 +384,6 @@ async function main(): Promise { const { values } = parseArgs({ options: { gateway: { type: "string" }, - "effect-policy": { type: "string" }, summary: { type: "string" }, python: { type: "string", default: "python3" }, "stripe-test-mode": { type: "boolean", default: false }, @@ -395,8 +394,6 @@ async function main(): Promise { }, }); if (values.gateway === undefined) throw new Error("--gateway PATH/TO/auths-gateway is required"); - const effectPolicy = values["effect-policy"]; - if (effectPolicy === undefined) throw new Error("--effect-policy PATH is required"); const live = values["stripe-test-mode"]!; const paymentIntent = values["payment-intent"]!; const rejectedPaymentIntent = values["rejected-payment-intent"]!; @@ -441,6 +438,12 @@ async function main(): Promise { REFUNDS, "grant", "--state", journey.state, "--gateway", journey.gateway, "--agent", CHECKS_AGENT, "--max-count", "4", ])); + const operatorDirectory = join(work, "operator"); + const operatorScript = join(EXAMPLE, "native_operator.py"); + journey.run(journey.python, [operatorScript, "--directory", operatorDirectory, "setup", + "--facts", join(journey.state, "setup.json"), "--key-directory", join(journey.state, "keys"), + "--gateway", journey.gateway, ...(live ? [] : ["--simulation"])]); + const effectPolicy = join(operatorDirectory, "effect-policy.json"); // The double checks the bearer token by digest; the key itself stays // only in the gateway's credential store. const mockTokenSha256 = createHash("sha256").update(secret).digest("hex"); @@ -469,7 +472,7 @@ async function main(): Promise { "--profile-lock", "profile.lock.json", "--trusted-context", join(journey.state, "trust", "gateway.context.cbor"), "--approve-digest", facts.recipe_digest, "--provider", "stripe", "--alias", "refunds", - "--account-label", platformAccount, "--credential-stdin", ...loopback, + "--account-label", platformAccount, "--credential-stdin", ], `${key}\n`, false); }; @@ -494,6 +497,8 @@ async function main(): Promise { await journey.step("gateway install with the key on stdin", () => { const installed = install(journey.gatewayState, secret); expect(installed.status === 0, `install failed: ${installed.stderr.trim()}`); + journey.run(journey.python, [operatorScript, "--directory", operatorDirectory, "publish", + "--state", journey.gatewayState, ...loopback]); }); const onboarding = journey.providerEntries().slice(onboardingFrom); // The store as a backup taken now would hold it: the shared connection @@ -503,6 +508,20 @@ async function main(): Promise { const observer = await journey.step("gateway observer key", () => ((JSON.parse(journey.run(journey.gateway, ["observer-init", "--state-dir", journey.gatewayState]).stdout) as { observer_anchor: { principal: string } }).observer_anchor.principal)); + const configuration = JSON.parse(journey.run(journey.gateway, + ["effect-configuration-review", "--state-dir", journey.gatewayState]).stdout) as + { previous_revision_hex: string; candidate_hex: string }; + journey.run(journey.gateway, ["effect-configuration-activate", "--state-dir", journey.gatewayState, + "--expected-revision", configuration.previous_revision_hex, "--expected-candidate", configuration.candidate_hex]); + rmSync(attemptsBackup, { recursive: true }); + copyTree(join(journey.gatewayState, "attempts"), attemptsBackup); + const reviewer = journey.background(journey.python, [operatorScript, "--directory", operatorDirectory, + "serve", "--state", journey.gatewayState, "--socket", join(work, "operator.sock")], "pipe"); + const reviewerReady = await Promise.race([ + new Promise((done) => createInterface({ input: reviewer.stdout! }).once("line", done)), + sleep(10_000, "", { ref: false }), + ]); + expect(reviewerReady === "ready", "operator reviewer did not start"); let running: ChildProcess | undefined; const startGateway = async (): Promise => { // A stopped gateway leaves its socket file behind; wait for a new one. @@ -572,6 +591,7 @@ async function main(): Promise { // The witness is its own process, so this blocking call cannot stall it. const sent = journey.run(journey.gateway, [ "submit", "--app-socket", journey.witnessSocket, "--proof", proof, "--action", action, + "--approval", join(operatorDirectory, "adversarial-substitution.approval"), ]); // The CLI prints the gateway's submit result unchanged. return { decided_by: "gateway", ...(JSON.parse(sent.stdout) as Json) }; @@ -650,6 +670,7 @@ async function main(): Promise { writeFileSync(actionPath, authored.action); const sent = journey.run(journey.gateway, [ "submit", "--app-socket", journey.witnessSocket, "--proof", proofPath, "--action", actionPath, + "--approval", join(operatorDirectory, "adversarial-substitution.approval"), ]); return { decided_by: "gateway", sdk, ...(JSON.parse(sent.stdout) as Json) }; }; @@ -784,11 +805,12 @@ async function main(): Promise { } const same = (left: unknown, right: unknown): boolean => JSON.stringify(left) === JSON.stringify(right); - const observed = results["refund-1"]! as Json & { evidence?: { channel: string; echo: string } }; + const observed = results["refund-1"]! as Json & { recovery: { report: { source: { provider_linked: boolean; stage: string }; acquisition: { response_status: number } } } }; expectGatewayDecided("refund-1", observed, frames["refund-1"]!, { - outcome: "observed-by-provider", status: 200, actionB64: requests["refund-1"]!.action_b64 as string, + outcome: "response-recorded", status: 200, actionB64: requests["refund-1"]!.action_b64 as string, }); - expect(observed.evidence?.channel === "read-back" && observed.bundle === "appended", + expect(observed.recovery.report.source.provider_linked && observed.recovery.report.source.stage === "observed-by-provider" && + observed.recovery.report.acquisition.response_status === 200 && observed.bundle === "appended", `refund-1: ${JSON.stringify(observed)}`); expect(same(observed.approved, ["manager-a", "manager-b"]) && same(observed.pending, ["manager-c"]) && !("declined" in observed) && @@ -891,8 +913,11 @@ async function main(): Promise { expect(writes.length === 2, `expected exactly 2 provider writes, saw ${writes.length}`); expect(writes.every((entry) => entry.well_formed === true), "provider saw a malformed refund"); expect(same(writes.map((entry) => entry.amount), [1_500, 4_000]), `provider writes ${JSON.stringify(writes)}`); - expect(writes[0]!.echo === observed.evidence?.echo, - `refund-1 echo ${String(writes[0]!.echo)} != ${String(observed.evidence?.echo)}`); + const echoRecord = join(work, "echo.json"), echoAction = join(work, "echo.action"); + writeFileSync(echoRecord, JSON.stringify({ echo: writes[0]!.echo }), { mode: 0o600 }); + writeFileSync(echoAction, Buffer.from(requests["refund-1"]!.action_b64 as string, "base64url"), { mode: 0o600 }); + journey.run(journey.gateway, ["echo-verify", "--record", echoRecord, "--pointer", "/echo", + "--operation-id", "refund-1", "--namespace", facts.operator_namespace, "--action", echoAction]); const readBack = `/v1/refunds/${String(writes[0]!.refund)}`; expect(entries.some((entry) => entry.path === readBack && entry.status === 200), `refund-1 was not read back at ${readBack}`); @@ -922,11 +947,25 @@ async function main(): Promise { const action = join(journey.work, "resubmit.action"); writeFileSync(proof, new Uint8Array(Buffer.from(first.proof_b64 as string, "base64url"))); writeFileSync(action, new Uint8Array(Buffer.from(first.action_b64 as string, "base64url"))); - return JSON.parse(journey.run(journey.gateway, [ + const reviewed = await requestOperator(join(work, "operator.sock"), + { kind: "approve", proof: first.proof_b64, action: first.action_b64 }); + const approval = join(work, "resubmit.approval"); + writeFileSync(approval, Buffer.from(String(reviewed.approval), "base64url"), { mode: 0o600 }); + const result = JSON.parse(journey.run(journey.gateway, [ "submit", "--app-socket", journey.socket, "--proof", proof, "--action", action, + "--approval", approval, ]).stdout) as Json; + const read = await requestOperator(join(work, "operator.sock"), { kind: "recover", source: "refund-1" }); + for (const field of ["proof", "action", "approval"] as const) { + writeFileSync(join(work, `read.${field}`), Buffer.from(String(read[field]), "base64url"), { mode: 0o600 }); + } + result.recovery = JSON.parse(journey.run(journey.gateway, ["app-recover", "--app-socket", journey.socket, + "--source-operation", "refund-1", "--proof", join(work, "read.proof"), + "--action", join(work, "read.action"), "--approval", join(work, "read.approval")]).stdout) as unknown; + return result; }); - expect(stateLoss.outcome === "observed-by-provider" && stateLoss.status === 200, + expect(stateLoss.outcome === "response-recorded" && stateLoss.status === 200 && + (stateLoss.recovery as { report: { source: { provider_linked: boolean } } }).report.source.provider_linked, `resubmitted refund-1: ${JSON.stringify(stateLoss)}`); writes = journey.providerEntries().filter((entry) => entry.kind === "write"); expect(writes.length === 3, `expected 3 provider writes, saw ${writes.length}`); @@ -1122,6 +1161,8 @@ async function main(): Promise { const summary = { journey: "stripe-refund-approval", sdk: "@auths-dev/sdk (packed npm)", + operator_tooling: "separate Python SDK; native gateway authors and verifies read semantics", + effect_reviewer: live ? "interactive operator consent; development custody" : "finite scripted simulation; no human-trial claim", provider: live ? "stripe-test-mode" : "counting-mock", wall_seconds: Math.round(performance.now() - journey.started) / 1000, steps: journey.steps, diff --git a/examples/stripe-refund-approval/typescript/refunds.ts b/examples/stripe-refund-approval/typescript/refunds.ts index f63e70773..7327b0ed9 100644 --- a/examples/stripe-refund-approval/typescript/refunds.ts +++ b/examples/stripe-refund-approval/typescript/refunds.ts @@ -42,6 +42,7 @@ import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, writeFileSync, } from "node:fs"; import { dirname, join, resolve } from "node:path"; +import { createConnection } from "node:net"; import { fileURLToPath } from "node:url"; import { parseArgs } from "node:util"; @@ -67,7 +68,7 @@ export const MANAGERS = ["manager-a", "manager-b", "manager-c"] as const; // The gateway's trusted context requires approvals from this many of the // three managers, any of them. const APPROVALS_REQUIRED = 2; -const ROLES = ["root", "agent", ...MANAGERS] as const; +const ROLES = ["root", "agent", "reader", ...MANAGERS] as const; const DAY = 86_400n; // The test connected account the grant's scope lists; the gateway sends it as // `Stripe-Account` on the refund and on every read of the refund's records. @@ -339,7 +340,10 @@ async function setup(options: Readonly<{ const challenge = new Uint8Array(randomBytes(32)); // The root is the only trust anchor and may delegate once, to the agent. // The managers are approver anchors: they approve and hold no authority. - const anchors = [anchor("root", principals.root!, audience, tool, 1, notBefore, expiresAt)]; + const rootAnchor = anchor("root", principals.root!, audience, tool, 1, notBefore, expiresAt); + const anchors = [{ ...rootAnchor, permissions: [...rootAnchor.permissions, + ...["auths_gateway_candidate_check_v1", "auths_gateway_recovery_read_v1"].map((name) => + ({ capability: "tools/call", resource: `${audience}/tools/${name}` }))] }]; const approvers: ApproverAnchor[] = MANAGERS.map((name) => ({ principal: principals[name]!, acceptedMethods: ["raw-key-v1"], notBefore, expiresAt, })); @@ -569,6 +573,40 @@ function recordEntry(audit: string, entry: Entry): "appended" | "replaced" | "un return "unchanged"; } +/** Private bounded development operator channel; the application never signs an effect approval. */ +export function requestOperator(path: string, request: Record): Promise> { + return new Promise((resolveRequest, reject) => { + const connection = createConnection(path); + const body = Buffer.from(JSON.stringify(request)); + const maximum = 8 * 1024 * 1024; + if (body.length === 0 || body.length > maximum) { + connection.destroy(); reject(new Error("operator.frame-bound")); return; + } + const header = Buffer.alloc(4); header.writeUInt32BE(body.length); + let received = Buffer.alloc(0); + let completed = false; + connection.setTimeout(620_000, () => connection.destroy(new Error("operator.review-timeout"))); + connection.on("error", reject); + connection.on("connect", () => connection.write(Buffer.concat([header, body]))); + connection.on("data", (chunk: Buffer) => { + received = Buffer.concat([received, chunk]); + if (received.length < 4) return; + const length = received.readUInt32BE(0); + if (length === 0 || length > maximum || received.length > length + 4) { + connection.destroy(new Error("operator.frame-bound")); return; + } + if (received.length === length + 4) { + try { + const result = JSON.parse(received.subarray(4).toString()) as Record; + if (typeof result.error === "string") throw new Error(result.error); + completed = true; resolveRequest(result); connection.end(); + } catch (error) { connection.destroy(); reject(error); } + } + }); + connection.on("end", () => { if (!completed) reject(new Error("operator.truncated-frame")); }); + }); +} + function readEffectApproval(path: string): Uint8Array { const file = openSync(path, "r"); try { @@ -588,7 +626,8 @@ function readEffectApproval(path: string): Uint8Array { } async function submit(options: Readonly<{ - state: string; socket: string; operationId: string; responses: string; effectApproval: string; + state: string; socket: string; operationId: string; responses: string; effectApproval?: string | undefined; + operatorSocket?: string | undefined; recover: boolean; }>): Promise> { const state = options.state; const facts = JSON.parse(readFileSync(join(state, "setup.json"), "utf8")) as SetupFacts; @@ -637,7 +676,24 @@ async function submit(options: Readonly<{ }); const proof = collection.assemble(action); const gateway = new GatewayClient(new GatewayEndpoint(resolve(options.socket))); - Object.assign(record, await gateway.submit({ proof, action: built.action, approval: readEffectApproval(options.effectApproval) }), { decided_by: "gateway" }); + let approval: Uint8Array; + if (options.operatorSocket !== undefined) { + const reviewed = await requestOperator(options.operatorSocket, + { kind: "approve", proof: b64(proof), action: b64(built.action) }); + approval = Buffer.from(String(reviewed.approval), "base64url"); + record.effect_review = Object.fromEntries(Object.entries(reviewed).filter(([name]) => name !== "approval")); + } else { + approval = readEffectApproval(required(options.effectApproval, "effect-approval or operator-socket")); + } + Object.assign(record, await gateway.submit({ proof, action: built.action, approval }), { decided_by: "gateway" }); + if (options.recover && record.outcome === "response-recorded" && record.status === 200) { + const read = await requestOperator(required(options.operatorSocket, "operator-socket for separate recovery"), + { kind: "recover", source: options.operationId }); + record.recovery = JSON.parse(Buffer.from(await gateway.recover(options.operationId, { + proof: Buffer.from(String(read.proof), "base64url"), action: Buffer.from(String(read.action), "base64url"), + approval: Buffer.from(String(read.approval), "base64url"), + })).toString()) as unknown; + } const observation = await gateway.observeOutcome(options.operationId); const outcome = observation.outcome === "signed" ? observation.observation : null; record.bundle = recordEntry(join(state, "audit"), { @@ -713,6 +769,8 @@ async function main(): Promise { required: { type: "string" }, responses: { type: "string" }, "effect-approval": { type: "string" }, + "operator-socket": { type: "string" }, + recover: { type: "boolean", default: false }, out: { type: "string" }, precheck: { type: "boolean", default: false }, help: { type: "boolean", default: false }, @@ -765,7 +823,9 @@ async function main(): Promise { socket: required(values.socket, "socket"), operationId: required(values["operation-id"], "operation-id"), responses: resolve(required(values.responses, "responses")), - effectApproval: resolve(required(values["effect-approval"], "effect-approval")), + effectApproval: values["effect-approval"], + operatorSocket: values["operator-socket"], + recover: values.recover!, }))}\n`); break; case "export": From af01d3769a2d6a1b90820a506a2f797487ebbe4a Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 01:13:13 +0000 Subject: [PATCH 071/136] test(gateway): exercise native acquisition crash boundaries on both stores --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-process-crash-file.json | 234 +++++++ .../native-process-crash-postgres.json | 234 +++++++ compliance.toml | 7 + docs/plans/0074-implementation-status.md | 96 ++- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../auths-gateway/src/native_crash_tests.rs | 573 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 44 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 10 +- release/semantic-freeze.json | 18 +- 12 files changed, 1191 insertions(+), 34 deletions(-) create mode 100644 bindings/fixtures/gateway/native-process-crash-file.json create mode 100644 bindings/fixtures/gateway/native-process-crash-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_crash_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index e28898ac1..ba6e25ddc 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -43,6 +43,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --exact native_content_process_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_process_tests::native_file_process_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_crash_tests::native_file_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-process-crash-file.json b/bindings/fixtures/gateway/native-process-crash-file.json new file mode 100644 index 000000000..65daeeba4 --- /dev/null +++ b/bindings/fixtures/gateway/native-process-crash-file.json @@ -0,0 +1,234 @@ +{ + "schema": "auths.native-process-crash/1", + "adapter": "file", + "scope": "full native content acquisition engine, fixed public fixture trust/approval/clock, separate real OS processes/custody and real local HTTP; SIGKILL inside/between actual adapter transactions and after partial response; no native decision or permit replaced", + "excluded": [ + "mutation/disclosure boundary schedules", + "injected sync/rename/partial-batch/ambiguous-commit faults", + "power loss or full-store rollback", + "hostile OS isolation", + "production commissioning and human approval" + ], + "cases": [ + { + "pause": "before-reservation-commit", + "sigkill": true, + "before": null, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-reservation-commit", + "sigkill": true, + "before": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "before-entry-commit", + "sigkill": true, + "before": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-entry-commit", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 0, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "during-response", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "before-response-commit", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-response-commit", + "sigkill": true, + "before": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-process-crash-postgres.json b/bindings/fixtures/gateway/native-process-crash-postgres.json new file mode 100644 index 000000000..84147b6c0 --- /dev/null +++ b/bindings/fixtures/gateway/native-process-crash-postgres.json @@ -0,0 +1,234 @@ +{ + "schema": "auths.native-process-crash/1", + "adapter": "postgres", + "scope": "full native content acquisition engine, fixed public fixture trust/approval/clock, separate real OS processes/custody and real local HTTP; SIGKILL inside/between actual adapter transactions and after partial response; no native decision or permit replaced", + "excluded": [ + "mutation/disclosure boundary schedules", + "injected sync/rename/partial-batch/ambiguous-commit faults", + "power loss or full-store rollback", + "hostile OS isolation", + "production commissioning and human approval" + ], + "cases": [ + { + "pause": "before-reservation-commit", + "sigkill": true, + "before": null, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-reservation-commit", + "sigkill": true, + "before": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "before-entry-commit", + "sigkill": true, + "before": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": true, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-entry-commit", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 0, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 0, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "during-response", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "before-response-commit", + "sigkill": true, + "before": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + }, + { + "pause": "after-response-commit", + "sigkill": true, + "before": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_at_kill": 1, + "resumed_only_without_previous_grant": false, + "after": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_calls_after_replays": 1, + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index cd3987cb2..16f43f20d 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1460,6 +1460,11 @@ language-binding = [ "bindings/python/tests/test_self_hosted_operator.py#test_root_grant_equals_the_native_path_and_carries_the_signer_evidence", "bindings/python/tests/test_enforcement_init.py#test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest", "bindings/python/tests/test_enforcement_init.py#test_audit_passes_the_gateway_verdict_through_and_adds_no_option", + "bindings/python/tests/test_enforcement_init.py#test_native_operator_template_matches_reviewed_example", + "bindings/python/tests/test_enforcement_init.py#test_operator_never_signs_incomplete_native_review", + "bindings/python/tests/test_enforcement_init.py#test_live_operator_decline_prevents_exact_signature", + "bindings/python/tests/test_enforcement_init.py#test_operator_bad_peers_leave_listener_available", + "bindings/python/tests/test_enforcement_init.py#test_operator_peer_and_native_deadlines_are_finite", ] core-wire-consumer = [ "bindings/python/tests/test_native_boundary_contract.py#test_every_registry_code_classifies_through_the_native_layer", @@ -1799,6 +1804,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/tests/content_journey.rs#native_content_process_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_process_tests.rs#native_file_process_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_process_tests.rs#postgres_native_process_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_crash_tests.rs#native_file_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_crash_tests.rs#postgres_native_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 605d28aef..d5e2897c3 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1769,6 +1769,100 @@ closure regeneration passed after that correction (one artifact-generation test) explicitly advanced. Generated source/formal identities were not reclassified as proved by these inventory updates. +## SDK example and generated-scaffold cutover checkpoint + +- Integrated hardened CI batch `a13e960f` as `8ab0136d`. Python, packed npm and + generated scaffold consumers now use native staged candidate acquisition and + publication, exact effect approvals, explicit configuration activation and + separately authorized recovery. Mutation HTTP response and the unchanged + native recovery report remain separate; positive recovery asserts the native + original source's provider link and observed stage, not a synthesized success. +- A separately installed Python operator SDK authors reserved read proofs for + the TypeScript application. This is declared deployment tooling; the actual + application still uses installed npm GatewayClient, without claiming native + TypeScript read-proof authoring. One authored operator transport helper is + copied byte-for-byte into the scaffold, with a direct equality gate. It does + not interpret provider fields or decide native admission/recovery outcomes. +- The operator channel accepts only closed bounded requests, canonical proof/ + action base64url and source tokens, rejects duplicate/malformed JSON, applies + a five-second whole-frame deadline and sixty-second native command deadline, + and returns redacted typed refusals. Malformed or disconnected peers cannot + terminate the listener or consume its valid-review allowance. Native authority, + capacity and one-use entry remain enforced by the gateway, independently of + this finite development review channel. +- Live exact signing requires separate owner-only FIFO consent after reading the + entire native literal-review.txt and signing-request.json. Simulation alone + uses the explicitly labeled finite scripted reviewer. Incomplete/unsupported + native reviews and declined live consent cannot reach the signer. +- Actual isolated reproductions passed the Python journey (19.55 seconds), + packed npm journey (24.25 seconds), generated project's full native selftest, + and thirty scaffold/operator tests. The latter include real malformed Unix + peers followed by a healthy request, finite deadlines and refusal before any + signature. A real positive recovery packet was also authored/reviewed through + the hardened transport. These used current wrappers and repaired native gateway + source but c809-era local Python/WASM artifacts; fresh exact-head installed + artifacts, live-human behavior and Docker isolation remain hosted obligations. +- Existing hostile manager/quorum/budget/provider cases, offline audit/tamper, + source-owned echo checks, idempotency state-loss demonstration, private key modes + and second-install zero-provider-I/O assertions were preserved. No AP070 source + or paused AP073 state was changed. These CI repairs do not close A01–A22. + +## Native acquisition process-crash checkpoint + +- `native_crash_tests.rs` executes the full native content acquisition engine in + separately spawned OS processes over each maintained adapter. It reuses native + call authoring, proof verification, exact approval, installed dependency fencing + and separate local custody. Fixed public keys, fixed deployment time and a + privileged test installation remain explicit assumptions; no EntryValidation + oracle replaces the gateway's checks. +- A test-only transparent store proxy pauses unchanged native decisions under + the actual adapter fence, or pauses before forwarding actual durability + acknowledgement. The proxy never selects a transition, rewrites a record or + constructs a permit. Production builds contain no selectable failpoint. +- Both file and TLS PostgreSQL exercise seven SIGKILL schedules: before + reservation commit; after reservation commit before acknowledgement; after + acknowledged reservation but before entry commit; after entry commit before + its acknowledgement/transport; while a real HTTP response is partial; after + complete response receipt before persistence; and after response commit before + return to the caller. The receiving process is confirmed killed by signal 9; + the separate HTTP double records actual requests. No caller result was written. +- Reopening checks the protected native phase, durable grant and original + allocation, plus native public history/charge projections. Absence and reserved + state can resume only through current native proof/approval/entry checks, with + one original allocation and one GET. A lost grant remains charged Unknown + even when no HTTP request was sent, and cannot lease or fetch again. Lost + response persistence remains Unknown without reconstructible content. Durable + response persistence retains ready content despite caller-response loss. +- Every terminal replay preserves private journal bytes, native boundary counters + and public snapshot. Each allocated invocation retains one call and the full + 1,024-byte ceiling, including unknown; it is not refunded to actual response + size. There is no automatic refetch, redelivery, observation or write. +- Required artifact generators `native_file_process_crash_fixture_is_current` + and `postgres_native_process_crash_fixture_is_current` generated reproducible + seven-case files under bindings/fixtures/gateway. Initial exact runs passed in + 1.45 and 2.66 seconds respectively; final assertions additionally check the + native recovered stage, no post-grant custody lease and retained-content + projection. PostgreSQL used an independent canonical TLS fixture on port55451, + certificate/server-name verification and synchronous commits; schema isolation + and cleanup are provided by TestAttempts. The dedicated Docker containers, + network and volume were stopped/removed after final generation. Both explicit feature-gated commands + were added to PostgreSQL CI so normal default-feature discovery cannot omit them. +- Final regeneration after the complete native assertions passed both adapter + generators in one invocation (two adapter tests and the no-input peer helper, + all three passed in 3.96 seconds). The source-closure generator passed in 0.06 seconds before rebuilding + that final test executable; its embedded-closure verification then passed + 1/1 in 0.05 seconds. The known strict gateway lint reproduction passed + without suppressions after adding the instrumentation. Source closure and release metadata must match + the committed final source before publication. These are native acquisition + transaction-boundary/process-crash results, not injected sync/rename failures, + partial-batch fault schedules, ambiguous database commit delivery, power-loss, + hostile-process isolation or all mutation/disclosure crash boundaries. A05 + remains partial and A06 remains open; no acceptance invariant was weakened. + +- Integrated release freeze 395 advances identity protocol 141, portable ABI + bindings 125, public SDK contract 138 and public surface 395 for the combined + source/inventory changes. It does not certify new formal or provider claims. + ## Phase gates | Phase | State | Outstanding gate | @@ -1791,7 +1885,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / two-daemon file and full native engine processes on file/TLS PostgreSQL / final source lifetime count/bytes, durable grants and reopened replay executed | Managed fixed-window count/sum and complete adverse schedules still required | -| A05 | Crash at every persistence/transport boundary | Partial / real daemon/recipient crash after receipt before ACK / charged unknown and exact late ACK executed | Remaining persistence/send boundaries and PostgreSQL | +| A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 36dbba573..a406fdb0a 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"938b1fe5d3b0f32f95e10d8052b7a11c39fb4c7024452cef72a575903df4f41e"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"006c735b311ccde0c72b4b30386bbe178e15b2c9beaa9024f9ba1b37cd65290c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"2ab677f9797ebd541da60a96857b653f5c58cce017f98b63b24edcd694a99d41"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"938b1fe5d3b0f32f95e10d8052b7a11c39fb4c7024452cef72a575903df4f41e"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"9e46791e45a815c94327937218ffa3121f5b736795182ba4e18fa747e33d8aac"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"08686fd3af614e0b83540ae807ee1d04914e358e754726e11b1e0456a50f4da5"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index d5745a5cd..5e743c459 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -157,3 +157,6 @@ pub use transport::MAX_TRANSPORT_DURATION; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_process_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_crash_tests; diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs new file mode 100644 index 000000000..7617f9560 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -0,0 +1,573 @@ +//! Real SIGKILL boundaries around the native engine and maintained adapters. +//! Test-only pass-through storage instrumentation never changes a decision, +//! acknowledgement or record. It cannot be selected in a shipping build. +use crate::native_process_tests::{ + CONTENT, Provider, Setup, acquire, authorize, load_engine, private, recipe, runtime, +}; +use crate::store::GatewayFenceDecision; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ContentHistory, ContentProjectionStatus, + GatewayAttemptError, GatewayAttemptKey, GatewayAttemptStore, GatewayAttempts, GatewayInsert, + GatewayRecordEntry, GatewayRecordKind, LogicalOperationId, SharedConnection, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::{fs::PermissionsExt as _, process::ExitStatusExt as _}, + path::{Path, PathBuf}, + process::{Child, Command, Stdio}, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, + thread, + time::{Duration, Instant}, +}; + +const OPERATION: &str = "crash-read"; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Point { + BeforeReservationCommit, + AfterReservationCommit, + BeforeEntryCommit, + AfterEntryCommit, + DuringResponse, + BeforeResponseCommit, + AfterResponseCommit, +} +impl Point { + const ALL: [Self; 7] = [ + Self::BeforeReservationCommit, + Self::AfterReservationCommit, + Self::BeforeEntryCommit, + Self::AfterEntryCommit, + Self::DuringResponse, + Self::BeforeResponseCommit, + Self::AfterResponseCommit, + ]; + const fn resumable(self) -> bool { + matches!( + self, + Self::BeforeReservationCommit | Self::AfterReservationCommit | Self::BeforeEntryCommit + ) + } + const fn expected_phase(self) -> Option<&'static str> { + match self { + Self::BeforeReservationCommit => None, + Self::AfterReservationCommit | Self::BeforeEntryCommit => Some("reserved"), + Self::AfterEntryCommit | Self::DuringResponse | Self::BeforeResponseCommit => { + Some("entry-granted") + } + Self::AfterResponseCommit => Some("content-response-recorded"), + } + } + const fn provider_calls(self) -> usize { + match self { + Self::DuringResponse | Self::BeforeResponseCommit | Self::AfterResponseCommit => 1, + _ => 0, + } + } + fn matches(self, after: bool, phase: &str) -> bool { + matches!( + (self, after, phase), + (Self::BeforeReservationCommit, false, "reserved") + | (Self::AfterReservationCommit, true, "reserved") + | (Self::BeforeEntryCommit, false, "entry-granted") + | (Self::AfterEntryCommit, true, "entry-granted") + | ( + Self::BeforeResponseCommit, + false, + "content-response-recorded" + ) + | (Self::AfterResponseCommit, true, "content-response-recorded") + ) + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct CrashSetup { + installation: Setup, + point: Point, +} + +fn pause_at(port: u16) { + let mut channel = TcpStream::connect(("127.0.0.1", port)).expect("crash control"); + channel + .set_read_timeout(Some(Duration::from_secs(20))) + .expect("control deadline"); + channel.write_all(b"P").expect("pause marker"); + let mut release = [0]; + channel + .read_exact(&mut release) + .expect("parent release or SIGKILL"); + assert_eq!(release, *b"G"); +} + +/// A transparent proxy around the actual adapter. Native closures are never +/// replaced or rerun: the adapter invokes them at most once under its fence, +/// and receives their bytes unchanged. +struct PausedStore { + inner: Arc, + key: GatewayAttemptKey, + point: Point, + port: u16, + fired: AtomicBool, +} +impl PausedStore { + fn target(&self, kind: GatewayRecordKind, key: GatewayAttemptKey) -> bool { + kind == GatewayRecordKind::Attempt && key == self.key + } + fn phase(bytes: &[u8]) -> String { + let value: Value = serde_json::from_slice(bytes).expect("native record"); + assert_eq!(value["operation_id"], OPERATION); + assert_eq!(value["state"]["protocol"], "acquisition"); + value["state"]["facts"]["phase"]["stage"] + .as_str() + .expect("native phase") + .to_owned() + } + fn pause(&self, after: bool, phase: &str) { + if self.point.matches(after, phase) && !self.fired.swap(true, Ordering::SeqCst) { + pause_at(self.port); + } + } +} +impl GatewayAttemptStore for PausedStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + if !entries + .first() + .is_some_and(|entry| self.target(entry.kind, entry.key)) + { + return self.inner.fenced_insert_all(entries, dependencies, decide); + } + let mut phase = None; + let result = self + .inner + .fenced_insert_all(entries, dependencies, &mut |snapshots| { + let next = decide(snapshots)?; + let current = Self::phase(&next); + self.pause(false, ¤t); + phase = Some(current); + Ok(next) + }); + if matches!(result, Ok(GatewayInsert::Inserted)) { + self.pause(true, phase.as_deref().expect("native admission decision")); + } + result + } + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + if !keys + .first() + .is_some_and(|(kind, key)| self.target(*kind, *key)) + { + return self.inner.fenced_replace(keys, decide); + } + let mut phase = None; + let result = self.inner.fenced_replace(keys, &mut |snapshots| { + let next = decide(snapshots)?; + let current = Self::phase(&next); + self.pause(false, ¤t); + phase = Some(current); + Ok(next) + }); + if result.is_ok() { + self.pause(true, phase.as_deref().expect("native entry decision")); + } + result + } + fn replace( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + if !self.target(kind, *key) { + return self.inner.replace(kind, key, current, next); + } + let phase = Self::phase(next); + self.pause(false, &phase); + let result = self.inner.replace(kind, key, current, next); + if result.is_ok() { + self.pause(true, &phase); + } + result + } + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.inner.insert_all(entries) + } + fn load( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + self.inner.load(kind, key) + } + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.inner.sweep_expired(now, limit) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.inner.attempt_keys(limit) + } +} + +fn operation_key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") +} + +#[test] +fn native_crash_peer() { + let Some(path) = std::env::var_os("AUTHS_AP074_CRASH_PEER") else { + return; + }; + let setup: CrashSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let attached = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let wrapped = Arc::new(PausedStore { + inner: attached.raw(), + key: operation_key(), + point: setup.point, + port: setup.installation.barrier_port, + fired: AtomicBool::new(false), + }); + let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine(&setup.installation, "crash-peer", attempts)); + let result = runtime.block_on(acquire(&engine, &setup.installation.root, OPERATION)); + private( + &setup.installation.root.join("caller-result.json"), + &serde_json::to_vec(&result).expect("result"), + ); +} + +struct Peer(Child); +impl Peer { + fn start(input: &Path) -> Self { + Self( + Command::new(std::env::current_exe().expect("test executable")) + .args([ + "--exact", + "native_crash_tests::native_crash_peer", + "--nocapture", + ]) + .env("AUTHS_AP074_CRASH_PEER", input) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("native child"), + ) + } + fn await_pause(&mut self, listener: &TcpListener) -> TcpStream { + let deadline = Instant::now() + Duration::from_secs(15); + loop { + if let Some(status) = self.0.try_wait().expect("child status") { + let mut diagnostic = String::new(); + self.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + panic!("child exited before the exact pause: {status}: {diagnostic}"); + } + match listener.accept() { + Ok((mut channel, _)) => { + channel.set_nonblocking(false).expect("blocking"); + channel + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut marker = [0]; + channel.read_exact(&mut marker).expect("pause"); + assert_eq!(marker, *b"P"); + return channel; + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "exact crash pause timed out"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("control accept: {error}"), + } + } + } + fn kill(&mut self) { + self.0.kill().expect("SIGKILL"); + assert_eq!(self.0.wait().expect("child exit").signal(), Some(9)); + } +} +impl Drop for Peer { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: CrashSetup, + listener: TcpListener, + provider: Provider, + runtime: tokio::runtime::Runtime, +} +impl Case { + fn new(backend: Backend, point: Point) -> Self { + let store = TestAttempts::open(backend); + let directory = tempfile::tempdir().expect("private directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private mode"); + let listener = TcpListener::bind("127.0.0.1:0").expect("control listener"); + listener.set_nonblocking(true).expect("nonblocking"); + let port = listener.local_addr().expect("address").port(); + let pause: Option> = matches!(point, Point::DuringResponse) + .then(|| Box::new(move || pause_at(port)) as Box); + let provider = Provider::controlled(pause); + let setup = CrashSetup { + point, + installation: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: port, + }, + }; + let runtime = runtime(); + let (engine, record) = runtime.block_on(load_engine( + &setup.installation, + "parent", + store.attempts().clone(), + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + runtime + .block_on(shared.insert(&record)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + runtime.block_on(authorize(&engine, &setup.installation.root, OPERATION)); + assert_eq!(provider.calls.load(Ordering::SeqCst), 0); + Self { + _directory: directory, + store, + setup, + listener, + provider, + runtime, + } + } + fn crash(&self) { + let input = self.setup.installation.root.join("crash-setup.json"); + private(&input, &serde_json::to_vec(&self.setup).expect("setup")); + let mut peer = Peer::start(&input); + let mut paused = peer.await_pause(&self.listener); + assert!( + !self + .setup + .installation + .root + .join("caller-result.json") + .exists() + ); + peer.kill(); + if matches!(self.setup.point, Point::DuringResponse) { + paused + .write_all(b"G") + .expect("release provider after child death"); + } + assert_eq!( + self.provider.calls.load(Ordering::SeqCst), + self.setup.point.provider_calls() + ); + } + fn raw(&self) -> Option> { + self.store + .raw() + .load(GatewayRecordKind::Attempt, &operation_key()) + .expect("native record") + } + fn pre_crash_phase(&self, bytes: Option<&[u8]>) { + let phase = bytes.map(PausedStore::phase); + assert_eq!(phase.as_deref(), self.setup.point.expected_phase()); + if let Some(bytes) = bytes { + let value: Value = serde_json::from_slice(bytes).expect("native record"); + assert_eq!(value["state"]["facts"]["allocation"], 0); + assert_eq!(!value["entry"].is_null(), !self.setup.point.resumable()); + } + } + fn reopen(&self) -> Value { + let before = self.raw(); + self.pre_crash_phase(before.as_deref()); + let (engine, _) = self.runtime.block_on(load_engine( + &self.setup.installation, + "reopened", + self.store.reopen(), + )); + let history = self.runtime.block_on(engine.content_history(OPERATION)); + if before.is_none() { + assert!(history.is_err(), "absent admission has no retained history"); + } + let before_snapshot = before + .as_ref() + .map(|_| match history.expect("retained facts") { + ContentHistory::Acquisition(snapshot) => snapshot, + ContentHistory::Disclosure(_) => panic!("wrong protocol"), + }); + if let Some(snapshot) = &before_snapshot { + let expected = if self.setup.point.resumable() { + AcquisitionStage::Reserved + } else if matches!(self.setup.point, Point::AfterResponseCommit) { + AcquisitionStage::ResponseRecorded + } else { + AcquisitionStage::Unknown + }; + assert_eq!(snapshot.stage, expected, "native recovered projection"); + assert_eq!( + (snapshot.reserved_calls, snapshot.reserved_bytes), + (1, 1024) + ); + } + let before_boundary = engine.execution_witness(); + let result = self + .runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("native replay"); + self.assert_result(&result); + let after = self.raw(); + if !self.setup.point.resumable() { + assert_eq!( + before_boundary, + engine.execution_witness(), + "lost grants cannot lease again" + ); + assert_eq!(before, after, "lost permits never remint"); + } + let witness = engine.execution_witness(); + assert_eq!( + self.runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("second replay"), + result + ); + assert_eq!( + witness, + engine.execution_witness(), + "terminal replay cannot lease or enter" + ); + assert_eq!(self.raw(), after, "terminal journal is byte immutable"); + json!({ "pause": self.setup.point, "sigkill": true, "before": before_snapshot, + "provider_calls_at_kill": self.setup.point.provider_calls(), + "resumed_only_without_previous_grant": self.setup.point.resumable(), + "after": result, "provider_calls_after_replays": self.provider.calls.load(Ordering::SeqCst), + "terminal_replays_leave_journal_and_boundary_counters_unchanged": true }) + } + fn assert_result(&self, snapshot: &AcquisitionSnapshot) { + let recorded = + self.setup.point.resumable() || matches!(self.setup.point, Point::AfterResponseCommit); + assert_eq!( + snapshot.stage, + if recorded { + AcquisitionStage::ResponseRecorded + } else { + AcquisitionStage::Unknown + } + ); + assert_eq!( + (snapshot.reserved_calls, snapshot.reserved_bytes), + (1, 1024) + ); + assert_eq!( + snapshot.response_bytes, + recorded.then_some(CONTENT.len() as u64) + ); + assert_eq!( + snapshot.content_projection, + recorded.then_some(ContentProjectionStatus::Ready { + bytes: CONTENT.len() as u64 + }), + "lost response bytes cannot become retained content" + ); + let calls = if self.setup.point.resumable() { + 1 + } else { + self.setup.point.provider_calls() + }; + assert_eq!(self.provider.calls.load(Ordering::SeqCst), calls); + let raw: Value = + serde_json::from_slice(&self.raw().expect("record")).expect("native record"); + assert!(!raw["entry"].is_null()); + assert_eq!( + raw["state"]["facts"]["allocation"], 0, + "one original permanent allocation" + ); + } +} + +fn crash_matrix(backend: Backend) { + let cases: Vec<_> = Point::ALL + .into_iter() + .map(|point| { + let case = Case::new(backend, point); + case.crash(); + case.reopen() + }) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({ + "schema": "auths.native-process-crash/1", "adapter": backend.label(), + "scope": "full native content acquisition engine, fixed public fixture trust/approval/clock, separate real OS processes/custody and real local HTTP; SIGKILL inside/between actual adapter transactions and after partial response; no native decision or permit replaced", + "excluded": ["mutation/disclosure boundary schedules", "injected sync/rename/partial-batch/ambiguous-commit faults", "power loss or full-store rollback", "hostile OS isolation", "production commissioning and human approval"], + "cases": cases + })).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-process-crash-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("artifact write"); + } + assert_eq!(std::fs::read(path).expect("artifact"), artifact); +} + +#[test] +fn native_file_process_crash_fixture_is_current() { + crash_matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_process_crash_fixture_is_current() { + assert!(postgres_configured()); + crash_matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index 715953049..e3ab2cdd5 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -33,23 +33,23 @@ use std::{ const NOW: u64 = 1_790_000_000; const SECRET: &[u8] = b"public-native-process-fixture"; -const CONTENT: &[u8] = b"PUBLIC-NATIVE-CONTENT"; +pub(super) const CONTENT: &[u8] = b"PUBLIC-NATIVE-CONTENT"; #[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] -struct Setup { - backend: String, - location: String, - root: PathBuf, - provider_port: u16, - barrier_port: u16, +pub(super) struct Setup { + pub(super) backend: String, + pub(super) location: String, + pub(super) root: PathBuf, + pub(super) provider_port: u16, + pub(super) barrier_port: u16, } -fn private(path: &Path, bytes: &[u8]) { +pub(super) fn private(path: &Path, bytes: &[u8]) { std::fs::write(path, bytes).expect("private input"); std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("private mode"); } -fn recipe() -> CompiledRecipe { +pub(super) fn recipe() -> CompiledRecipe { CompiledRecipe::compile( include_bytes!("../../../../bindings/fixtures/gateway/content-only/recipe.json"), include_bytes!("../../../../bindings/fixtures/gateway/content-only/profile.lock.json"), @@ -65,11 +65,11 @@ fn trust(recipe: &CompiledRecipe) -> Vec { .expect("tool"); tools_context(&[call], NOW).expect("native trust") } -fn runtime() -> tokio::runtime::Runtime { +pub(super) fn runtime() -> tokio::runtime::Runtime { tokio::runtime::Runtime::new().expect("runtime") } -async fn load_engine( +pub(super) async fn load_engine( setup: &Setup, label: &str, attempts: GatewayAttempts, @@ -139,7 +139,7 @@ async fn load_engine( (engine, record) } -async fn authorize(engine: &GatewayEngine, root: &Path, operation: &str) { +pub(super) async fn authorize(engine: &GatewayEngine, root: &Path, operation: &str) { let call = engine .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) .await @@ -169,7 +169,7 @@ async fn authorize(engine: &GatewayEngine, root: &Path, operation: &str) { private(&root.join(format!("{operation}.{suffix}")), &bytes); } } -async fn acquire( +pub(super) async fn acquire( engine: &GatewayEngine, root: &Path, operation: &str, @@ -182,14 +182,17 @@ async fn acquire( .await } -struct Provider { - port: u16, - calls: Arc, +pub(super) struct Provider { + pub(super) port: u16, + pub(super) calls: Arc, stop: Arc, thread: Option>, } impl Provider { fn start() -> Self { + Self::controlled(None) + } + pub(super) fn controlled(mut pause: Option>) -> Self { let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); let port = listener.local_addr().expect("address").port(); listener.set_nonblocking(true).expect("nonblocking"); @@ -233,7 +236,14 @@ impl Provider { ); observed.fetch_add(1, Ordering::SeqCst); stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: close\r\nContent-Length: {}\r\n\r\n",CONTENT.len()).as_bytes()).expect("response headers"); - stream.write_all(CONTENT).expect("response body"); + if let Some(pause) = pause.take() { + stream.write_all(&CONTENT[..1]).expect("partial response"); + pause(); + // The crash case deliberately kills the receiving process. + let _ = stream.write_all(&CONTENT[1..]); + } else { + stream.write_all(CONTENT).expect("response body"); + } } }); Self { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 1d132ebe8..8b443e280 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d4fc5a0b03f146dd1cad971d75db4e199f2ec44405e916f2fd764b32b973cc6c"; + "c031726748fb1ee96d0f1bec3c34803edfcefaeb79130ed5438660a367aed78a"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 2b490cc01..323956461 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 394 +freeze_version = 395 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,9 +45,9 @@ freeze_version = 394 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 140 +"auths.identity.protocol" = 141 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 124 +"auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -60,11 +60,11 @@ freeze_version = 394 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 137 +"auths.product.public-sdk-contract" = 138 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 394 +"auths.release.public-surface" = 395 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 8f8140820..cc32e9ed3 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 394, + "freezeVersion": 395, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 140, + "version": 141, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "815d6e8ec9ff5d0dbfea3f8eb03f51dcbd012a037ce81387cda0e75f16a1cb95" + "sha256": "67b2b9cbfe32d73e9646f7e09653ee3bd83e563c409d618db01c00e8d6de3c94" }, { "id": "auths.modular-components", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 124, + "version": 125, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "51fed0f1e4dd7d44df657588052b6790615b917307c8cd8ae13fd9f073640bde" + "sha256": "26330f8e6c0b586b5a410e85bb1365eb99c0d1e2534d2ea0a5d2a975b84b9cfb" }, { "id": "auths.product.bounded-domains", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 137, + "version": 138, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "ac1053fd2412b4cceb83f85287cd48b17dd7fe0d2bfc69b714fa1d4b44d6cf38" + "sha256": "57b709148ca6e7efa2017d712f26ed9eb08253eaa117848da2a428b2a617be64" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 394, + "version": 395, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "7ba758b2e0d287819fe098134599f634a893a28251a60518ab44e8a4b2a67315" + "sha256": "094c17969512ab6038fd1fb37101c0d672b0156fd126b6287697660831641b5e" } ] } From 050fa21940cc540c332eaf12dff4ad181968d542 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 01:39:57 +0000 Subject: [PATCH 072/136] fix(ci): resolve security gates and preserve producer artifacts on retries --- .github/workflows/python-sdk.yml | 28 ++- .github/workflows/recipe-qualification.yml | 35 ++-- .github/workflows/release.yml | 5 +- .github/workflows/typescript-sdk.yml | 9 +- .gitleaksignore | 26 +++ Cargo.lock | 171 +++++++++++------- Cargo.toml | 12 +- bindings/customer-journey-matrix-v1.json | 2 +- core/adapters/auths-webauthn/src/lib.rs | 2 +- core/crates/auths-signature-core/src/lib.rs | 20 +- core/testkit/auths-testkit/src/lib.rs | 25 +-- .../auths-custody-aws-kms/src/lib.rs | 8 +- .../auths-custody-pkcs11/src/lib.rs | 4 +- .../auths-custody/src/conformance.rs | 4 +- product/integrations/auths-custody/src/key.rs | 4 +- product/integrations/auths-custody/src/lib.rs | 8 +- .../auths-git-signing/src/custody_tests.rs | 4 +- .../auths-git-signing/src/workload.rs | 4 +- .../auths-git-signing/src/workload_fakes.rs | 10 +- .../src/effect_candidate_staging_tests.rs | 7 +- .../auths-gateway/src/observed_tests.rs | 11 +- .../auths-gateway/src/pending_vectors/keys.rs | 8 +- 22 files changed, 240 insertions(+), 167 deletions(-) diff --git a/.github/workflows/python-sdk.yml b/.github/workflows/python-sdk.yml index 05322fdf8..70458dc9c 100644 --- a/.github/workflows/python-sdk.yml +++ b/.github/workflows/python-sdk.yml @@ -83,7 +83,10 @@ jobs: - run: python bindings/python/tools/check_contract.py - run: python bindings/python/tools/check_doc_snippets.py + # Consumers use producer IDs across retries; zero refuses missing outputs. consumer-contract: + outputs: + artifact-id: ${{ steps.consumer-artifact.outputs.artifact-id }} name: build external-consumer contract runs-on: ubuntu-latest steps: @@ -97,6 +100,7 @@ jobs: cargo run --locked -p auths-proof-wasm --example generate-node-vectors -- target/binding-vectors - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: consumer-artifact with: name: python-sdk-consumer-${{ github.run_id }}-${{ github.run_attempt }} path: | @@ -132,6 +136,10 @@ jobs: compression-level: 9 wheel-build: + outputs: + ubuntu-24.04: ${{ steps.wheel-output.outputs['ubuntu-24.04'] }} + macos-latest: ${{ steps.wheel-output.outputs['macos-latest'] }} + windows-latest: ${{ steps.wheel-output.outputs['windows-latest'] }} name: build abi3 wheel (${{ matrix.os }}) strategy: fail-fast: true @@ -155,12 +163,20 @@ jobs: --features pyo3/extension-module --out target/python-release-wheels - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: wheel-artifact with: name: python-wheel-${{ matrix.os }}-${{ github.run_id }}-${{ github.run_attempt }} path: target/python-release-wheels/*.whl if-no-files-found: error retention-days: 1 compression-level: 0 + # Unique matrix keys retain the producing platform's immutable artifact ID. + - id: wheel-output + shell: bash + env: + WHEEL_PLATFORM: ${{ matrix.os }} + WHEEL_ARTIFACT_ID: ${{ steps.wheel-artifact.outputs.artifact-id }} + run: echo "${WHEEL_PLATFORM}=${WHEEL_ARTIFACT_ID}" >> "$GITHUB_OUTPUT" installed-workflow: name: installed CPython ${{ matrix.python }} (${{ matrix.os }}) @@ -177,11 +193,11 @@ jobs: python-version: ${{ matrix.python }} - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-wheel-${{ matrix.os }}-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.wheel-build.outputs[matrix.os] || '0' }} path: wheelhouse - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-sdk-consumer-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.consumer-contract.outputs.artifact-id || '0' }} path: consumer - name: Assert a source-free consumer boundary shell: bash @@ -248,11 +264,11 @@ jobs: python-version: "3.9" - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-wheel-ubuntu-24.04-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.wheel-build.outputs['ubuntu-24.04'] || '0' }} path: wheelhouse - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-sdk-consumer-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.consumer-contract.outputs.artifact-id || '0' }} path: consumer - name: Install the wheel and pinned type checkers shell: bash @@ -303,11 +319,11 @@ jobs: python-version: "3.9" - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-wheel-${{ matrix.os }}-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.wheel-build.outputs[matrix.os] || '0' }} path: wheelhouse - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: python-sdk-consumer-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.consumer-contract.outputs.artifact-id || '0' }} path: consumer - name: Install only the built wheel shell: bash diff --git a/.github/workflows/recipe-qualification.yml b/.github/workflows/recipe-qualification.yml index bb8f696cb..fef4cfc24 100644 --- a/.github/workflows/recipe-qualification.yml +++ b/.github/workflows/recipe-qualification.yml @@ -30,6 +30,8 @@ concurrency: jobs: candidate: + outputs: + artifact-id: ${{ steps.candidate-artifact.outputs.artifact-id }} name: shipping gateway candidate without credentials runs-on: ubuntu-latest timeout-minutes: 60 @@ -80,6 +82,7 @@ jobs: }, sort_keys=True, indent=2) + '\n') PY - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: candidate-artifact with: name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} path: target/qualification-shipping-candidate @@ -87,6 +90,8 @@ jobs: retention-days: 30 packet-author: + outputs: + artifact-id: ${{ steps.python-artifact.outputs.artifact-id }} name: installed packet author and shipping native review needs: candidate runs-on: ubuntu-latest @@ -110,7 +115,7 @@ jobs: "${RUNNER_TEMP}/packet-consumer/bin/python" -m pip install target/qualification-wheels/*.whl - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/packet-candidate - name: Run the author without a checkout or provider credential shell: bash @@ -162,6 +167,7 @@ jobs: retention-days: 30 - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: python-artifact with: name: qualification-python-${{ github.run_id }}-${{ github.run_attempt }} path: target/qualification-wheels/*.whl @@ -169,6 +175,8 @@ jobs: retention-days: 30 typescript-consumer: + outputs: + artifact-id: ${{ steps.typescript-artifact.outputs.artifact-id }} name: installed TypeScript qualification consumer runs-on: ubuntu-latest timeout-minutes: 60 @@ -226,6 +234,7 @@ jobs: }, sort_keys=True) + '\n') PY - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: typescript-artifact with: name: qualification-typescript-${{ github.run_id }}-${{ github.run_attempt }} path: target/qualification-typescript @@ -327,7 +336,7 @@ jobs: cp qualification/reference/*.py "${RUNNER_TEMP}/offline-author-kit/" - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/candidate - name: Run offline stages on the exact shipping candidate shell: bash @@ -396,15 +405,15 @@ jobs: node-version: 22.23.1 - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/candidate - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-python-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.packet-author.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/python-package - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-typescript-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.typescript-consumer.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/typescript-package - name: Install the exact credential-free consumer packages shell: bash @@ -532,7 +541,7 @@ jobs: run: cargo build --locked --release -p auths-gateway --bin auths-gateway -p auths-recipe-qualification-issuance --bin auths-qualification - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/candidate - name: Receive only this run's bounded public inputs shell: bash @@ -586,15 +595,15 @@ jobs: run: cargo build --locked --release -p auths-gateway --bin auths-gateway -p auths-recipe-qualification-issuance --bin auths-qualification - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/candidate - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-python-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.packet-author.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/python-package - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-typescript-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.typescript-consumer.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/typescript-package - name: Receive only this run's original public pool and first proposal shell: bash @@ -630,7 +639,7 @@ jobs: sign: name: sign the complete cleaned qualification release - needs: [live, families, commissioner, first-sign] + needs: [live, families, commissioner, first-sign, candidate, packet-author, typescript-consumer] if: github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main' runs-on: ubuntu-latest timeout-minutes: 60 @@ -649,15 +658,15 @@ jobs: run: cargo build --locked --release -p auths-gateway --bin auths-gateway -p auths-recipe-qualification-issuance --bin auths-qualification - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-shipping-candidate-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.candidate.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/candidate - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-python-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.packet-author.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/python-package - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: qualification-typescript-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.typescript-consumer.outputs.artifact-id || '0' }} path: ${{ runner.temp }}/typescript-package - name: Receive exact-run public inputs and cleanup-closed proposals shell: bash diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 474dfda90..aae8c7b7f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -186,6 +186,8 @@ jobs: } >> "$GITHUB_STEP_SUMMARY" promotion-entry-gate: + outputs: + artifact-id: ${{ steps.promotion-artifact.outputs.artifact-id }} name: verify exact staged candidate and promotion authority if: inputs.operation == 'promote-github-prerelease' runs-on: ubuntu-latest @@ -270,6 +272,7 @@ jobs: target/promotion-request.json target/owner-authorization.json - name: Preserve verified promotion input for protected job + id: promotion-artifact uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 with: name: auths-promotion-input-${{ github.run_id }}-${{ github.run_attempt }} @@ -294,7 +297,7 @@ jobs: - name: Download verified promotion input uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: auths-promotion-input-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.promotion-entry-gate.outputs.artifact-id || '0' }} path: target/promotion - name: Recheck exact manifest and immutable tag state env: diff --git a/.github/workflows/typescript-sdk.yml b/.github/workflows/typescript-sdk.yml index 2b3a1a5f6..fd3fd6748 100644 --- a/.github/workflows/typescript-sdk.yml +++ b/.github/workflows/typescript-sdk.yml @@ -31,6 +31,8 @@ permissions: jobs: package-runtime: + outputs: + artifact-id: ${{ steps.runtime-artifact.outputs.artifact-id }} name: build package runtime runs-on: ubuntu-latest steps: @@ -54,6 +56,7 @@ jobs: - run: npm run build:vectors working-directory: bindings/typescript - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + id: runtime-artifact with: name: typescript-sdk-runtime-${{ github.run_id }}-${{ github.run_attempt }} path: | @@ -85,7 +88,7 @@ jobs: working-directory: bindings/typescript - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: typescript-sdk-runtime-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.package-runtime.outputs.artifact-id || '0' }} path: . - run: npm run test:contract working-directory: bindings/typescript @@ -124,7 +127,7 @@ jobs: working-directory: bindings/typescript - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: typescript-sdk-runtime-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.package-runtime.outputs.artifact-id || '0' }} path: . - run: npx playwright install --with-deps chromium working-directory: bindings/typescript @@ -159,7 +162,7 @@ jobs: working-directory: bindings/typescript - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8 with: - name: typescript-sdk-runtime-${{ github.run_id }}-${{ github.run_attempt }} + artifact-ids: ${{ needs.package-runtime.outputs.artifact-id || '0' }} path: . - run: npm run test:gateway working-directory: bindings/typescript diff --git a/.gitleaksignore b/.gitleaksignore index caf599f79..2ccc6fba9 100644 --- a/.gitleaksignore +++ b/.gitleaksignore @@ -99,3 +99,29 @@ f9e6eda7d45bf8a135c8b4cce6d662212bb454d9:formal/Auths/Product/JsonStringDocument # Reviewed 2026-10-25: this evidence line names a public Auths Git commit # revision. The matched value is an immutable source SHA, not a credential. 3d29a6b0273165f85676f200ff5c6e54c30b12d9:demos/google-employee-delegation/evidence/live-partial-consumer-2026-10-25.md:generic-api-key:8 + +# Reviewed 2026-10-29 against exact full-history findings. +# Synthetic credential marker in the unapproved-candidate denial test; never sent +# to a provider. Current source uses an unmistakable synthetic marker. +ed557dab874beed2820624ad9600df04e81a1d6e:product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs:stripe-access-token:366 +# Native configuration fixture: deterministic SHA-256 key of the synthetic +# policy/namespace; required public digest bytes, generated in configuration.rs. +8dbd99391b274d8a9589dd28c1ba0187fb9cd90e:bindings/fixtures/gateway/effect-configuration.json:generic-api-key:4 +# Native configuration fixture: deterministic SHA-256 revision digest of the +# synthetic record; required public bytes, generated in configuration.rs. +8dbd99391b274d8a9589dd28c1ba0187fb9cd90e:bindings/fixtures/gateway/effect-configuration.json:generic-api-key:6 +# Native effect fixture: deterministic replay identity from policy, namespace +# and operation ID; generated by effect_native_tests.rs, not a credential. +96e47805cb245a00256ec4ad8e7d45c61ffe7947:bindings/fixtures/gateway/effect-binding.json:generic-api-key:5 +# Removed release-reference test: synthetic Airtable resource identifier in +# a namespace/resource tuple; not a provider credential. +510950b92d92ef2b5fb087113283f7ee6924f851:product/runtime/auths-gateway/src/recipe/release.rs:airtable-api-key:720 +# Historical rebase of the reviewed public Python import symbols +# raw_key_ed25519 and authenticate_message; no credential value. +e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b:bindings/python/tests/test_identity_authoring.py:generic-api-key:5 +# Historical rebase of the reviewed public Git revision in live partial +# consumer evidence; preserve independent AP070 evidence source unchanged. +e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b:demos/google-employee-delegation/evidence/live-partial-consumer-2026-10-25.md:generic-api-key:8 +# Historical rebase of the reviewed public Git base revision in the +# independent AP070 demo lock file; not a credential. +e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b:demos/google-employee-delegation/versions.lock.json:generic-api-key:4 diff --git a/Cargo.lock b/Cargo.lock index 255f50963..11aaf3264 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2281,12 +2281,6 @@ dependencies = [ "tokio", ] -[[package]] -name = "base16ct" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" - [[package]] name = "base16ct" version = "1.0.0" @@ -2606,6 +2600,12 @@ version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" +[[package]] +name = "cpubits" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae" + [[package]] name = "cpufeatures" version = "0.2.17" @@ -2656,12 +2656,16 @@ checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17" [[package]] name = "crypto-bigint" -version = "0.5.5" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +checksum = "9c035cb64cba03dad2fb921f3e218785e8cf9a41790da5eb3a1400f62fa2be11" dependencies = [ - "generic-array", - "rand_core 0.6.4", + "cpubits", + "ctutils", + "getrandom 0.4.3", + "hybrid-array", + "num-traits", + "rand_core 0.10.1", "subtle", "zeroize", ] @@ -2682,6 +2686,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" dependencies = [ + "getrandom 0.4.3", "hybrid-array", "rand_core 0.10.1", ] @@ -2697,11 +2702,12 @@ dependencies = [ [[package]] name = "ctutils" -version = "0.4.2" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e" +checksum = "a2376ffd6f96d8a9db59875b4b6b0237d6900b5baf64279714e05493ce64828a" dependencies = [ "cmov", + "subtle", ] [[package]] @@ -2868,7 +2874,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer 0.10.4", - "const-oid 0.9.6", "crypto-common 0.1.7", "subtle", ] @@ -2939,16 +2944,17 @@ checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" [[package]] name = "ecdsa" -version = "0.16.9" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0" dependencies = [ - "der 0.7.10", - "digest 0.10.7", + "der 0.8.1", + "digest 0.11.3", "elliptic-curve", "rfc6979", - "signature 2.2.0", - "spki 0.7.3", + "signature 3.0.0", + "spki 0.8.0", + "zeroize", ] [[package]] @@ -3011,18 +3017,19 @@ checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d" [[package]] name = "elliptic-curve" -version = "0.13.8" +version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +checksum = "900f37e7e18d74a2347389af6cd69e3a30d5cc9e697f40004865679aa75e9c7c" dependencies = [ - "base16ct 0.2.0", + "base16ct", "crypto-bigint", - "digest 0.10.7", + "crypto-common 0.2.2", + "digest 0.11.3", "ff", - "generic-array", "group", - "pkcs8 0.10.2", - "rand_core 0.6.4", + "hybrid-array", + "pkcs8 0.11.0", + "rand_core 0.10.1", "sec1", "subtle", "zeroize", @@ -3081,11 +3088,11 @@ checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" [[package]] name = "ff" -version = "0.13.1" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f" dependencies = [ - "rand_core 0.6.4", + "rand_core 0.10.1", "subtle", ] @@ -3287,7 +3294,6 @@ checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", - "zeroize", ] [[package]] @@ -3355,12 +3361,12 @@ dependencies = [ [[package]] name = "group" -version = "0.13.0" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4" dependencies = [ "ff", - "rand_core 0.6.4", + "rand_core 0.10.1", "subtle", ] @@ -3592,7 +3598,9 @@ version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "818356c5132c1fede50f837ca96afbe78ff42413047f4abb886217845e1b6c8c" dependencies = [ + "subtle", "typenum", + "zeroize", ] [[package]] @@ -4743,14 +4751,15 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" [[package]] name = "p256" -version = "0.13.2" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" +checksum = "d2c9239b2dbc807adbbe147e8cf72ea7450c3a0aabe62cb8e75ff4ec22e1f72a" dependencies = [ "ecdsa", "elliptic-curve", + "primefield", "primeorder", - "sha2 0.10.9", + "sha2 0.11.0", ] [[package]] @@ -5052,13 +5061,31 @@ dependencies = [ "num-traits", ] +[[package]] +name = "primefield" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c555a6e4eb7d4e158fcb028c835c3b8642206ddc279b5c6b202ef9a8bdb592f4" +dependencies = [ + "crypto-bigint", + "crypto-common 0.2.2", + "ff", + "rand_core 0.10.1", + "subtle", + "zeroize", +] + [[package]] name = "primeorder" -version = "0.13.6" +version = "0.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" +checksum = "5c9f42978c78a00e3d68f69fc03e57a234debae69da4020a4fb588fcdcd07b06" dependencies = [ "elliptic-curve", + "once_cell", + "primefield", + "serdect", + "wnaf", ] [[package]] @@ -5450,12 +5477,12 @@ checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7" [[package]] name = "rfc6979" -version = "0.4.0" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +checksum = "b4a459cddafb3fe76b31fd8f1108007566c40301feb64dc7b54656eb7388172b" dependencies = [ - "hmac 0.12.1", - "subtle", + "crypto-bigint", + "hmac 0.13.0", ] [[package]] @@ -5531,9 +5558,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.45" +version = "0.23.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" dependencies = [ "aws-lc-rs", "log", @@ -5596,9 +5623,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" [[package]] name = "rustls-webpki" -version = "0.103.15" +version = "0.103.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" +checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281" dependencies = [ "aws-lc-rs", "ring", @@ -5703,14 +5730,14 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" [[package]] name = "sec1" -version = "0.7.3" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d" dependencies = [ - "base16ct 0.2.0", - "der 0.7.10", - "generic-array", - "pkcs8 0.10.2", + "base16ct", + "ctutils", + "der 0.8.1", + "hybrid-array", "subtle", "zeroize", ] @@ -5885,7 +5912,7 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66cf8fedced2fcf12406bcb34223dffb92eaf34908ede12fed414c82b7f00b3e" dependencies = [ - "base16ct 1.0.0", + "base16ct", "serde", ] @@ -5948,7 +5975,6 @@ version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" dependencies = [ - "digest 0.10.7", "rand_core 0.6.4", ] @@ -5958,6 +5984,7 @@ version = "3.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5" dependencies = [ + "digest 0.11.3", "rand_core 0.10.1", ] @@ -6340,9 +6367,9 @@ dependencies = [ [[package]] name = "tokio" -version = "1.53.1" +version = "1.54.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed" +checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3" dependencies = [ "bytes", "libc", @@ -6969,18 +6996,18 @@ dependencies = [ [[package]] name = "webpki-root-certs" -version = "1.0.9" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b" +checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a" dependencies = [ "rustls-pki-types", ] [[package]] name = "webpki-roots" -version = "1.0.9" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" +checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171" dependencies = [ "rustls-pki-types", ] @@ -7340,6 +7367,18 @@ dependencies = [ "windows-core", ] +[[package]] +name = "wnaf" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "795ca18b3fdb5e62bf982199278341ddcf7ebf7d32e25e212ad05d496e95f6fa" +dependencies = [ + "ff", + "group", + "hybrid-array", + "primefield", +] + [[package]] name = "writeable" version = "0.6.3" @@ -7579,27 +7618,27 @@ checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" [[package]] name = "zstd" -version = "0.13.3" +version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +checksum = "db3ae9bf90af6e40197bef767eeefc46ad6397420fe873830bd85e5fbbfb3c70" dependencies = [ "zstd-safe", ] [[package]] name = "zstd-safe" -version = "7.2.4" +version = "8.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +checksum = "ded520f16b29e1a9b771c722221b2b0a0398c2316d9bb3c42b458a5414d7434b" dependencies = [ "zstd-sys", ] [[package]] name = "zstd-sys" -version = "2.0.16+zstd.1.5.7" +version = "2.1.2+zstd.1.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +checksum = "481ada9c543b2323cbb7bbdbb5249177fbf0188ed959ed2c15e4b22421c84ed3" dependencies = [ "cc", "pkg-config", diff --git a/Cargo.toml b/Cargo.toml index 2ad2eec94..8f9fed174 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -261,7 +261,7 @@ reqwest = { version = "0.13.4", default-features = false, features = ["blocking" postgres = { version = "0.19.12", default-features = false } r2d2 = "0.8.10" r2d2_postgres = "0.18.2" -rustls = { version = "0.23.45", default-features = false, features = ["ring", "std", "tls12"] } +rustls = { version = "0.23.46", default-features = false, features = ["ring", "std", "tls12"] } rustix = { version = "1.1.4", default-features = false, features = ["fs", "net", "process"] } seccompiler = "0.5.0" zeroize = { version = "1.9.0", features = ["derive"] } @@ -270,7 +270,7 @@ rmcp = { version = "1.8.0", default-features = false, features = ["server"] } serde_json_canonicalizer = "0.3.2" tempfile = "3.27.0" tar = { version = "0.4.44", default-features = false } -tokio = { version = "1.48.0", features = ["fs", "io-util", "macros", "net", "rt-multi-thread", "signal", "sync", "time"] } +tokio = { version = "1.53.3", features = ["fs", "io-util", "macros", "net", "rt-multi-thread", "signal", "sync", "time"] } tokio-postgres = { version = "0.7.18", default-features = false, features = ["runtime"] } tokio-postgres-rustls = { version = "0.14.0", default-features = false, features = ["ring"] } tower = { version = "0.5.3", features = ["util"] } @@ -285,7 +285,7 @@ bs58 = { version = "0.5.1", default-features = false, features = ["alloc"] } clap = { version = "4.5.60", features = ["derive"] } ed25519-dalek = { version = "2.2.0", default-features = false, features = ["alloc", "zeroize"] } hex = "0.4.3" -p256 = { version = "0.13.2", default-features = false, features = ["alloc", "ecdsa", "pkcs8"] } +p256 = { version = "0.14.0", default-features = false, features = ["alloc", "ecdsa", "pkcs8"] } pyo3 = { version = "0.29.0", features = ["abi3-py39"] } proptest = "1.9.0" proc-macro2 = { version = "1.0.107", default-features = false, features = ["span-locations"] } @@ -299,15 +299,15 @@ syn = { version = "2.0.119", default-features = false, features = ["full", "pars subtle = { version = "2.6.1", default-features = false } minicbor = { version = "2.3.0", default-features = false, features = ["alloc"] } rustls-pki-types = { version = "1.15.1", default-features = false, features = ["alloc"] } -rustls-webpki = { version = "0.103.13", default-features = false, features = ["alloc", "ring"] } +rustls-webpki = { version = "0.103.16", default-features = false, features = ["alloc", "ring"] } ring = { version = "0.17.14", default-features = false } x509-parser = { version = "0.18.1", default-features = false } thiserror = { version = "2.0.19", default-features = false } unicode-normalization = "0.1.25" uuid = { version = "1.24.0", default-features = false, features = ["serde"] } -webpki-roots = "1.0.9" +webpki-roots = "1.0.10" wasm-bindgen = "=0.2.118" -zstd = { version = "0.13.3", default-features = false } +zstd = { version = "0.14.3", default-features = false } [workspace.lints.rust] unsafe_code = "forbid" diff --git a/bindings/customer-journey-matrix-v1.json b/bindings/customer-journey-matrix-v1.json index 4dac27785..1d7d14213 100644 --- a/bindings/customer-journey-matrix-v1.json +++ b/bindings/customer-journey-matrix-v1.json @@ -9,7 +9,7 @@ "typescriptEntryPoints": 10, "typescriptPublicSymbols": 163, "pythonModules": 15, - "pythonPublicSymbols": 189, + "pythonPublicSymbols": 190, "maintainedTypescriptRecipes": 2, "maintainedPythonRecipes": 2 }, diff --git a/core/adapters/auths-webauthn/src/lib.rs b/core/adapters/auths-webauthn/src/lib.rs index fff51ea09..860cafed1 100644 --- a/core/adapters/auths-webauthn/src/lib.rs +++ b/core/adapters/auths-webauthn/src/lib.rs @@ -728,7 +728,7 @@ mod tests { #[test] fn ceremony_message_binds_exact_auths_preimage() { let signing_key = SigningKey::from_bytes((&[7u8; 32]).into()).unwrap(); - let point = signing_key.verifying_key().to_encoded_point(true); + let point = signing_key.verifying_key().to_sec1_point(true); let credential = WebAuthnCredential::new( b"credential-1".to_vec(), &P256Sha256Suite::new().unwrap(), diff --git a/core/crates/auths-signature-core/src/lib.rs b/core/crates/auths-signature-core/src/lib.rs index 9b78b735b..a1b6d4edb 100644 --- a/core/crates/auths-signature-core/src/lib.rs +++ b/core/crates/auths-signature-core/src/lib.rs @@ -144,7 +144,7 @@ pub fn verify_p256_sha256( let key = decode_p256_key(verification_key)?; let signature = P256Signature::from_slice(signature).map_err(|_| P256Error::InvalidSignatureEncoding)?; - if signature.normalize_s().is_some() { + if signature.normalize_s() != signature { return Err(P256Error::VerificationFailed); } key.verify(message, &signature) @@ -158,7 +158,7 @@ mod tests { use super::*; use alloc::{vec, vec::Vec}; use ed25519_dalek::{Signer as _, SigningKey}; - use p256::ecdsa::SigningKey as P256SigningKey; + use p256::ecdsa::{SigningKey as P256SigningKey, signature::Signer as _}; #[test] fn strict_verifier_binds_every_byte_and_classifies_shapes() { @@ -195,7 +195,7 @@ mod tests { scalar[31] = 7; let key = P256SigningKey::from_bytes((&scalar).into()).unwrap(); let mut compact = vec![0x05]; - compact.extend_from_slice(&key.verifying_key().to_encoded_point(true).as_bytes()[1..]); + compact.extend_from_slice(&key.verifying_key().to_sec1_point(true).as_bytes()[1..]); if P256Key::from_sec1_bytes(&compact).unwrap() == *key.verifying_key() { key } else { @@ -213,18 +213,10 @@ mod tests { fn p256_accepts_only_the_compressed_encoding_of_a_point() { let key = compact_decodable_p256_key(); let signature: P256Signature = key.sign(P256_MESSAGE); - let signature = signature.normalize_s().unwrap_or(signature); + let signature = signature.normalize_s(); let signature_bytes = signature.to_bytes(); - let compressed = key - .verifying_key() - .to_encoded_point(true) - .as_bytes() - .to_vec(); - let uncompressed = key - .verifying_key() - .to_encoded_point(false) - .as_bytes() - .to_vec(); + let compressed = key.verifying_key().to_sec1_point(true).as_bytes().to_vec(); + let uncompressed = key.verifying_key().to_sec1_point(false).as_bytes().to_vec(); let x = &uncompressed[1..33]; let x_and_y = &uncompressed[1..]; let compact = with_tag(0x05, x); diff --git a/core/testkit/auths-testkit/src/lib.rs b/core/testkit/auths-testkit/src/lib.rs index c89a229b7..6e746fda0 100644 --- a/core/testkit/auths-testkit/src/lib.rs +++ b/core/testkit/auths-testkit/src/lib.rs @@ -55,6 +55,7 @@ use base64ct::{Base64UrlUnpadded, Encoding as _}; use ed25519_dalek::{Signer as _, SigningKey as Ed25519SigningKey, pkcs8::EncodePrivateKey as _}; use p256::ecdsa::{ Signature as P256Signature, SigningKey as P256SigningKey, VerifyingKey as P256VerifyingKey, + signature::Signer as _, }; use rcgen::{ BasicConstraints, CertificateParams, ExtendedKeyUsagePurpose, IsCa, KeyPair, KeyUsagePurpose, @@ -248,7 +249,7 @@ impl Identity { let mut scalar = [0; 32]; scalar[31] = seed.max(1); let key = P256SigningKey::from_bytes((&scalar).into()).expect("fixed P-256 scalar"); - let public_key = key.verifying_key().to_encoded_point(true); + let public_key = key.verifying_key().to_sec1_point(true); let raw = RawKeyDescriptor::new(RawKeyType::P256, public_key.as_bytes().to_vec()) .expect("fixed P-256 key"); let principal = raw.principal().expect("derived principal"); @@ -470,11 +471,7 @@ impl Identity { TestKey::Ed25519(key) => key.sign(preimage).to_bytes().to_vec(), TestKey::P256(key) => { let signature: P256Signature = key.sign(preimage); - signature - .normalize_s() - .unwrap_or(signature) - .to_bytes() - .to_vec() + signature.normalize_s().to_bytes().to_vec() } }; let bytes = if let PrincipalKind::WebAuthn { evidence, .. } = &self.principal_kind { @@ -482,11 +479,7 @@ impl Identity { panic!("WebAuthn fixture requires P-256"); }; let signature: P256Signature = key.sign(&evidence.signature_message()); - signature - .normalize_s() - .unwrap_or(signature) - .to_bytes() - .to_vec() + signature.normalize_s().to_bytes().to_vec() } else { bytes }; @@ -498,7 +491,7 @@ impl Identity { panic!("high-S fixture requires P-256"); }; let signature: P256Signature = key.sign(preimage); - let low = signature.normalize_s().unwrap_or(signature); + let low = signature.normalize_s(); let (r, s) = low.split_scalars(); let high = P256Signature::from_scalars(r.to_bytes(), (-s).to_bytes()).expect("high-S signature"); @@ -602,11 +595,7 @@ fn p256_compact_key(seed: u8) -> (P256SigningKey, Vec) { let mut scalar = [0; 32]; scalar[31] = seed.max(1); let key = P256SigningKey::from_bytes((&scalar).into()).expect("fixed P-256 scalar"); - let mut compact = key - .verifying_key() - .to_encoded_point(true) - .as_bytes() - .to_vec(); + let mut compact = key.verifying_key().to_sec1_point(true).as_bytes().to_vec(); compact[0] = 0x05; let decoded = P256VerifyingKey::from_sec1_bytes(&compact).expect("x-coordinate on the curve"); let key = if decoded == *key.verifying_key() { @@ -626,7 +615,7 @@ fn webauthn_credential(seed: u8) -> (P256SigningKey, WebAuthnCredential) { let mut scalar = [0; 32]; scalar[31] = seed.max(1); let key = P256SigningKey::from_bytes((&scalar).into()).expect("fixed WebAuthn scalar"); - let point = key.verifying_key().to_encoded_point(true); + let point = key.verifying_key().to_sec1_point(true); let credential = WebAuthnCredential::new( vec![seed; 16], &P256Sha256Suite::new().expect("P-256 suite"), diff --git a/product/integrations/auths-custody-aws-kms/src/lib.rs b/product/integrations/auths-custody-aws-kms/src/lib.rs index 389779425..1585f47b1 100644 --- a/product/integrations/auths-custody-aws-kms/src/lib.rs +++ b/product/integrations/auths-custody-aws-kms/src/lib.rs @@ -7,7 +7,7 @@ use auths_custody::{ CustodyProviderError, ExternalSigner, KeyLifecycleState, KeyVersionId, P256SignatureVerifier, RawSigningResponse, SigningIntent, UntrustedSigningResponse, }; -use p256::{EncodedPoint, pkcs8::DecodePublicKey as _}; +use p256::{Sec1Point, pkcs8::DecodePublicKey as _}; use sha2::{Digest as _, Sha256}; const ADAPTER_ID: &str = "aws-kms-p256-v1"; @@ -231,7 +231,7 @@ impl AwsKmsP256Adapter { .map_err(AwsKmsConfigurationError::Provider)?; let key = p256::PublicKey::from_public_key_der(&public_key_der) .map_err(|_| AwsKmsConfigurationError::InvalidPublicKey)?; - let sec1 = EncodedPoint::from(key).compress(); + let sec1 = Sec1Point::from(key).compress(); let identity = CustodyIdentity::p256(form, sec1.as_bytes()) .map_err(|_| AwsKmsConfigurationError::InvalidPublicKey)?; let key_version = key_version(key_arn, &public_key_der)?; @@ -407,7 +407,7 @@ mod tests { } fn get_public_key(&self, _key_arn: &str) -> Result, AwsKmsFailure> { - let encoded = self.key.verifying_key().to_encoded_point(false); + let encoded = self.key.verifying_key().to_sec1_point(false); Ok(p256::PublicKey::from_sec1_bytes(encoded.as_bytes()) .unwrap() .to_public_key_der() @@ -424,7 +424,7 @@ mod tests { _message_type: AwsKmsMessageType, ) -> Result { let signature: Signature = self.key.sign(message); - let signature = signature.normalize_s().unwrap_or(signature); + let signature = signature.normalize_s(); Ok(AwsKmsSignOutput { key_arn: self.arn.clone(), algorithm, diff --git a/product/integrations/auths-custody-pkcs11/src/lib.rs b/product/integrations/auths-custody-pkcs11/src/lib.rs index a6afb2bfe..46e5a9a09 100644 --- a/product/integrations/auths-custody-pkcs11/src/lib.rs +++ b/product/integrations/auths-custody-pkcs11/src/lib.rs @@ -411,7 +411,7 @@ mod tests { public_key_sec1: self .key .verifying_key() - .to_encoded_point(true) + .to_sec1_point(true) .as_bytes() .to_vec(), p256: true, @@ -427,7 +427,7 @@ mod tests { message: &[u8], ) -> Result { let signature: Signature = self.key.sign(message); - let signature = signature.normalize_s().unwrap_or(signature); + let signature = signature.normalize_s(); Ok(Pkcs11SignOutput { signature: signature.to_bytes().to_vec(), }) diff --git a/product/integrations/auths-custody/src/conformance.rs b/product/integrations/auths-custody/src/conformance.rs index 2532b6242..f62007c3d 100644 --- a/product/integrations/auths-custody/src/conformance.rs +++ b/product/integrations/auths-custody/src/conformance.rs @@ -143,7 +143,7 @@ impl ConformanceSigner { ) -> Self { let key = SigningKey::from_slice(&KEY).expect("fixed P-256 key"); let identity = - CustodyIdentity::p256(form, key.verifying_key().to_encoded_point(true).as_bytes()) + CustodyIdentity::p256(form, key.verifying_key().to_sec1_point(true).as_bytes()) .expect("fixed identity"); let descriptor = CustodyDescriptor::new( kind, @@ -165,7 +165,7 @@ impl ConformanceSigner { fn signature(key: &SigningKey, message: &[u8]) -> Signature { let signature: Signature = key.sign(message); - signature.normalize_s().unwrap_or(signature) + signature.normalize_s() } } diff --git a/product/integrations/auths-custody/src/key.rs b/product/integrations/auths-custody/src/key.rs index 119888a0a..682692b26 100644 --- a/product/integrations/auths-custody/src/key.rs +++ b/product/integrations/auths-custody/src/key.rs @@ -20,7 +20,7 @@ use auths_model::{ }; use auths_multikey::{Multikey, MultikeyType}; use auths_raw_key::{RAW_KEY_MEDIA_TYPE, RAW_KEY_V1, RawKeyDescriptor, RawKeyType}; -use p256::{EncodedPoint, PublicKey}; +use p256::{PublicKey, Sec1Point}; const P256_SUITE: &str = "p256-sha256-v1"; @@ -53,7 +53,7 @@ impl CustodyIdentity { /// valid P-256 point or cannot be represented under `form`. pub fn p256(form: CustodyPrincipalForm, sec1: &[u8]) -> Result { let key = PublicKey::from_sec1_bytes(sec1).map_err(|_| CustodyError::EvidenceMismatch)?; - let public_key = EncodedPoint::from(key).compress().as_bytes().to_vec(); + let public_key = Sec1Point::from(key).compress().as_bytes().to_vec(); let invalid = |_| CustodyError::EvidenceMismatch; let suite = SignatureSuiteId::parse(P256_SUITE).map_err(invalid)?; let (principal, method, verification, evidence_type, media_type, bytes) = match form { diff --git a/product/integrations/auths-custody/src/lib.rs b/product/integrations/auths-custody/src/lib.rs index 60af2209a..e304c92ac 100644 --- a/product/integrations/auths-custody/src/lib.rs +++ b/product/integrations/auths-custody/src/lib.rs @@ -604,7 +604,7 @@ fn canonical_signature( P256Signature::from_der(&bytes) } .map_err(|_| CustodyError::MalformedSignature)?; - if signature.normalize_s().is_some() { + if signature.normalize_s() != signature { return Err(CustodyError::NonCanonicalSignature); } SignatureBytes::new(signature.to_bytes().to_vec()).map_err(|_| CustodyError::MalformedSignature) @@ -748,7 +748,7 @@ mod tests { request: &SigningIntent<'_>, ) -> Result { let signature: P256Signature = self.key.sign(request.signing_preimage()); - let signature = signature.normalize_s().unwrap_or(signature); + let signature = signature.normalize_s(); let mut transaction_digest = *request.transaction_digest(); if self.transaction_mismatch { transaction_digest[0] ^= 1; @@ -798,7 +798,7 @@ mod tests { P256SignatureVerifier, ) { let key = SigningKey::from_slice(&[7; 32]).unwrap(); - let verification = key.verifying_key().to_encoded_point(true); + let verification = key.verifying_key().to_sec1_point(true); let principal = PrincipalId::parse("raw:p256-test").unwrap(); let signature = SignatureDescriptor::new( PrincipalMethodId::parse("raw-key-v1").unwrap(), @@ -955,7 +955,7 @@ mod tests { let other = SigningKey::from_slice(&[5; 32]).unwrap(); let identity = CustodyIdentity::p256( CustodyPrincipalForm::RawKeyV1, - other.verifying_key().to_encoded_point(false).as_bytes(), + other.verifying_key().to_sec1_point(false).as_bytes(), ) .unwrap(); assert!(matches!( diff --git a/product/integrations/auths-git-signing/src/custody_tests.rs b/product/integrations/auths-git-signing/src/custody_tests.rs index 5fc8a0f09..c8b344b75 100644 --- a/product/integrations/auths-git-signing/src/custody_tests.rs +++ b/product/integrations/auths-git-signing/src/custody_tests.rs @@ -139,7 +139,7 @@ impl Pkcs11Api for Token { public_key_sec1: self .0 .verifying_key() - .to_encoded_point(true) + .to_sec1_point(true) .as_bytes() .to_vec(), p256: true, @@ -156,7 +156,7 @@ impl Pkcs11Api for Token { ) -> Result { let signature: Signature = self.0.sign(message); Ok(Pkcs11SignOutput { - signature: signature.normalize_s().unwrap_or(signature).to_vec(), + signature: signature.normalize_s().to_vec(), }) } } diff --git a/product/integrations/auths-git-signing/src/workload.rs b/product/integrations/auths-git-signing/src/workload.rs index 77c240dcb..6653f4cbd 100644 --- a/product/integrations/auths-git-signing/src/workload.rs +++ b/product/integrations/auths-git-signing/src/workload.rs @@ -263,7 +263,7 @@ pub const WORKLOAD_CUSTODY: &str = "workload"; /// encoding Fulcio and Rekor take. fn sign_p256(key: &P256SigningKey, message: &[u8]) -> P256Signature { let signature: P256Signature = p256::ecdsa::signature::Signer::sign(key, message); - signature.normalize_s().unwrap_or(signature) + signature.normalize_s() } fn sign_ed25519(key: &SigningKey, preimage: &[u8]) -> Result { @@ -443,7 +443,7 @@ impl<'c> SigstoreKeylessSigner<'c> { ) -> Result { let key = ephemeral_p256_key()?; let mut spki = P256_SPKI_PREFIX.to_vec(); - spki.extend_from_slice(key.verifying_key().to_encoded_point(false).as_bytes()); + spki.extend_from_slice(key.verifying_key().to_sec1_point(false).as_bytes()); let token = tokens.token(SIGSTORE_AUDIENCE)?; let identity = TokenIdentity::read(token.as_bytes(), SIGSTORE_AUDIENCE)?; let proof = sign_p256(&key, identity.subject.as_bytes()).to_der(); diff --git a/product/integrations/auths-git-signing/src/workload_fakes.rs b/product/integrations/auths-git-signing/src/workload_fakes.rs index 5f528706d..5bf893f0f 100644 --- a/product/integrations/auths-git-signing/src/workload_fakes.rs +++ b/product/integrations/auths-git-signing/src/workload_fakes.rs @@ -10,7 +10,7 @@ use crate::workload::{ use auths_oidc_workload::jws::CompactJws; use auths_sigstore_keyless::merkle::leaf_hash; use base64ct::{Base64, Base64UrlUnpadded, Encoding as _}; -use ed25519_dalek::SigningKey; +use ed25519_dalek::{Signer as _, SigningKey}; use p256::ecdsa::signature::{Signer as _, Verifier as _}; use p256::ecdsa::{Signature as P256Signature, SigningKey as P256SigningKey, VerifyingKey}; use rcgen::{ @@ -213,7 +213,7 @@ impl FakeLogKey { } Self::P256(key) => { let mut spki = P256_SPKI_PREFIX.to_vec(); - spki.extend_from_slice(key.verifying_key().to_encoded_point(false).as_bytes()); + spki.extend_from_slice(key.verifying_key().to_sec1_point(false).as_bytes()); spki } } @@ -226,12 +226,12 @@ impl FakeLogKey { .to_vec(), Self::P256(key) => { let signature: P256Signature = key.sign(message); - let low = signature.normalize_s().unwrap_or(signature); + let low = signature.normalize_s(); let (r, s) = low.split_scalars(); let high = P256Signature::from_scalars(r.to_bytes(), (-*s).to_bytes()) .expect("high-S pair"); assert!( - high.normalize_s().is_some(), + high.normalize_s() != high, "the emitted signature is high-S" ); high.to_der().as_bytes().to_vec() @@ -404,7 +404,7 @@ impl SigstoreClient for FakeSigstore { ), ]; set_validity(&mut params, self.leaf_window.0, self.leaf_window.1); - let point = key.to_encoded_point(false).as_bytes().to_vec(); + let point = key.to_sec1_point(false).as_bytes().to_vec(); let leaf = params .signed_by(&RawP256(point), &self.ca, &self.ca_key) .map_err(|_| refuse("leaf"))?; diff --git a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs index 95374dd6f..c3eb1f66d 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs @@ -132,7 +132,12 @@ async fn installation_histories( &*credentials, |_| panic!("unapproved draft must not run"), draft.connection_id(), - SecretBytes::new(b"rk_test_unapproved".to_vec()).expect("secret") + SecretBytes::new( + concat!("rk_test_", "synthetic_unapproved_fixture") + .as_bytes() + .to_vec() + ) + .expect("secret") ) .await .err(), diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 22756567a..773cc32b1 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -1464,12 +1464,7 @@ mod mock_custody { Ok(AwsKmsSignOutput { key_arn: ARN.to_owned(), algorithm, - signature_der: signature - .normalize_s() - .unwrap_or(signature) - .to_der() - .as_bytes() - .to_vec(), + signature_der: signature.normalize_s().to_der().as_bytes().to_vec(), }) } } @@ -1486,7 +1481,7 @@ mod mock_custody { public_key_sec1: self .0 .verifying_key() - .to_encoded_point(false) + .to_sec1_point(false) .as_bytes() .to_vec(), p256: true, @@ -1503,7 +1498,7 @@ mod mock_custody { ) -> Result { let signature: Signature = self.0.sign(message); Ok(Pkcs11SignOutput { - signature: signature.normalize_s().unwrap_or(signature).to_vec(), + signature: signature.normalize_s().to_vec(), }) } } diff --git a/product/runtime/auths-gateway/src/pending_vectors/keys.rs b/product/runtime/auths-gateway/src/pending_vectors/keys.rs index 7adf19291..e3f3b7e1e 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/keys.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/keys.rs @@ -86,17 +86,13 @@ fn keys() -> Vec { .to_vec(), }; let p256 = |id, seed| { - use p256::elliptic_curve::sec1::ToEncodedPoint as _; + use p256::elliptic_curve::sec1::ToSec1Point as _; let secret = p256::SecretKey::from_slice(&[seed; 32]).expect("fixed scalar"); Key { id, kind: RawKeyType::P256, seed, - public: secret - .public_key() - .to_encoded_point(true) - .as_bytes() - .to_vec(), + public: secret.public_key().to_sec1_point(true).as_bytes().to_vec(), } }; vec![ From a64eacd4a591f8736570e9cf8e66bab4a887f645 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 02:01:53 +0000 Subject: [PATCH 073/136] test(gateway): prove native dependency and expiry ordering on both stores --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-dependency-order-file.json | 199 +++++ .../native-dependency-order-postgres.json | 199 +++++ compliance.toml | 2 + docs/plans/0074-implementation-status.md | 99 ++- ...ound-effects-and-recovery-state-machine.md | 18 + .../qualification/aeneas/source-closure.json | 6 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/harness/authoring.rs | 16 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../src/native_dependency_tests.rs | 697 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 44 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 12 +- release/semantic-freeze.json | 22 +- 15 files changed, 1290 insertions(+), 33 deletions(-) create mode 100644 bindings/fixtures/gateway/native-dependency-order-file.json create mode 100644 bindings/fixtures/gateway/native-dependency-order-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_dependency_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index ba6e25ddc..25060ff7f 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -45,6 +45,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_crash_tests::native_file_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-dependency-order-file.json b/bindings/fixtures/gateway/native-dependency-order-file.json new file mode 100644 index 000000000..ea43302b6 --- /dev/null +++ b/bindings/fixtures/gateway/native-dependency-order-file.json @@ -0,0 +1,199 @@ +{ + "schema": "auths.native-dependency-order/1", + "adapter": "file", + "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", + "excluded": [ + "observer-evidence aging and threshold-selection changes", + "mutation/disclosure races", + "fixed-window budget contention", + "production commissioning", + "hostile OS containment", + "power loss and whole-store rollback" + ], + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "revoke", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "configuration", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "configuration", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-dependency-order-postgres.json b/bindings/fixtures/gateway/native-dependency-order-postgres.json new file mode 100644 index 000000000..6fb8fc7e1 --- /dev/null +++ b/bindings/fixtures/gateway/native-dependency-order-postgres.json @@ -0,0 +1,199 @@ +{ + "schema": "auths.native-dependency-order/1", + "adapter": "postgres", + "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", + "excluded": [ + "observer-evidence aging and threshold-selection changes", + "mutation/disclosure races", + "fixed-window budget contention", + "production commissioning", + "hostile OS containment", + "power loss and whole-store rollback" + ], + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "revoke", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "configuration", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "configuration", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 16f43f20d..d924888ea 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1806,6 +1806,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_process_tests.rs#postgres_native_process_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_crash_tests.rs#native_file_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_crash_tests.rs#postgres_native_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_dependency_tests.rs#native_file_dependency_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d5e2897c3..3fba12b74 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1863,6 +1863,101 @@ closure regeneration passed after that correction (one artifact-generation test) bindings 125, public SDK contract 138 and public surface 395 for the combined source/inventory changes. It does not certify new formal or provider claims. +## Combined publication observation + +- Pushed non-force to origin/codex/effect-recovery-foundation at exact head + `af01d3769a2d6a1b90820a506a2f797487ebbe4a`; GitHub confirms draft PR213 + remains open at that head: https://github.com/auths-dev/auths-proof/pull/213. + The push includes native capacity/crash evidence and both substantial CI repair + batches, demos, examples/scaffold, inventories and regenerated source identities. +- Exact-head hosted runs were confirmed live: main run 40799196205, + Python run 40799196247, TypeScript run 40799196258, TLS PostgreSQL run 40799196262, + SDK recipes run 40799196408, qualification run 40799196229, + operator package run 40799196193, Airtable run 40799196227, Stripe run 40799196249 and + isolation run 40799196259. Pending jobs are not passes; skipped custody/live-provider + workflows do not establish provider qualification. The CI agent continues + holistic triage with backoff and must collect all actual roots before a batch. +- The PR description reports this work as an incomplete foundation and retains + every remaining acceptance/formal/installed/operational gate. No merge or + deployment was requested or performed. Subsequent implementation/checkpoint + commits need their own final exact-head verification before goal closure. + +## Native dependency ordering and expiry checkpoint + +- `native_dependency_tests.rs` adds independent native worker/operator OS + processes over the maintained file and TLS PostgreSQL adapters. Both handles + finish installation/review before contention begins. A transparent test-only + store wrapper schedules the unchanged native entry decision against actual + adapter fences; it cannot construct a permit or select a native transition. +- Connection revocation and exact configuration activation each run in both + orders: a dependency change committed first prevents a grant/provider call; + an entry decision ordered first may exercise its one grant. The grant fence + explicitly contains the connection and effect-configuration records, each + physically distinct from the attempted effect. The competing writer is a + separately spawned operator using the maintained connection CAS or reviewed + configuration activation, not a fabricated record snapshot. +- Four additional schedules hold the real connection writer fence while the + worker waits to grant entry. The maintained test clock advances without + modifying signed proof/action/approval bytes. Exact human approval and native + resource-authority expiry are tested independently, each with a still-valid + positive control. Expiry blocks entry; the positive controls record the new + grant time after waiting. Admission time remains the original signed/event + time. Existing allocations and the full call/byte charge remain unchanged. +- Native public history is inspected through a reopened handle and must agree + with the actual result while preserving private journal bytes. Real HTTP + request counts distinguish admitted entry from blocked attempts. These cases + do not establish observer-evidence aging, threshold-selection changes, + mutation/disclosure dependency races, fixed-window budget contention, + power-loss or hostile-process isolation. A12/A13 remain partial. + +- Required fixture generation passed the two adapter cases plus the no-input + peer helper (three tests, 3.58 seconds). After regenerating the integrated + gateway source closure, a rebuilt executable verified both dependency files, + both existing process-capacity files, both seven-case crash files, all three + no-input peer helpers and the closure without update mode: ten tests passed + in 7.62 seconds. The shared-helper default authoring remains byte-identical + to the previous capacity/crash fixtures. Strict gateway library/test clippy + passed without new suppressions. The dedicated canonical TLS PostgreSQL + fixture used port55451, verified CA/server name and synchronous commits. + The dedicated containers, network and volume were removed after verification. + These are local artifact-construction/regression results; fresh hosted + verification remains required. + +## Additional holistic CI repairs + +- Integrated isolated repair `ae3154f3` as `050fa219`: patched dependency + requirements/lockfile and corresponding vetted crypto API callers, preserved + high-S rejection and all canonical signature fixtures, regenerated the SDK + baseline for the existing GatewayReserved export, corrected the synthetic + credential marker and documented fingerprint-specific historical public-data + exceptions. No broad secret-scan allowlist or dependency advisory exception + was added. +- Hosted macOS setup initially failed DNS; its one exact-head job retry exposed + a separate artifact-handoff bug. Consumers now download immutable IDs emitted + by their actual producers, including unique per-platform matrix outputs. + Missing producer output fails closed. No consumer guesses its producer's + attempt number, and no head, platform, source-free or live approval requirement + is weakened. The repair spans Python, TypeScript, qualification and release + workflows as one batch. +- Agent-local reproductions passed strict workspace check/clippy, dependency + policy, 1,597 unchanged wire vectors, conformance, 68 crypto/custody tests, + staged/full-history secret scans and workflow lint. Those results diagnose + the prior hosted failures; they are not successful hosted evidence for the + combined new head. The previous head's formal translation subsequently failed + and is under separate investigation before the next combined publication. + Its inventory and natural model still describe the superseded Attempting + state. The repair must model current protocol/revision/entry/ACK facts, + distinguish late source-bound response/recipient evidence from linked provider + observation, and retain strict provenance and no-blind-retry invariants. +- The existing AP070 reference and paused AP073 worktree remain untouched. + +- Release freeze 396 advances only the generator-reported changed subjects: + formal source closure104, identity protocol142, external custody6, public SDK + contract139 and public surface396. The gateway semantic closure includes the + new tests and integrated crypto/custody/lockfile sources. These identities + record reviewed source changes; they do not establish completed formal proofs + or close an acceptance gate. + ## Phase gates | Phase | State | Outstanding gate | @@ -1892,8 +1987,8 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | -| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate / dependency changes after authentication and competing live grants executed | Full independent-process races on both adapters pending | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and signed-observation cases / narrow file and native predicate fixtures | Installed lock-wait, independent expiry and adapter races pending | +| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate plus full native acquisition worker/operator histories / sixteen file/TLS PostgreSQL histories executed | Complete mutation/disclosure races remain required | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, signed-observation cases and native independent-process approval/authority lock-wait cases / file/TLS PostgreSQL lock-wait controls executed | Observer expiry, threshold changes and full installed/adverse evidence remain required | | A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 71fccfabf..f4f17a1bc 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -686,6 +686,24 @@ These cases use no final-entry authorization oracle. They establish the stated source-lifetime count/byte behavior; fixed-window count/sum, complete fault and race schedules and deployed hostile-process containment remain separate gates. +`native-process-crash-{file,postgres}.json` records seven acquisition SIGKILL +schedules per adapter, covering reservation, entry, partial HTTP response and +response persistence. Reopening retains original charges and allocation; a lost +grant cannot be recreated, and a lost response cannot authorize another fetch. +These transaction-boundary process deaths do not establish actual sync/rename +failure, partial-batch failure, ambiguous database commit delivery or the complete +mutation/disclosure crash matrix. + +`native-dependency-order-{file,postgres}.json` adds eight independent worker/ +operator histories per adapter. Connection revocation and configuration activation +race the actual grant fence in both orders. Separate positive/expired controls +advance the maintained test clock while entry waits behind a physically distinct +connection record's writer fence, independently checking human approval and +native resource authority. Signed inputs and admission time remain unchanged; +valid entry records the time after waiting. These cases establish acquisition +ordering under the stated test deployment, not observer-evidence expiry, +threshold-selection changes or complete mutation/disclosure dependency races. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index c87805196..a5d79474b 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "bb575dd0f27bc7c9a5c087cb35730a28deae9dd9c1952e2da15429179c4247f7", + "digest": "dee421e6130ea9cf33df179a6235d4ee1be66a91a382b1b260a733bf4128c33b", "files": [ { "path": ".cargo/config.toml", @@ -8,12 +8,12 @@ }, { "path": "Cargo.lock", - "sha256": "9a7d4631685c172dc81e588d86603642563555b90785b6722d5657b4649df523", + "sha256": "ab4ed8625de4336a74db8583cc3fb11b285f1e66b9d0aee349f9fb30a813536c", "normalization": "translated-cargo-closure-v1" }, { "path": "Cargo.toml", - "sha256": "6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24" + "sha256": "ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3" }, { "path": "core/crates/auths-algebra-kernel/Cargo.toml", diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index a406fdb0a..e524533f1 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"d9267a780195a5972752f39e848a35d1b34154496c4bcfa46b39f99d1a7acf11"},{"path":"Cargo.toml","sha256":"6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"6e3f9311ded5e49ea50d445eb21e6d8fa12442aa4362a73e0cb6fda15b7cd865"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"8ed1afd58f18fc6becc268908aa6419c9aa404c79da0197963eb2599df44acf6"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"70cbb0fd21b6f5652157845a22c35be2d0f6c05b3d138fc4b9bb6dbdc3d81c40"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"8ee593c1f59b0fd2126bdda9138026f5bc531beb64d4489a99785842e7b98b43"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"938b1fe5d3b0f32f95e10d8052b7a11c39fb4c7024452cef72a575903df4f41e"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"641860fd69b719f1637c90e54d25c489428b323b70362aa47198d19ab32ab268"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"9e46791e45a815c94327937218ffa3121f5b736795182ba4e18fa747e33d8aac"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"08686fd3af614e0b83540ae807ee1d04914e358e754726e11b1e0456a50f4da5"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"b880d6485b3ef9e76137d44817f0e0eb3b735cee637f5c80ec85f132c8c0c61c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"f84c56f2ea9cb34b2b79c72d13fbf2c6585010ec1ed450af58a78c80c1ea1edd"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"afabb922898f56e992420cddb58cf15862682978d5f9aeedc7e69e0187c11849"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"90b6a97bff2e0ce3268bd26d34c23be9832a8c7bacf6e22dfcecde34ca9958bb"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"6c0e1c79efb542fd66826eb19c6fae09e05e2497a9f17e9f9783311d59b836b2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/harness/authoring.rs b/product/runtime/auths-gateway/src/harness/authoring.rs index e6ab31398..6ca92e897 100644 --- a/product/runtime/auths-gateway/src/harness/authoring.rs +++ b/product/runtime/auths-gateway/src/harness/authoring.rs @@ -32,15 +32,25 @@ pub struct ToolFixture { /// # Errors /// Refuses invalid time ranges, call encodings or native authoring inputs. pub fn tool_fixture(call: &McpToolCall, now: u64) -> Result { + let until = now + .checked_add(86_400) + .ok_or(HarnessError::Fixture("time"))?; + tool_fixture_until(call, now, until) +} + +/// Native test authoring with an explicit signed resource-authority end time. +/// This changes no verification rule; expired proofs still fail the native owner. +pub(crate) fn tool_fixture_until( + call: &McpToolCall, + now: u64, + until: u64, +) -> Result { let root = Signer::new(0x11); let actor = Signer::new(0x22); let observer = Signer::new(0x33); let from = now .checked_sub(86_400) .ok_or(HarnessError::Fixture("time"))?; - let until = now - .checked_add(86_400) - .ok_or(HarnessError::Fixture("time"))?; let context = context_for_tool(&root, &observer.principal, now, call)?; let grant = grant_for_tool(&root, &actor.principal, None, window(from, until)?, call)?; let canonical = fixture( diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 5e743c459..76794a887 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -160,3 +160,6 @@ mod native_process_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_crash_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_dependency_tests; diff --git a/product/runtime/auths-gateway/src/native_dependency_tests.rs b/product/runtime/auths-gateway/src/native_dependency_tests.rs new file mode 100644 index 000000000..5b114003a --- /dev/null +++ b/product/runtime/auths-gateway/src/native_dependency_tests.rs @@ -0,0 +1,697 @@ +//! Independent native workers and operators race shared dependencies and time. +//! Trusted test control channels schedule real adapter fences; they do not +//! replace native authorization, decisions, record bytes or entry permits. +use crate::native_process_tests::{ + EngineControls, NOW, Provider, Setup, acquire, authorize_bounded, load_controlled_engine, + load_engine, private, recipe, runtime, +}; +use crate::store::GatewayFenceDecision; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ContentHistory, FixedClock, GatewayAttemptError, + GatewayAttemptKey, GatewayAttemptStore, GatewayAttempts, GatewayInsert, GatewayRecordEntry, + GatewayRecordKind, LogicalOperationId, SharedConnection, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + process::{Child, Command, Stdio}, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, + thread, + time::{Duration, Instant}, +}; + +const OPERATION: &str = "dependency-read"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Scenario { + Revoke, + Configuration, + ApprovalValid, + ApprovalExpired, + AuthorityValid, + AuthorityExpired, +} +impl Scenario { + const fn time_shift(self) -> u64 { + match self { + Self::ApprovalValid | Self::AuthorityValid => 4, + _ => 6, + } + } + const fn authority_until(self) -> u64 { + if matches!(self, Self::AuthorityValid | Self::AuthorityExpired) { + NOW + 5 + } else { + NOW + 86_400 + } + } + const fn approval_until(self) -> u64 { + if matches!(self, Self::ApprovalValid | Self::ApprovalExpired) { + NOW + 5 + } else { + NOW + 300 + } + } +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Order { + ChangeFirst, + GrantFirst, + LockWait, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Race { + installation: Setup, + operator_port: u16, + scenario: Scenario, + order: Order, +} +impl Race { + const fn enters(&self) -> bool { + matches!(self.order, Order::GrantFirst) + || matches!( + self.scenario, + Scenario::ApprovalValid | Scenario::AuthorityValid + ) + } + fn key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") + } +} + +fn connect(port: u16) -> TcpStream { + let channel = TcpStream::connect(("127.0.0.1", port)).expect("test control"); + channel + .set_read_timeout(Some(Duration::from_secs(15))) + .expect("deadline"); + channel + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + channel +} +fn send(channel: &mut TcpStream, marker: u8) { + channel.write_all(&[marker]).expect("marker"); +} +fn expect(channel: &mut TcpStream, marker: u8) { + let mut value = [0]; + channel.read_exact(&mut value).expect("control marker"); + assert_eq!(value, [marker]); +} +fn pending(channel: &mut TcpStream) { + channel + .set_read_timeout(Some(Duration::from_millis(50))) + .expect("short observation"); + let mut value = [0]; + let error = channel + .read(&mut value) + .expect_err("writer must remain blocked by real fence"); + assert!(matches!( + error.kind(), + std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut + )); + channel + .set_read_timeout(Some(Duration::from_secs(15))) + .expect("deadline"); +} + +struct EntryGate { + inner: Arc, + order: Order, + port: u16, + clock: Arc, + fired: AtomicBool, +} +impl EntryGate { + fn before_lock( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + let mut channel = connect(self.port); + send(&mut channel, b'P'); + expect(&mut channel, b'G'); + match self.order { + Order::ChangeFirst => self.inner.fenced_replace(keys, decide), + Order::LockWait => { + // Clock mutation runs concurrently while this thread waits in + // the actual adapter. Neither the native decision nor its + // snapshots are fabricated or pre-evaluated by this wrapper. + let mut receiver = channel.try_clone().expect("clock control"); + let clock = self.clock.clone(); + let control = thread::spawn(move || { + let mut bytes = [0; 8]; + receiver.read_exact(&mut bytes).expect("clock value"); + clock.set(u64::from_be_bytes(bytes)); + send(&mut receiver, b'A'); + }); + send(&mut channel, b'W'); + let result = self.inner.fenced_replace(keys, decide); + control.join().expect("clock thread"); + send(&mut channel, b'D'); + result + } + Order::GrantFirst => unreachable!("this order pauses under the fence"), + } + } +} +impl GatewayAttemptStore for EntryGate { + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + let target = keys.first() == Some(&(GatewayRecordKind::Attempt, Race::key())); + if !target || self.fired.swap(true, Ordering::SeqCst) { + return self.inner.fenced_replace(keys, decide); + } + for kind in [ + GatewayRecordKind::Connection, + GatewayRecordKind::EffectConfiguration, + ] { + let dependencies: Vec<_> = keys.iter().filter(|(found, _)| *found == kind).collect(); + assert_eq!(dependencies.len(), 1, "entry fences its actual dependency"); + assert_ne!(dependencies[0].1, Race::key(), "physically distinct record"); + } + if !matches!(self.order, Order::GrantFirst) { + return self.before_lock(keys, decide); + } + self.inner.fenced_replace(keys, &mut |snapshots| { + let bytes = decide(snapshots)?; + let value: Value = serde_json::from_slice(&bytes).expect("native decision"); + assert_eq!(value["state"]["facts"]["phase"]["stage"], "entry-granted"); + let mut channel = connect(self.port); + send(&mut channel, b'P'); + expect(&mut channel, b'G'); + Ok(bytes) + }) + } + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + self.inner.fenced_insert_all(entries, dependencies, decide) + } + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.inner.insert_all(entries) + } + fn load( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + self.inner.load(kind, key) + } + fn replace( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + self.inner.replace(kind, key, current, next) + } + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.inner.sweep_expired(now, limit) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.inner.attempt_keys(limit) + } +} + +fn run_worker(race: &Race, store: &TestAttempts) { + let clock = Arc::new(FixedClock::at(NOW)); + let gate = Arc::new(EntryGate { + inner: store.raw(), + order: race.order, + port: race.installation.barrier_port, + clock: clock.clone(), + fired: AtomicBool::new(false), + }); + let attempts = GatewayAttempts::new(gate, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let controls = EngineControls { + policy: crate::effect::fixture_policy().expect("policy"), + clock, + }; + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &race.installation, + "worker", + attempts, + controls, + )); + let result = runtime.block_on(acquire(&engine, &race.installation.root, OPERATION)); + private( + &race.installation.root.join("worker-result"), + &serde_json::to_vec(&result).expect("result"), + ); +} +fn hold_connection(race: &Race, store: &TestAttempts, channel: &mut TcpStream) { + let record = crate::harness::fixture_connection(&recipe()).expect("connection template"); + let key = crate::connection::connection_key(record.provider_kind(), record.alias()); + store + .raw() + .fenced_replace(&[(GatewayRecordKind::Connection, key)], &mut |snapshots| { + send(channel, b'H'); + expect(channel, b'G'); + // A privileged test writer holds a physically distinct real record. + // Its exact byte-preserving write creates no semantic state change. + Ok(snapshots[0].clone().expect("connection")) + }) + .expect("held connection fence"); + assert!(matches!(race.order, Order::LockWait)); +} +fn run_operator(race: &Race, store: &TestAttempts) { + // Prepare custody, current connection and the exact native review token + // before the competing worker holds a writer fence. The test races + // publication, not the opening/recovery of a new host's store handle. + let runtime = runtime(); + let mut controls = EngineControls::baseline(); + if matches!(race.scenario, Scenario::Configuration) { + use ed25519_dalek::SigningKey; + controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + SigningKey::from_bytes(&[30; 32]).verifying_key().to_bytes(), + ) + .expect("new operator policy"); + } + let operator_attempts = GatewayAttempts::new(store.raw(), controls.policy.clone()) + .expect("operator store policy matches candidate installation"); + let (engine, record) = runtime.block_on(load_controlled_engine( + &race.installation, + "operator", + operator_attempts, + controls, + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + let current = runtime + .block_on(shared.load()) + .expect("current connection") + .expect("connection"); + let reviewed = engine + .effect_configuration_revision() + .expect("native operator review"); + let mut channel = connect(race.operator_port); + send(&mut channel, b'S'); + expect(&mut channel, b'G'); + if matches!(race.order, Order::LockWait) { + hold_connection(race, store, &mut channel); + } else { + match race.scenario { + Scenario::Revoke => { + let next = current + .record() + .transition_state(auths_connections::ConnectionState::Revoked, NOW) + .expect("native revocation transition"); + let changed = runtime + .block_on(shared.replace(¤t, &next)) + .expect("native revocation CAS"); + assert_eq!( + changed.record().state(), + auths_connections::ConnectionState::Revoked + ); + } + Scenario::Configuration => { + engine + .activate_effect_configuration(reviewed) + .expect("native activation"); + assert_ne!( + engine + .effect_configuration_revision() + .expect("active revision"), + reviewed + ); + } + _ => unreachable!("clock cases hold the fence only"), + } + } + private( + &race.installation.root.join("operator-result"), + b"committed", + ); + send(&mut channel, b'D'); +} + +#[test] +fn native_dependency_peer() { + let Some(input) = std::env::var_os("AUTHS_AP074_DEPENDENCY_PEER") else { + return; + }; + let race: Race = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach( + Backend::parse(&race.installation.backend), + &race.installation.location, + ); + match std::env::var("AUTHS_AP074_DEPENDENCY_ROLE") + .expect("role") + .as_str() + { + "worker" => run_worker(&race, &store), + "operator" => run_operator(&race, &store), + _ => panic!("unknown private test role"), + } +} +struct Peer(Child); +impl Peer { + fn start(input: &Path, role: &str) -> Self { + Self( + Command::new(std::env::current_exe().expect("test binary")) + .args([ + "--exact", + "native_dependency_tests::native_dependency_peer", + "--nocapture", + ]) + .env("AUTHS_AP074_DEPENDENCY_PEER", input) + .env("AUTHS_AP074_DEPENDENCY_ROLE", role) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("peer"), + ) + } + fn check_exit(&mut self) -> Option { + let result = self.0.try_wait().expect("process status"); + if let Some(status) = result { + let mut diagnostic = String::new(); + self.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "peer failed: {diagnostic}"); + } + result + } + fn accept(&mut self, listener: &TcpListener) -> TcpStream { + let deadline = Instant::now() + Duration::from_secs(15); + loop { + assert!( + self.check_exit().is_none(), + "peer exited before its control marker" + ); + match listener.accept() { + Ok((channel, _)) => { + channel.set_nonblocking(false).expect("blocking"); + channel + .set_read_timeout(Some(Duration::from_secs(15))) + .expect("deadline"); + channel + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + return channel; + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "peer control timeout"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("listener: {error}"), + } + } + } + fn finish(&mut self) { + let deadline = Instant::now() + Duration::from_secs(20); + while self.check_exit().is_none() { + assert!(Instant::now() < deadline, "peer completion timeout"); + thread::sleep(Duration::from_millis(2)); + } + } +} +impl Drop for Peer { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + if thread::panicking() + && let Some(mut stderr) = self.0.stderr.take() + { + let mut diagnostic = String::new(); + let _ = stderr.read_to_string(&mut diagnostic); + eprintln!("private native peer diagnostic: {diagnostic}"); + } + } +} +fn listener() -> TcpListener { + let value = TcpListener::bind("127.0.0.1:0").expect("listener"); + value.set_nonblocking(true).expect("nonblocking"); + value +} +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + race: Race, + worker_listener: TcpListener, + operator_listener: TcpListener, + provider: Provider, + signed_inputs: Vec>, +} +impl Case { + fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private mode"); + let worker_listener = listener(); + let operator_listener = listener(); + let provider = Provider::controlled(None); + let store = TestAttempts::open(backend); + let race = Race { + scenario, + order, + operator_port: operator_listener.local_addr().expect("address").port(), + installation: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: worker_listener.local_addr().expect("address").port(), + }, + }; + let runtime = runtime(); + let (engine, record) = runtime.block_on(load_engine( + &race.installation, + "parent", + store.attempts().clone(), + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + runtime + .block_on(shared.insert(&record)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + runtime.block_on(authorize_bounded( + &engine, + &race.installation.root, + OPERATION, + scenario.authority_until(), + scenario.approval_until(), + )); + let signed_inputs = Self::inputs(&race); + Self { + _directory: directory, + store, + race, + worker_listener, + operator_listener, + provider, + signed_inputs, + } + } + fn inputs(race: &Race) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| { + std::fs::read(race.installation.root.join(format!("{OPERATION}.{suffix}"))) + .expect("signed input") + }) + .to_vec() + } + fn execute(&self) -> AcquisitionSnapshot { + let input = self.race.installation.root.join("race-setup.json"); + private(&input, &serde_json::to_vec(&self.race).expect("setup")); + let mut operator = Peer::start(&input, "operator"); + let mut operator_channel = operator.accept(&self.operator_listener); + expect(&mut operator_channel, b'S'); + let mut worker = Peer::start(&input, "worker"); + let mut worker_channel = worker.accept(&self.worker_listener); + expect(&mut worker_channel, b'P'); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 0); + match self.race.order { + Order::ChangeFirst => { + send(&mut operator_channel, b'G'); + expect(&mut operator_channel, b'D'); + operator.finish(); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 0); + send(&mut worker_channel, b'G'); + } + Order::GrantFirst => { + send(&mut operator_channel, b'G'); + pending(&mut operator_channel); + assert!(!self.race.installation.root.join("operator-result").exists()); + send(&mut worker_channel, b'G'); + expect(&mut operator_channel, b'D'); + operator.finish(); + } + Order::LockWait => { + send(&mut operator_channel, b'G'); + expect(&mut operator_channel, b'H'); + send(&mut worker_channel, b'G'); + expect(&mut worker_channel, b'W'); + worker_channel + .write_all(&(NOW + self.race.scenario.time_shift()).to_be_bytes()) + .expect("advance clock"); + expect(&mut worker_channel, b'A'); + pending(&mut worker_channel); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 0); + send(&mut operator_channel, b'G'); + expect(&mut operator_channel, b'D'); + operator.finish(); + expect(&mut worker_channel, b'D'); + } + } + worker.finish(); + let result: Result = + serde_json::from_slice( + &std::fs::read(self.race.installation.root.join("worker-result")).expect("result"), + ) + .expect("native result"); + result.expect("native retained facts") + } + fn verify(&self, snapshot: &AcquisitionSnapshot) -> Value { + assert_eq!( + Self::inputs(&self.race), + self.signed_inputs, + "signed evidence/event times never refreshed" + ); + assert_eq!( + snapshot.stage, + if self.race.enters() { + AcquisitionStage::ResponseRecorded + } else { + AcquisitionStage::Reserved + } + ); + assert_eq!( + (snapshot.reserved_calls, snapshot.reserved_bytes), + (1, 1024) + ); + assert_eq!( + self.provider.calls.load(Ordering::SeqCst), + usize::from(self.race.enters()) + ); + let stored = self + .store + .raw() + .load(GatewayRecordKind::Attempt, &Race::key()) + .expect("load") + .expect("record"); + let record: Value = serde_json::from_slice(&stored).expect("native record"); + assert_eq!(record["evaluated_at"], NOW); + assert_eq!(record["state"]["facts"]["allocation"], 0); + assert_eq!(!record["entry"].is_null(), self.race.enters()); + if matches!(self.race.order, Order::LockWait) && self.race.enters() { + assert_eq!( + record["entry"]["granted_at"], + NOW + self.race.scenario.time_shift() + ); + } + let runtime = runtime(); + let (inspector, _) = runtime.block_on(load_engine( + &self.race.installation, + "inspector", + self.store.reopen(), + )); + match runtime + .block_on(inspector.content_history(OPERATION)) + .expect("native history") + { + ContentHistory::Acquisition(history) => assert_eq!(&history, snapshot), + ContentHistory::Disclosure(_) => panic!("wrong protocol"), + } + assert_eq!( + stored, + self.store + .raw() + .load(GatewayRecordKind::Attempt, &Race::key()) + .expect("replay") + .expect("record") + ); + json!({ "scenario": self.race.scenario, "order": self.race.order, + "actual_provider_reads": self.provider.calls.load(Ordering::SeqCst), "native_history": snapshot, + "separate_operator_completed": true, "signed_inputs_unchanged": true, + "admission_time": NOW, "clock_after_wait": matches!(self.race.order, Order::LockWait).then(|| NOW + self.race.scenario.time_shift()), + "history_inspection_did_not_change_journal": true }) + } +} +fn dependency_matrix(backend: Backend) { + let pairs = [ + (Scenario::Revoke, Order::ChangeFirst), + (Scenario::Revoke, Order::GrantFirst), + (Scenario::Configuration, Order::ChangeFirst), + (Scenario::Configuration, Order::GrantFirst), + (Scenario::ApprovalValid, Order::LockWait), + (Scenario::ApprovalExpired, Order::LockWait), + (Scenario::AuthorityValid, Order::LockWait), + (Scenario::AuthorityExpired, Order::LockWait), + ]; + let cases: Vec<_> = pairs + .into_iter() + .map(|(scenario, order)| { + let case = Case::new(backend, scenario, order); + let snapshot = case.execute(); + case.verify(&snapshot) + }) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({ "schema": "auths.native-dependency-order/1", "adapter": backend.label(), + "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", + "excluded": ["observer-evidence aging and threshold-selection changes", "mutation/disclosure races", "fixed-window budget contention", "production commissioning", "hostile OS containment", "power loss and whole-store rollback"], "cases": cases })).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-dependency-order-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("artifact"), artifact); +} +#[test] +fn native_file_dependency_order_fixture_is_current() { + dependency_matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_dependency_order_fixture_is_current() { + assert!(postgres_configured()); + dependency_matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index e3ab2cdd5..e00d77e20 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -4,7 +4,7 @@ #![cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] use crate::effect::{CONTENT_READ_TOOL, ExactEffectApproval, fixture_policy}; -use crate::harness::authoring::{tool_fixture, tools_context}; +use crate::harness::authoring::{tool_fixture_until, tools_context}; use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; use crate::{ AcquisitionSnapshot, AcquisitionStage, CompiledRecipe, GatewayAttempts, GatewayEngine, @@ -31,7 +31,7 @@ use std::{ time::{Duration, Instant}, }; -const NOW: u64 = 1_790_000_000; +pub(super) const NOW: u64 = 1_790_000_000; const SECRET: &[u8] = b"public-native-process-fixture"; pub(super) const CONTENT: &[u8] = b"PUBLIC-NATIVE-CONTENT"; @@ -69,10 +69,32 @@ pub(super) fn runtime() -> tokio::runtime::Runtime { tokio::runtime::Runtime::new().expect("runtime") } +pub(super) struct EngineControls { + pub(super) policy: crate::effect::EffectPolicy, + pub(super) clock: Arc, +} +impl EngineControls { + pub(super) fn baseline() -> Self { + Self { + policy: fixture_policy().expect("policy"), + clock: Arc::new(crate::FixedClock::at(NOW)), + } + } +} + pub(super) async fn load_engine( setup: &Setup, label: &str, attempts: GatewayAttempts, +) -> (GatewayEngine, ConnectionRecord) { + load_controlled_engine(setup, label, attempts, EngineControls::baseline()).await +} + +pub(super) async fn load_controlled_engine( + setup: &Setup, + label: &str, + attempts: GatewayAttempts, + controls: EngineControls, ) -> (GatewayEngine, ConnectionRecord) { let recipe = recipe(); let initial = crate::harness::fixture_connection(&recipe).expect("connection template"); @@ -110,7 +132,7 @@ pub(super) async fn load_engine( QualificationPolicy::Optional, None, None, - Box::new(Arc::new(crate::FixedClock::at(NOW))), + Box::new(controls.clock), auths_recipe_qualification::VerifierState::default(), )); gate.load(&crate::QualificationBundle { @@ -125,7 +147,7 @@ pub(super) async fn load_engine( recipe.clone(), *recipe.digest(), &trust(&recipe), - fixture_policy().expect("policy"), + controls.policy, record.provider_kind().clone(), record.alias().clone(), "gateway".to_owned(), @@ -140,18 +162,28 @@ pub(super) async fn load_engine( } pub(super) async fn authorize(engine: &GatewayEngine, root: &Path, operation: &str) { + authorize_bounded(engine, root, operation, NOW + 86_400, NOW + 300).await; +} + +pub(super) async fn authorize_bounded( + engine: &GatewayEngine, + root: &Path, + operation: &str, + authority_until: u64, + approval_until: u64, +) { let call = engine .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) .await .expect("native call"); - let signed = tool_fixture(&call, NOW).expect("native authority"); + let signed = tool_fixture_until(&call, NOW, authority_until).expect("native authority"); assert_eq!(signed.context, trust(&recipe())); let effect = engine .compile_content_action(&signed.proof, &signed.action) .await .expect("native effect"); let request = effect - .approval_request(NOW, NOW + 300) + .approval_request(NOW, approval_until) .expect("review request"); let key = SigningKey::from_bytes(&[29; 32]); let signature = key diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 8b443e280..759333da5 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "c031726748fb1ee96d0f1bec3c34803edfcefaeb79130ed5438660a367aed78a"; + "0d030da904106d7744e7d26564f1d026342dd903ee3b619d0a58249d3a92ec83"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 323956461..d45a47e1b 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 395 +freeze_version = 396 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -19,7 +19,7 @@ freeze_version = 395 "auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 60 "auths.frozen-bytes/formal/qualification/aeneas/generated" = 19 "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 16 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 103 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 104 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -45,7 +45,7 @@ freeze_version = 395 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 141 +"auths.identity.protocol" = 142 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -53,18 +53,18 @@ freeze_version = 395 "auths.product.configuration-commitments" = 1 "auths.product.development-composition" = 13 "auths.product.error-recovery-contract" = 18 -"auths.product.external-custody" = 5 +"auths.product.external-custody" = 6 "auths.product.facade" = 26 "auths.product.github-issue-address-v2" = 4 "auths.product.lifecycle" = 17 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 138 +"auths.product.public-sdk-contract" = 139 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 395 +"auths.release.public-surface" = 396 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index cc32e9ed3..85134f75d 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 395, + "freezeVersion": 396, "publicSurface": { "rustRoots": [ "auths", @@ -238,7 +238,7 @@ }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 103, + "version": 104, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "0b3d14c09cc6c50e6c6d9d1167447d6ac46d745e6d41014ef40d889ac5c0ff91" + "sha256": "68589b4fbdbe61823fc9ed8d77d38a8a3e1f0f00a66e197784d5fa1f9f0f732a" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 141, + "version": 142, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "67b2b9cbfe32d73e9646f7e09653ee3bd83e563c409d618db01c00e8d6de3c94" + "sha256": "693b70eec4a41bff2b2261d78ca3fcca594d01fd493de424d0cdb7a8c81d6bd9" }, { "id": "auths.modular-components", @@ -728,7 +728,7 @@ }, { "id": "auths.product.external-custody", - "version": 5, + "version": 6, "classification": "frozen-meaning", "categories": [ "transaction-bound-signing", @@ -748,7 +748,7 @@ "product/integrations/auths-custody-pkcs11/src", "product/integrations/auths-custody/src" ], - "sha256": "9698123f65fa3ee4e28915146111fece1524e61b1f66dda69d80e7164e8d7b0c" + "sha256": "db42e22edfd14fdc686044d2e0b33bb2a3bcac4f1be986d86384e01cd90beb45" }, { "id": "auths.product.facade", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 138, + "version": 139, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "57b709148ca6e7efa2017d712f26ed9eb08253eaa117848da2a428b2a617be64" + "sha256": "b67cc30af766ad3ce538b3b1c3bd36327b089c56fae8614de186150df456f3ac" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 395, + "version": 396, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "094c17969512ab6038fd1fb37101c0d672b0156fd126b6287697660831641b5e" + "sha256": "0ec1769915891988834ebeec2f34e44fcdd27e6e52e40fd39e212f89268dcfa9" } ] } From edb122e9ebb357efab2fdc146a8bd322357047b0 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 02:11:15 +0000 Subject: [PATCH 074/136] test(gateway): prove native fixed-window acquisition capacity across stores --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-window-capacity-file.json | 65 ++++ .../native-window-capacity-postgres.json | 65 ++++ compliance.toml | 2 + docs/plans/0074-implementation-status.md | 43 ++- ...ound-effects-and-recovery-state-machine.md | 10 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/harness.rs | 10 + .../auths-gateway/src/harness/authoring.rs | 42 ++- product/runtime/auths-gateway/src/lib.rs | 3 + .../auths-gateway/src/native_budget_tests.rs | 357 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 40 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 15 files changed, 643 insertions(+), 22 deletions(-) create mode 100644 bindings/fixtures/gateway/native-window-capacity-file.json create mode 100644 bindings/fixtures/gateway/native-window-capacity-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_budget_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 25060ff7f..d2bd2e664 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -47,6 +47,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-window-capacity-file.json b/bindings/fixtures/gateway/native-window-capacity-file.json new file mode 100644 index 000000000..5ca6aabb3 --- /dev/null +++ b/bindings/fixtures/gateway/native-window-capacity-file.json @@ -0,0 +1,65 @@ +{ + "schema": "auths.native-window-capacity/1", + "adapter": "file", + "scope": "full native acquisition engine; signed bounded grants, exact approval, separate native OS workers and local custody, actual common adapter transactions and HTTP; fixed public fixture keys and maintained test clock", + "excluded": [ + "mutation/disclosure fixed-window contention", + "cross-window expiry and clock rollback", + "partial batch and durability faults", + "human review UI and hostile OS containment", + "provider qualification" + ], + "cases": [ + { + "limit": "count", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 0, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + }, + { + "limit": "byte-sum", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 2, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 2, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-window-capacity-postgres.json b/bindings/fixtures/gateway/native-window-capacity-postgres.json new file mode 100644 index 000000000..bfe29926c --- /dev/null +++ b/bindings/fixtures/gateway/native-window-capacity-postgres.json @@ -0,0 +1,65 @@ +{ + "schema": "auths.native-window-capacity/1", + "adapter": "postgres", + "scope": "full native acquisition engine; signed bounded grants, exact approval, separate native OS workers and local custody, actual common adapter transactions and HTTP; fixed public fixture keys and maintained test clock", + "excluded": [ + "mutation/disclosure fixed-window contention", + "cross-window expiry and clock rollback", + "partial batch and durability faults", + "human review UI and hostile OS containment", + "provider qualification" + ], + "cases": [ + { + "limit": "count", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 0, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + }, + { + "limit": "byte-sum", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 2, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 3600, + "window_index": 497222, + "prefix": 1, + "contenders": 2, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "reserved_calls": 2, + "reserved_bytes": 2048, + "count_slots": 2, + "sum_slots": 2, + "actual_http_reads": 2, + "reopened_replay_preserves_attempt_and_counter_bytes": true, + "reopened_replay_leases_and_sends_nothing": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index d924888ea..6787bd59d 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1808,6 +1808,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_crash_tests.rs#postgres_native_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#native_file_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 3fba12b74..e5552321e 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1958,6 +1958,47 @@ closure regeneration passed after that correction (one artifact-generation test) record reviewed source changes; they do not establish completed formal proofs or close an acceptance gate. +## Native fixed-window capacity checkpoint + +- `native_budget_tests.rs` adds three full native acquisition histories per + adapter: count-only exhaustion, response-byte sum exhaustion with count + headroom, and simultaneous count/byte limits. A real bounded extension is + signed into each resource grant and passes the ordinary native compiler and + entry checks; exact human approval remains a separate signed fact. This + test-only authoring extension constructs no admission fact or entry permit. +- After one prefix request reserves a count slot and the entire 1,024-byte + response ceiling, two independent worker OS processes with separate local + custody contend for the remaining allowance in the same fixed 3,600-second + window. Exactly one receives a grant and sends HTTP. The other retains a + not-entered record with the precise window/sum refusal, no allocation, no + counter slot and zero call/byte charge. The successful pair retains two + call charges and 2,048 reserved bytes despite only 21 response bytes each. +- Assertions load the native count/sum slots through their recorded counter + witnesses and verify the original window index/end, operation ownership and + cumulative byte ceiling. No third slot exists. A reopened native engine + returns all original snapshots and preserves every inspected attempt/counter + byte, execution witness and provider count. These cases use actual adapter + transactions and local HTTP, with fixed public test keys/clock; they do not + establish mutation/disclosure fixed-window contention, cross-window expiry, + clock rollback, partial-batch/durability faults, human review or isolation. +- Initial artifact generation passed the file matrix (1.28 seconds) and TLS + PostgreSQL matrix (2.60 seconds), each containing three histories. The strict + gateway library/test lint reproduction passed after the complete test helper + factoring, without suppressions. Exact feature-gated CI commands and consumer + evidence anchors include both adapters. A04 remains partial. +- Final source-closure generation and rebuild verified the two new budget + artifacts together with both native capacity, crash and dependency matrices, + the three no-input peer helpers and the closure without update mode: all + twelve tests passed in 4.69 seconds. Existing unbounded authoring/capacity/ + crash/dependency artifacts stayed byte-identical after the bounded-grant helper + factoring. The dedicated TLS fixture's containers, network and volume were + stopped/removed afterward. Fresh exact-head hosted verification remains open. + +- Release freeze397 advances the reported identity protocol143, public SDK + contract140 and public surface397 subjects for this bounded-authoring/test + inventory update. No portable wire change, new formal proof or completed + acceptance claim follows from these source identity updates. + ## Phase gates | Phase | State | Outstanding gate | @@ -1979,7 +2020,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | | A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / two-daemon file and full native engine processes on file/TLS PostgreSQL / final source lifetime count/bytes, durable grants and reopened replay executed | Managed fixed-window count/sum and complete adverse schedules still required | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index f4f17a1bc..3eb0e46e3 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -704,6 +704,16 @@ valid entry records the time after waiting. These cases establish acquisition ordering under the stated test deployment, not observer-evidence expiry, threshold-selection changes or complete mutation/disclosure dependency races. +`native-window-capacity-{file,postgres}.json` separately exercises native +bounded resource grants and exact approvals across independent worker processes. +After a prefix acquisition, two new operations contend for the last count slot, +byte-sum allowance or both within the same fixed window. The loser retains an +uncharged not-entered record; the winner retains the original full response +ceiling. Native slot witnesses and reopened history preserve window, cumulative +charges and exact record bytes without another lease or HTTP request. These +acquisition cases do not replace mutation/disclosure fixed-window evidence, +cross-window expiry, partial-batch faults or the other A04/A06 requirements. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index e524533f1..51da78942 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"c57787fef2ddde8efbcd4bde3940748adb73395d7f7a558d275cf5807941f4e2"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"afabb922898f56e992420cddb58cf15862682978d5f9aeedc7e69e0187c11849"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"90b6a97bff2e0ce3268bd26d34c23be9832a8c7bacf6e22dfcecde34ca9958bb"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"6c0e1c79efb542fd66826eb19c6fae09e05e2497a9f17e9f9783311d59b836b2"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33858f37d34122b37154a6b2338a0016ae791189b32e157b82db5e974f5ceb77"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"4b20147614f4fd2669c3ffa30820ad04d27f20d830e8bc7868725af0a9113e4d"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index 04db3b28e..fb3e9964e 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -601,6 +601,16 @@ pub(crate) fn grant_for_tool( )? } }; + grant_for_tool_with_extensions(root, subject, validity, unbound, extensions) +} + +pub(crate) fn grant_for_tool_with_extensions( + root: &Signer, + subject: &PrincipalId, + validity: ValidityWindow, + unbound: &McpToolCall, + extensions: CriticalExtensions, +) -> Result { let statement = GrantStatement::new( root.principal.clone(), subject.clone(), diff --git a/product/runtime/auths-gateway/src/harness/authoring.rs b/product/runtime/auths-gateway/src/harness/authoring.rs index 6ca92e897..ed38e5acb 100644 --- a/product/runtime/auths-gateway/src/harness/authoring.rs +++ b/product/runtime/auths-gateway/src/harness/authoring.rs @@ -1,15 +1,18 @@ //! Fixed-key native authoring for installed-process tests. This module is //! available only in testkit builds. None of its public seeds are credentials. -use super::{HarnessError, Signer, audience, context_for_tool, fixture, grant_for_tool, window}; +use super::{ + HarnessError, Signer, audience, context_for_tool, fixture, grant_for_tool, + grant_for_tool_with_extensions, window, +}; use auths_codec::{ action_id, action_signing_preimage, body_digest, encode_bundle, encode_canonical_action, encode_verifier_context, grant_id, plan_id, }; use auths_model::{ ActionEnvelope, AuthorizationPlan, BundleHeader, Challenge, ChannelBindingId, ControlBinding, - CriticalExtensions, EvidenceObject, ProofBundle, ProofRef, SignatureEnvelope, SignedAction, - StatementRef, + CriticalExtension, CriticalExtensions, EvidenceObject, ExtensionId, ProofBundle, ProofRef, + SignatureEnvelope, SignedAction, StatementRef, }; use auths_profile_api::ActionProfile as _; use auths_profile_mcp::{McpProfile, McpToolCall}; @@ -44,6 +47,17 @@ pub(crate) fn tool_fixture_until( call: &McpToolCall, now: u64, until: u64, +) -> Result { + tool_fixture_using_policy(call, now, until, None) +} + +/// Signs a native bounded grant for a test tool. Policy and permission are +/// verified by the ordinary native compiler; no admission fact is created. +pub(crate) fn tool_fixture_using_policy( + call: &McpToolCall, + now: u64, + until: u64, + policy: Option<&crate::ArgumentCeilingPolicy>, ) -> Result { let root = Signer::new(0x11); let actor = Signer::new(0x22); @@ -52,7 +66,27 @@ pub(crate) fn tool_fixture_until( .checked_sub(86_400) .ok_or(HarnessError::Fixture("time"))?; let context = context_for_tool(&root, &observer.principal, now, call)?; - let grant = grant_for_tool(&root, &actor.principal, None, window(from, until)?, call)?; + let grant = if let Some(policy) = policy { + let extension = fixture( + CriticalExtension::new( + fixture( + ExtensionId::parse(auths_registries::BOUNDED_POLICY_COMMITMENT_EXTENSION_V1), + "extension ID", + )?, + fixture(policy.extension_body(None), "bounded policy")?, + ), + "policy extension", + )?; + grant_for_tool_with_extensions( + &root, + &actor.principal, + window(from, until)?, + call, + fixture(CriticalExtensions::new(vec![extension]), "extensions")?, + )? + } else { + grant_for_tool(&root, &actor.principal, None, window(from, until)?, call)? + }; let canonical = fixture( McpProfile.canonicalize(&fixture(call.canonical_bytes(), "call")?), "canonical action", diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 76794a887..15e91c846 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -163,3 +163,6 @@ mod native_crash_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_dependency_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_budget_tests; diff --git a/product/runtime/auths-gateway/src/native_budget_tests.rs b/product/runtime/auths-gateway/src/native_budget_tests.rs new file mode 100644 index 000000000..3bc33e1bb --- /dev/null +++ b/product/runtime/auths-gateway/src/native_budget_tests.rs @@ -0,0 +1,357 @@ +//! Native fixed-window acquisition admission over independent processes. +//! Real proof verification, exact approval, adapter transactions and HTTP; +//! public fixture keys and a controlled maintained test clock are explicit. +use crate::native_process_tests::{ + NOW, Provider, Setup, acquire, authorize_policy, finish_peer, load_engine, private, recipe, + runtime, start_peer, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ArgumentCeilingPolicy, GatewayAttemptKey, + GatewayRecordKind, GatewaySubmitResult, LogicalOperationId, SharedConnection, +}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::TcpListener, + os::unix::fs::PermissionsExt as _, + path::Path, + sync::atomic::Ordering, + thread, + time::{Duration, Instant}, +}; + +const OPERATIONS: [&str; 3] = ["window-prefix", "window-left", "window-right"]; +const WINDOW: u64 = 3_600; +const MAXIMUM: u64 = 1_024; +type StoredRecord = (GatewayRecordKind, GatewayAttemptKey, Vec); + +#[derive(Clone, Copy)] +enum Limit { + Count, + Bytes, + Both, +} +impl Limit { + const fn label(self) -> &'static str { + match self { + Self::Count => "count", + Self::Bytes => "byte-sum", + Self::Both => "count-and-byte-sum", + } + } + const fn has_sum(self) -> bool { + !matches!(self, Self::Count) + } + const fn refusal(self) -> &'static str { + if matches!(self, Self::Bytes) { + "gateway.policy.sum-exhausted" + } else { + "gateway.policy.window-exhausted" + } + } + fn policy(self) -> ArgumentCeilingPolicy { + let bound = ArgumentCeilingPolicy::new( + "maximum_response_bytes", + MAXIMUM, + WINDOW, + if matches!(self, Self::Bytes) { 16 } else { 2 }, + ) + .expect("native count bound"); + if self.has_sum() { + bound.with_sum(2 * MAXIMUM, None).expect("native sum bound") + } else { + bound + } + } +} + +fn release(barrier: &TcpListener) { + let mut signals = Vec::new(); + let deadline = Instant::now() + Duration::from_secs(15); + while signals.len() < 2 { + match barrier.accept() { + Ok((mut stream, _)) => { + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut ready = [0]; + stream.read_exact(&mut ready).expect("native peer ready"); + assert_eq!(ready, *b"R"); + signals.push(stream); + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "peer timeout"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("barrier: {error}"), + } + } + for signal in &mut signals { + signal.write_all(b"G").expect("release native peer"); + } +} + +fn records(store: &TestAttempts) -> Vec { + let raw = store.raw(); + let keys = raw.attempt_keys(8).expect("keys"); + assert_eq!(keys.len(), 3, "one retained record per logical operation"); + keys.into_iter() + .map(|key| { + ( + GatewayRecordKind::Attempt, + key, + raw.load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"), + ) + }) + .collect() +} + +fn check_counters(store: &TestAttempts, limit: Limit) -> Vec { + let mut retained = records(store); + let mut counts = 0; + let mut sums = 0; + let mut grants = 0; + let mut refusals = 0; + // Iterate a snapshot; append the actual shared counter records for replay + // byte checks. All slot keys come from native recorded counter witnesses. + for (_, _, bytes) in retained.clone() { + let record: Value = serde_json::from_slice(&bytes).expect("native record"); + let counters = record["state"]["facts"]["counters"] + .as_array() + .expect("counter witnesses"); + if record["entry"].is_null() { + assert_eq!(record["state"]["facts"]["phase"]["stage"], "not-entered"); + assert_eq!(record["state"]["facts"]["phase"]["code"], limit.refusal()); + assert!(counters.is_empty(), "refusal leaks no counter slot"); + assert!(record["state"]["facts"]["allocation"].is_null()); + refusals += 1; + continue; + } + grants += 1; + assert_eq!(counters.len(), 1 + usize::from(limit.has_sum())); + for counter in counters { + let digest: [u8; 32] = hex::decode(counter["counter"].as_str().expect("counter")) + .expect("digest") + .try_into() + .expect("digest length"); + let slot = counter["slot"].as_u64().expect("slot"); + assert!(slot < 2, "only the two admitted slots exist"); + let (kind, key, beyond) = if counter["kind"] == "count" { + counts += 1; + ( + GatewayRecordKind::CountSlot, + crate::bounds::count_slot_key(&digest, slot), + crate::bounds::count_slot_key(&digest, 2), + ) + } else { + assert_eq!(counter["kind"], "sum"); + sums += 1; + ( + GatewayRecordKind::SumSlot, + crate::bounds::sum_slot_key(&digest, slot), + crate::bounds::sum_slot_key(&digest, 2), + ) + }; + let key = GatewayAttemptKey::from_bytes(key); + let bytes = store + .raw() + .load(kind, &key) + .expect("slot load") + .expect("slot"); + let value: Value = serde_json::from_slice(&bytes).expect("native slot"); + assert_eq!(value["window_seconds"], WINDOW); + assert_eq!(value["window_index"], NOW / WINDOW); + assert_eq!(value["window_end"], (NOW / WINDOW + 1) * WINDOW); + assert_eq!(value["operation_id"], record["operation_id"]); + if kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], MAXIMUM, "charge the full ceiling"); + assert_eq!(value["cumulative"], (slot + 1) * MAXIMUM); + } + assert!( + store + .raw() + .load(kind, &GatewayAttemptKey::from_bytes(beyond)) + .expect("no overflow") + .is_none() + ); + retained.push((kind, key, bytes)); + } + } + assert_eq!((grants, refusals), (2, 1)); + assert_eq!((counts, sums), (2, if limit.has_sum() { 2 } else { 0 })); + retained +} + +fn contend(setup: &Setup, barrier: &TcpListener) -> Vec { + let input = setup.root.join("setup.json"); + private(&input, &serde_json::to_vec(setup).expect("setup")); + let mut left = start_peer(&input, OPERATIONS[1]); + let mut right = start_peer(&input, OPERATIONS[2]); + assert_ne!(left.id(), right.id()); + release(barrier); + finish_peer(&mut left); + finish_peer(&mut right); + let contenders: Vec = OPERATIONS[1..] + .iter() + .map(|operation| { + let result: Result = serde_json::from_slice( + &std::fs::read(setup.root.join(format!("{operation}.result"))).expect("result"), + ) + .expect("native result"); + result.expect("retained native facts") + }) + .collect(); + assert_eq!( + contenders + .iter() + .filter(|value| value.stage == AcquisitionStage::ResponseRecorded) + .count(), + 1 + ); + assert_eq!( + contenders + .iter() + .filter(|value| value.stage == AcquisitionStage::NotEntered) + .count(), + 1 + ); + contenders +} + +fn verify_replay( + setup: &Setup, + store: &TestAttempts, + provider: &Provider, + snapshots: &[AcquisitionSnapshot], + retained: &[StoredRecord], +) { + let runtime = runtime(); + let (reopened, _) = runtime.block_on(load_engine(setup, "reopened", store.reopen())); + let witness = reopened.execution_witness(); + for (operation, expected) in OPERATIONS.iter().zip(snapshots) { + assert_eq!( + &runtime + .block_on(acquire(&reopened, &setup.root, operation)) + .expect("replay"), + expected + ); + } + assert_eq!(reopened.execution_witness(), witness); + assert_eq!(provider.calls.load(Ordering::SeqCst), 2); + for (kind, key, expected) in retained { + assert_eq!( + &store + .raw() + .load(*kind, key) + .expect("replay record") + .expect("record"), + expected + ); + } + // Every operation, including the refusal, retains its native replay key. + let policy = crate::effect::fixture_policy().expect("policy"); + for operation in OPERATIONS { + let key = GatewayAttemptKey::for_operation( + &policy, + recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key"); + assert!( + store + .raw() + .load(GatewayRecordKind::Attempt, &key) + .expect("attempt") + .is_some() + ); + } +} + +fn one_case(backend: Backend, limit: Limit) -> Value { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::controlled(None); + let barrier = TcpListener::bind("127.0.0.1:0").expect("barrier"); + barrier.set_nonblocking(true).expect("nonblocking"); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root: root.clone(), + provider_port: provider.port, + barrier_port: barrier.local_addr().expect("address").port(), + }; + let runtime = runtime(); + let (engine, connection) = + runtime.block_on(load_engine(&setup, "parent", store.attempts().clone())); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + for operation in OPERATIONS { + runtime.block_on(authorize_policy(&engine, &root, operation, &limit.policy())); + } + let prefix = runtime + .block_on(acquire(&engine, &root, OPERATIONS[0])) + .expect("prefix"); + assert_eq!(prefix.stage, AcquisitionStage::ResponseRecorded); + assert_eq!(provider.calls.load(Ordering::SeqCst), 1); + let mut contenders = contend(&setup, &barrier); + contenders.insert(0, prefix); + assert_eq!( + contenders + .iter() + .map(|value| value.reserved_calls) + .sum::(), + 2 + ); + assert_eq!( + contenders + .iter() + .map(|value| value.reserved_bytes) + .sum::(), + 2 * MAXIMUM + ); + let retained = check_counters(&store, limit); + verify_replay(&setup, &store, &provider, &contenders, &retained); + json!({"limit":limit.label(),"window_seconds":WINDOW,"window_index":NOW/WINDOW,"prefix":1,"contenders":2,"final_winners":1,"refusal_code":limit.refusal(),"durable_grants":2,"reserved_calls":2,"reserved_bytes":2*MAXIMUM,"count_slots":2,"sum_slots":if limit.has_sum(){2}else{0},"actual_http_reads":2,"reopened_replay_preserves_attempt_and_counter_bytes":true,"reopened_replay_leases_and_sends_nothing":true}) +} + +fn matrix(backend: Backend) { + let cases: Vec<_> = [Limit::Count, Limit::Bytes, Limit::Both] + .into_iter() + .map(|limit| one_case(backend, limit)) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-window-capacity/1","adapter":backend.label(),"scope":"full native acquisition engine; signed bounded grants, exact approval, separate native OS workers and local custody, actual common adapter transactions and HTTP; fixed public fixture keys and maintained test clock","excluded":["mutation/disclosure fixed-window contention","cross-window expiry and clock rollback","partial batch and durability faults","human review UI and hostile OS containment","provider qualification"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-window-capacity-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} + +#[test] +fn native_file_window_capacity_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_window_capacity_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index e00d77e20..757b1a017 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -4,7 +4,9 @@ #![cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] use crate::effect::{CONTENT_READ_TOOL, ExactEffectApproval, fixture_policy}; -use crate::harness::authoring::{tool_fixture_until, tools_context}; +use crate::harness::authoring::{ + ToolFixture, tool_fixture_until, tool_fixture_using_policy, tools_context, +}; use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; use crate::{ AcquisitionSnapshot, AcquisitionStage, CompiledRecipe, GatewayAttempts, GatewayEngine, @@ -177,6 +179,31 @@ pub(super) async fn authorize_bounded( .await .expect("native call"); let signed = tool_fixture_until(&call, NOW, authority_until).expect("native authority"); + save_authorization(engine, root, operation, signed, approval_until).await; +} + +pub(super) async fn authorize_policy( + engine: &GatewayEngine, + root: &Path, + operation: &str, + policy: &crate::ArgumentCeilingPolicy, +) { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) + .await + .expect("native call"); + let signed = tool_fixture_using_policy(&call, NOW, NOW + 86_400, Some(policy)) + .expect("native bounded authority"); + save_authorization(engine, root, operation, signed, NOW + 300).await; +} + +async fn save_authorization( + engine: &GatewayEngine, + root: &Path, + operation: &str, + signed: ToolFixture, + approval_until: u64, +) { assert_eq!(signed.context, trust(&recipe())); let effect = engine .compile_content_action(&signed.proof, &signed.action) @@ -297,7 +324,12 @@ impl Drop for Provider { } } } -struct Peer(Child); +pub(super) struct Peer(Child); +impl Peer { + pub(super) fn id(&self) -> u32 { + self.0.id() + } +} impl Drop for Peer { fn drop(&mut self) { let _ = self.0.kill(); @@ -334,7 +366,7 @@ fn native_capacity_peer() { ); } -fn start_peer(input: &Path, operation: &str) -> Peer { +pub(super) fn start_peer(input: &Path, operation: &str) -> Peer { Peer( Command::new(std::env::current_exe().expect("test binary")) .args([ @@ -351,7 +383,7 @@ fn start_peer(input: &Path, operation: &str) -> Peer { .expect("peer"), ) } -fn finish_peer(peer: &mut Peer) { +pub(super) fn finish_peer(peer: &mut Peer) { let deadline = Instant::now() + Duration::from_secs(30); loop { if let Some(status) = peer.0.try_wait().expect("peer status") { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 759333da5..833f48ea6 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0d030da904106d7744e7d26564f1d026342dd903ee3b619d0a58249d3a92ec83"; + "bd58988e9726c5ebb189467eb929bf44d8d8c1cbfa8f899b49f70af7877288ce"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index d45a47e1b..9eb10d2f7 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 396 +freeze_version = 397 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 396 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 142 +"auths.identity.protocol" = 143 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 396 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 139 +"auths.product.public-sdk-contract" = 140 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 396 +"auths.release.public-surface" = 397 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 85134f75d..00ea8d623 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 396, + "freezeVersion": 397, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 142, + "version": 143, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "693b70eec4a41bff2b2261d78ca3fcca594d01fd493de424d0cdb7a8c81d6bd9" + "sha256": "6db93f3d0214a97c758a857cfffa862ae68c444c862995b2e3ef0f318985ae5e" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 139, + "version": 140, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "b67cc30af766ad3ce538b3b1c3bd36327b089c56fae8614de186150df456f3ac" + "sha256": "90b969afaf0b1311c36ac7724e254424d90589dc5a8c9378091242706599600c" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 396, + "version": 397, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "0ec1769915891988834ebeec2f34e44fcdd27e6e52e40fd39e212f89268dcfa9" + "sha256": "5e5f8018e71f481fb105c2af986ac98c9cafbdb4bdfa26441369ad8a2576e37d" } ] } From 0a26acb342fb3d7391273f09e25df4670a031d3f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 11:26:37 +0000 Subject: [PATCH 075/136] test(gateway): inject native file transaction and acknowledgement faults --- .github/workflows/postgres-lifecycle.yml | 1 + .../gateway/native-file-io-faults.json | 451 ++++++++++++++ compliance.toml | 1 + docs/plans/0074-implementation-status.md | 49 +- ...ound-effects-and-recovery-state-machine.md | 12 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../src/native_file_fault_tests.rs | 581 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 8 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 131 +++- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 13 files changed, 1229 insertions(+), 34 deletions(-) create mode 100644 bindings/fixtures/gateway/native-file-io-faults.json create mode 100644 product/runtime/auths-gateway/src/native_file_fault_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index d2bd2e664..7eba187e0 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -49,6 +49,7 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-file-io-faults.json b/bindings/fixtures/gateway/native-file-io-faults.json new file mode 100644 index 000000000..0d7a673fe --- /dev/null +++ b/bindings/fixtures/gateway/native-file-io-faults.json @@ -0,0 +1,451 @@ +{ + "schema": "auths.native-file-io-faults/1", + "scope": "full native acquisition engine in separate worker OS processes; actual maintained file writer fence, four-record admission batches, rollback/reopen, signed bounded grants, fixed-key exact approvals, separate local custody and real HTTP; failed I/O return is simulated at the native adapter call site", + "excluded": [ + "actual kernel/device EIO or power loss", + "PostgreSQL partial batches and ambiguous commit delivery", + "mutation/disclosure fault matrices", + "whole-store rollback and hostile OS containment", + "live provider qualification or human review" + ], + "cases": [ + { + "schedule": { + "phase": "admission", + "point": "data-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "install-batch", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "install-target", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "install-target", + "skip": 1 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "install-target", + "skip": 2 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "install-target", + "skip": 3 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "directory-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "directory-sync", + "skip": 1 + }, + "injected_io_failures": 1, + "phase_after_failure": null, + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "point": "directory-sync", + "skip": 2 + }, + "injected_io_failures": 1, + "phase_after_failure": "reserved", + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "entry", + "point": "data-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "reserved", + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "entry", + "point": "replace", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "reserved", + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": true, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "entry", + "point": "directory-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "entry-granted", + "actual_reads_before_reopen": 0, + "new_native_execution_permitted": false, + "actual_reads_after_reopen": 0, + "native_history": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "response", + "point": "data-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "entry-granted", + "actual_reads_before_reopen": 1, + "new_native_execution_permitted": false, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "response", + "point": "replace", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "entry-granted", + "actual_reads_before_reopen": 1, + "new_native_execution_permitted": false, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "response", + "point": "directory-sync", + "skip": 0 + }, + "injected_io_failures": 1, + "phase_after_failure": "content-response-recorded", + "actual_reads_before_reopen": 1, + "new_native_execution_permitted": false, + "actual_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_slot_and_sum_slot": true, + "terminal_replay_preserves_journal_and_execution_witness": true, + "signed_inputs_unchanged": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 6787bd59d..6dcd83833 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1810,6 +1810,7 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index e5552321e..d57135e44 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1999,6 +1999,53 @@ closure regeneration passed after that correction (one artifact-generation test) inventory update. No portable wire change, new formal proof or completed acceptance claim follows from these source identity updates. +## Native file I/O failure checkpoint + +- `FileGatewayAttemptStore` has private `cfg(test)` failure state and hooks at + its actual data-sync, rollback-journal installation, batch-target installation, + replacement and directory-sync call sites. Production builds contain no + selector/state, environment switch or selectable failure behavior. Native + record decisions and every preceding successful filesystem operation are + unchanged; the selected failing I/O return is simulated rather than produced + by an actual faulty kernel/device. +- `native_file_fault_tests.rs` authors fifteen full native acquisition schedules + in independent worker OS processes, using signed bounded resource grants, + separate exact approvals/custody and real local HTTP. A transparent scheduling + wrapper arms the adapter only after the unmodified native decision under the + real writer fence. It cannot manufacture a reservation or entry permit. +- The admission matrix covers sync/install of the rollback journal, each of + four target-install prefixes (attempt, lifetime allocation, count, byte sum), + and each of three directory acknowledgements. Entry and response each exercise + data sync, replacement and directory acknowledgement. Authoritative reopen, + native history, all-or-none charges, immutable signed inputs, actual provider + requests and execution witnesses distinguish rollback, resumable reservation, + charged lost-grant unknown and retained response evidence. +- Authored assertions require a partial batch to leave no attempt/allocation/ + count/sum targets; a committed reservation may progress only through native + fresh checks; a visible grant after failed acknowledgement cannot produce a + new permit. Unknown outcomes remain charged even when no HTTP request was + made. Terminal replay preserves every journal JSON byte and performs no new + lease or HTTP request. Required artifact generation passed all fifteen + schedules in 3.37 seconds. The first run encountered the local HTTP double's + existing two-second header deadline on a heavily contended host and correctly + projected Unknown; its positive-resume assertion failed. The test executor + pool is now bounded to two threads per process instead of multiplying the + host's CPU count. No native deadline, assertion or security invariant changed. + Strict gateway library/test lint passed without suppressions. After source + closure regeneration and rebuild, fourteen selected native artifact/helper/ + closure tests passed without update mode in 6.37 seconds. The two adapter + lifetime/fixed-window capacity, crash and dependency matrices stayed byte- + identical with the bounded test executor. The dedicated TLS fixture's + containers/network/volume were stopped and removed after verification. +- These schedules do not establish actual device EIO/power loss, PostgreSQL + partial-batch/ambiguous-commit delivery or the complete mutation/disclosure + fault matrices. No acceptance condition is waived, and A06 remains incomplete. + +- Release freeze398 advances identity protocol144, public SDK contract141 and + public surface398 for the generator-reported source/inventory changes. The + regenerated gateway closure includes the fault instrumentation and matrix. + Hosted exact-head verification and the complete A06 gate remain required. + ## Phase gates | Phase | State | Outstanding gate | @@ -2022,7 +2069,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Pending / no / no | Fault injection | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O call-site failure matrix / fifteen independent native worker histories generated and executed | PostgreSQL transaction/commit delivery, complete mutation/disclosure schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 3eb0e46e3..ad3003e0b 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -714,6 +714,18 @@ charges and exact record bytes without another lease or HTTP request. These acquisition cases do not replace mutation/disclosure fixed-window evidence, cross-window expiry, partial-batch faults or the other A04/A06 requirements. +The `native-file-io-faults.json` generator exercises fifteen injected file-adapter +failure schedules in independent native worker processes. A test-only call-site +hook returns an I/O failure at data sync, journal/target installation, record +replacement or directory acknowledgement after the preceding real operations. +The four-record bounded admission batch must recover all-or-none; a retained +reservation can resume only through fresh native entry checks; a retained grant +after a lost acknowledgement cannot mint another permit. Reopened terminal +history must preserve all charges and journal bytes without a new lease or HTTP +request. The failed I/O return is simulated, and production builds contain no +selector. Actual device faults/power loss, PostgreSQL commit delivery and the +complete mutation/disclosure fault matrix remain separate requirements. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 51da78942..1904a3902 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"33858f37d34122b37154a6b2338a0016ae791189b32e157b82db5e974f5ceb77"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"4b20147614f4fd2669c3ffa30820ad04d27f20d830e8bc7868725af0a9113e4d"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"5cb53ef4eb29412c9be4f80484f7bc359aa70ca3c9d40f217be24f7f3726c7af"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"418de3db1bcfede305db78182bc62a5f5f554b771d1b02c4ad692fe8225ec391"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"6b1f68f703f00899036517c778037ffa5e15ce51265090878519689470e0255d"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 15e91c846..8b1beea58 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -166,3 +166,6 @@ mod native_dependency_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_budget_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_file_fault_tests; diff --git a/product/runtime/auths-gateway/src/native_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_file_fault_tests.rs new file mode 100644 index 000000000..22d276301 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_file_fault_tests.rs @@ -0,0 +1,581 @@ +//! Injected errors at file adapter I/O boundaries under actual native decisions. +//! The failed syscall is simulated; real preceding writes, fences, rollback, +//! native verification, custody and HTTP run in independent OS processes. +use crate::native_process_tests::{ + NOW, Provider, Setup, acquire, authorize_policy, load_engine, private, recipe, runtime, +}; +use crate::store::{FileIoPoint, GatewayFenceDecision}; +use crate::store_testkit::{Backend, TestAttempts}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ArgumentCeilingPolicy, ContentHistory, + FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptKey, GatewayAttemptStore, + GatewayAttempts, GatewayExecutionWitness, GatewayInsert, GatewayRecordEntry, GatewayRecordKind, + GatewaySubmitResult, LogicalOperationId, SharedConnection, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + collections::BTreeMap, + io::Read as _, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + process::{Child, Command, Stdio}, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, + thread, + time::{Duration, Instant}, +}; + +const OPERATION: &str = "file-fault-read"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Phase { + Admission, + Entry, + Response, +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + point: FileIoPoint, + skip: usize, +} +impl Schedule { + fn all() -> Vec { + let mut schedules = vec![ + Self { + phase: Phase::Admission, + point: FileIoPoint::DataSync, + skip: 0, + }, + Self { + phase: Phase::Admission, + point: FileIoPoint::InstallBatch, + skip: 0, + }, + ]; + for skip in 0..4 { + schedules.push(Self { + phase: Phase::Admission, + point: FileIoPoint::InstallTarget, + skip, + }); + } + for skip in 0..3 { + schedules.push(Self { + phase: Phase::Admission, + point: FileIoPoint::DirectorySync, + skip, + }); + } + for phase in [Phase::Entry, Phase::Response] { + for point in [ + FileIoPoint::DataSync, + FileIoPoint::Replace, + FileIoPoint::DirectorySync, + ] { + schedules.push(Self { + phase, + point, + skip: 0, + }); + } + } + assert_eq!(schedules.len(), 15); + schedules + } + const fn decision(self) -> &'static str { + match self.phase { + Phase::Admission => "reserved", + Phase::Entry => "entry-granted", + Phase::Response => "content-response-recorded", + } + } + const fn retained_phase(self) -> Option<&'static str> { + match self.phase { + Phase::Admission => { + if matches!(self.point, FileIoPoint::DirectorySync) && self.skip == 2 { + Some("reserved") + } else { + None + } + } + Phase::Entry => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("entry-granted") + } else { + Some("reserved") + } + } + Phase::Response => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("content-response-recorded") + } else { + Some("entry-granted") + } + } + } + } + fn resumable(self) -> bool { + matches!(self.retained_phase(), None | Some("reserved")) + } + fn requests(self) -> usize { + usize::from(matches!(self.phase, Phase::Response)) + } + fn public_stage(self) -> AcquisitionStage { + match self.retained_phase() { + Some("reserved") => AcquisitionStage::Reserved, + Some("content-response-recorded") => AcquisitionStage::ResponseRecorded, + _ => AcquisitionStage::Unknown, + } + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct FaultSetup { + installation: Setup, + schedule: Schedule, +} +fn operation_key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") +} + +struct FailureStore { + inner: Arc, + schedule: Schedule, + armed: AtomicBool, +} +impl FailureStore { + fn arm( + &self, + kind: GatewayRecordKind, + key: GatewayAttemptKey, + bytes: &[u8], + ) -> Result<(), GatewayAttemptError> { + if kind == GatewayRecordKind::Attempt && key == operation_key() { + let value: Value = serde_json::from_slice(bytes).expect("unchanged native decision"); + if value["state"]["facts"]["phase"]["stage"] == self.schedule.decision() + && !self.armed.swap(true, Ordering::SeqCst) + { + self.inner + .arm_io_failure(self.schedule.point, self.schedule.skip)?; + } + } + Ok(()) + } +} +impl GatewayAttemptStore for FailureStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + self.inner + .fenced_insert_all(entries, dependencies, &mut |snapshots| { + let next = decide(snapshots)?; + self.arm(entries[0].kind, entries[0].key, &next)?; + Ok(next) + }) + } + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + self.inner.fenced_replace(keys, &mut |snapshots| { + let next = decide(snapshots)?; + self.arm(keys[0].0, keys[0].1, &next)?; + Ok(next) + }) + } + fn replace( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + self.arm(kind, *key, next)?; + self.inner.replace(kind, key, current, next) + } + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.inner.insert_all(entries) + } + fn load( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + self.inner.load(kind, key) + } + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.inner.sweep_expired(now, limit) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.inner.attempt_keys(limit) + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + injected: usize, + result: Result, + witness: GatewayExecutionWitness, +} + +#[test] +fn native_file_fault_peer() { + let Some(input) = std::env::var_os("AUTHS_AP074_FILE_FAULT_PEER") else { + return; + }; + let setup: FaultSetup = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("closed setup"); + let store = Arc::new( + FileGatewayAttemptStore::open(&setup.installation.location).expect("file adapter"), + ); + let failure = Arc::new(FailureStore { + inner: store.clone(), + schedule: setup.schedule, + armed: AtomicBool::new(false), + }); + let attempts = GatewayAttempts::new(failure, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine(&setup.installation, "worker", attempts)); + let result = runtime.block_on(acquire(&engine, &setup.installation.root, OPERATION)); + let answer = WorkerResult { + injected: store.injected_io_failures().expect("fault witness"), + result, + witness: engine.execution_witness(), + }; + private( + &setup.installation.root.join("worker-result"), + &serde_json::to_vec(&answer).expect("result"), + ); +} + +struct Peer(Child); +impl Drop for Peer { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} +fn execute(setup: &FaultSetup) -> WorkerResult { + let input = setup.installation.root.join("fault-setup.json"); + private(&input, &serde_json::to_vec(setup).expect("setup")); + let mut peer = Peer( + Command::new(std::env::current_exe().expect("test executable")) + .args([ + "--exact", + "native_file_fault_tests::native_file_fault_peer", + "--nocapture", + ]) + .env("AUTHS_AP074_FILE_FAULT_PEER", input) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("native peer"), + ); + let deadline = Instant::now() + Duration::from_secs(20); + loop { + if let Some(status) = peer.0.try_wait().expect("status") { + let mut diagnostic = String::new(); + peer.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "native worker: {diagnostic}"); + break; + } + assert!(Instant::now() < deadline, "native worker deadline"); + thread::sleep(Duration::from_millis(2)); + } + serde_json::from_slice( + &std::fs::read(setup.installation.root.join("worker-result")).expect("worker result"), + ) + .expect("native result") +} + +fn journal_files(path: &Path) -> BTreeMap> { + std::fs::read_dir(path) + .expect("directory") + .map(|entry| { + let entry = entry.expect("entry"); + ( + entry.file_name().into_string().expect("file name"), + entry.path(), + ) + }) + .filter(|(_, path)| { + path.extension() + .is_some_and(|extension| extension.eq_ignore_ascii_case("json")) + }) + .map(|(name, path)| (name, std::fs::read(path).expect("record bytes"))) + .collect() +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: FaultSetup, + provider: Provider, + signed: Vec>, +} +impl Case { + fn new(schedule: Schedule) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private mode"); + let store = TestAttempts::open(Backend::File); + let provider = Provider::controlled(None); + let setup = FaultSetup { + schedule, + installation: Setup { + backend: "file".to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }, + }; + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_engine( + &setup.installation, + "parent", + store.attempts().clone(), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("published connection"); + engine + .initialize_effect_configuration() + .expect("installed configuration"); + let policy = ArgumentCeilingPolicy::new("maximum_response_bytes", 1024, 3600, 4) + .expect("count") + .with_sum(4096, None) + .expect("sum"); + runtime.block_on(authorize_policy( + &engine, + &setup.installation.root, + OPERATION, + &policy, + )); + let signed = Self::inputs(&setup); + Self { + _directory: directory, + store, + setup, + provider, + signed, + } + } + fn inputs(setup: &FaultSetup) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| { + std::fs::read( + setup + .installation + .root + .join(format!("{OPERATION}.{suffix}")), + ) + .expect("signed inputs") + }) + .to_vec() + } + fn raw(&self) -> Option> { + self.store + .raw() + .load(GatewayRecordKind::Attempt, &operation_key()) + .expect("load") + } + fn check_initial(&self, worker: &WorkerResult) { + assert_eq!( + worker.injected, 1, + "one actual adapter failure site reached" + ); + assert_eq!( + self.provider.calls.load(Ordering::SeqCst), + self.setup.schedule.requests() + ); + assert_eq!( + worker.witness.read_transport_entries, + self.setup.schedule.requests() as u64 + ); + assert_eq!(worker.witness.write_transport_entries, 0); + assert_eq!( + worker.witness.credential_lease_calls, + u64::from(!matches!(self.setup.schedule.phase, Phase::Admission)) + ); + assert_eq!(Self::inputs(&self.setup), self.signed); + let raw = self.raw(); + if let Some(phase) = self.setup.schedule.retained_phase() { + let record: Value = serde_json::from_slice(raw.as_ref().expect("retained record")) + .expect("native record"); + assert_eq!(record["state"]["facts"]["phase"]["stage"], phase); + assert_eq!(record["state"]["facts"]["allocation"], 0); + assert_eq!( + record["state"]["facts"]["counters"] + .as_array() + .expect("counters") + .len(), + 2 + ); + assert_eq!(record["evaluated_at"], NOW); + assert_eq!(!record["entry"].is_null(), phase != "reserved"); + let snapshot = worker.result.as_ref().expect("native retained projection"); + assert_eq!(snapshot.stage, self.setup.schedule.public_stage()); + assert_eq!( + (snapshot.reserved_calls, snapshot.reserved_bytes), + (1, 1024) + ); + assert_eq!( + ( + snapshot.policy_count_counters, + snapshot.policy_byte_counters + ), + (1, 1) + ); + } else { + assert!( + raw.is_none(), + "all unacknowledged batch targets rolled back" + ); + assert!( + matches!(&worker.result, Err(GatewaySubmitResult::Indeterminate { code }) if code == "gateway.attempt.state-unavailable") + ); + } + let files = journal_files(Path::new(&self.setup.installation.location)); + assert!( + !files.contains_key(".batch.json"), + "recovery removes the rollback marker" + ); + let expected = usize::from(self.setup.schedule.retained_phase().is_some()); + for prefix in ["claim-", "allocation-", "slot-", "sum-"] { + assert_eq!( + files.keys().filter(|name| name.starts_with(prefix)).count(), + expected, + "all-or-none charge: {prefix}" + ); + } + } + fn reopen(&self) -> Value { + let before = journal_files(Path::new(&self.setup.installation.location)); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine( + &self.setup.installation, + "reopened", + self.store.reopen(), + )); + if self.setup.schedule.retained_phase().is_some() { + match runtime + .block_on(engine.content_history(OPERATION)) + .expect("native history") + { + ContentHistory::Acquisition(history) => { + assert_eq!(history.stage, self.setup.schedule.public_stage()); + } + ContentHistory::Disclosure(_) => panic!("wrong protocol"), + } + } + let witness = engine.execution_witness(); + let result = runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("native replay"); + assert_eq!( + result.stage, + if self.setup.schedule.resumable() { + AcquisitionStage::ResponseRecorded + } else { + self.setup.schedule.public_stage() + } + ); + assert_eq!((result.reserved_calls, result.reserved_bytes), (1, 1024)); + assert_eq!( + (result.policy_count_counters, result.policy_byte_counters), + (1, 1) + ); + if !self.setup.schedule.resumable() { + assert_eq!( + engine.execution_witness(), + witness, + "lost acknowledgement cannot grant again" + ); + assert_eq!( + journal_files(Path::new(&self.setup.installation.location)), + before + ); + } + let calls = self.setup.schedule.requests() + usize::from(self.setup.schedule.resumable()); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), calls); + let retained = journal_files(Path::new(&self.setup.installation.location)); + let witness = engine.execution_witness(); + assert_eq!( + runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("second replay"), + result + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), calls); + assert_eq!( + journal_files(Path::new(&self.setup.installation.location)), + retained + ); + for prefix in ["claim-", "allocation-", "slot-", "sum-"] { + assert_eq!( + retained + .keys() + .filter(|name| name.starts_with(prefix)) + .count(), + 1, + "no repeated charge" + ); + } + json!({"schedule":self.setup.schedule,"injected_io_failures":1,"phase_after_failure":self.setup.schedule.retained_phase(),"actual_reads_before_reopen":self.setup.schedule.requests(),"new_native_execution_permitted":self.setup.schedule.resumable(),"actual_reads_after_reopen":calls,"native_history":result,"one_allocation_count_slot_and_sum_slot":true,"terminal_replay_preserves_journal_and_execution_witness":true,"signed_inputs_unchanged":true}) + } +} + +#[test] +fn native_file_io_fault_fixture_is_current() { + let cases: Vec<_> = Schedule::all() + .into_iter() + .map(|schedule| { + let case = Case::new(schedule); + let worker = execute(&case.setup); + case.check_initial(&worker); + case.reopen() + }) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-file-io-faults/1","scope":"full native acquisition engine in separate worker OS processes; actual maintained file writer fence, four-record admission batches, rollback/reopen, signed bounded grants, fixed-key exact approvals, separate local custody and real HTTP; failed I/O return is simulated at the native adapter call site","excluded":["actual kernel/device EIO or power loss","PostgreSQL partial batches and ambiguous commit delivery","mutation/disclosure fault matrices","whole-store rollback and hostile OS containment","live provider qualification or human review"],"cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-file-io-faults.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index 757b1a017..19f3a6eb0 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -68,7 +68,13 @@ fn trust(recipe: &CompiledRecipe) -> Vec { tools_context(&[call], NOW).expect("native trust") } pub(super) fn runtime() -> tokio::runtime::Runtime { - tokio::runtime::Runtime::new().expect("runtime") + // Each case also creates independent OS workers. Bound test executor + // resources rather than multiplying the host's reported CPU count. + tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .expect("runtime") } pub(super) struct EngineControls { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 833f48ea6..4c32b409c 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "bd58988e9726c5ebb189467eb929bf44d8d8c1cbfa8f899b49f70af7877288ce"; + "0ac73c216168574de2f33c0a08c9f7156a1cdcb9e4343366d4992d797bc0ea5b"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 968b6639d..0b7ad0a1b 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -1416,6 +1416,28 @@ pub trait GatewayAttemptStore: Send + Sync { /// batch never returned, so its targets are deleted. pub struct FileGatewayAttemptStore { root: PathBuf, + #[cfg(test)] + io_fault: std::sync::Mutex, +} + +/// Private test-only failures at the actual adapter's I/O call sites. Shipping +/// builds contain neither the selector nor mutable fault state. +#[cfg(test)] +#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub(crate) enum FileIoPoint { + DataSync, + InstallBatch, + InstallTarget, + Replace, + DirectorySync, +} + +#[cfg(test)] +#[derive(Default)] +struct FileIoFault { + pending: Option<(FileIoPoint, usize)>, + injected: usize, } #[derive(Deserialize, Serialize)] @@ -1480,7 +1502,11 @@ impl FileGatewayAttemptStore { PrivateDirectoryError::Unavailable(_) => GatewayAttemptError::Unavailable, _ => GatewayAttemptError::UnsafeDirectory, })?; - let store = Self { root }; + let store = Self { + root, + #[cfg(test)] + io_fault: std::sync::Mutex::default(), + }; store.recover()?; Ok(store) } @@ -1553,11 +1579,67 @@ impl FileGatewayAttemptStore { NamedTempFile::new_in(&self.root).map_err(|_| GatewayAttemptError::Unavailable)?; pending .write_all(bytes) - .and_then(|()| pending.as_file().sync_all()) + .map_err(|_| GatewayAttemptError::Unavailable)?; + #[cfg(test)] + self.io_failure(FileIoPoint::DataSync)?; + pending + .as_file() + .sync_all() .map_err(|_| GatewayAttemptError::Unavailable)?; Ok(pending) } + fn sync_root(&self) -> Result<(), GatewayAttemptError> { + #[cfg(test)] + self.io_failure(FileIoPoint::DirectorySync)?; + sync_directory(&self.root) + } + + #[cfg(test)] + fn io_failure(&self, point: FileIoPoint) -> Result<(), GatewayAttemptError> { + let mut fault = self + .io_fault + .lock() + .map_err(|_| GatewayAttemptError::Unavailable)?; + if let Some((selected, skip)) = &mut fault.pending + && *selected == point + { + if *skip > 0 { + *skip -= 1; + } else { + fault.pending = None; + fault.injected += 1; + return Err(GatewayAttemptError::Unavailable); + } + } + Ok(()) + } + + #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn arm_io_failure( + &self, + point: FileIoPoint, + skip: usize, + ) -> Result<(), GatewayAttemptError> { + let mut fault = self + .io_fault + .lock() + .map_err(|_| GatewayAttemptError::Unavailable)?; + if fault.pending.is_some() { + return Err(GatewayAttemptError::Conflict); + } + fault.pending = Some((point, skip)); + Ok(()) + } + + #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn injected_io_failures(&self) -> Result { + self.io_fault + .lock() + .map(|fault| fault.injected) + .map_err(|_| GatewayAttemptError::Unavailable) + } + fn load_locked( &self, kind: GatewayRecordKind, @@ -1669,9 +1751,9 @@ impl FileGatewayAttemptStore { fs::remove_file(&target_path).map_err(|_| GatewayAttemptError::Unavailable)?; } } - sync_directory(&self.root)?; + self.sync_root()?; fs::remove_file(&path).map_err(|_| GatewayAttemptError::Unavailable)?; - sync_directory(&self.root) + self.sync_root() } fn insert_batch( @@ -1717,31 +1799,37 @@ impl FileGatewayAttemptStore { .collect(), })?; admission_deadline(started)?; - self.pending(&batch)? + let pending = self.pending(&batch)?; + #[cfg(test)] + self.io_failure(FileIoPoint::InstallBatch)?; + pending .persist_noclobber(self.root.join(BATCH_FILE)) .map_err(|_| GatewayAttemptError::Unavailable)?; - sync_directory(&self.root)?; + self.sync_root()?; if crash == Some(BatchCrash::AfterBatchFile) { return Ok(GatewayInsert::Inserted); } for (index, (name, bytes)) in files.iter().enumerate() { if crash == Some(BatchCrash::AfterTargets(index)) { - sync_directory(&self.root)?; + self.sync_root()?; return Ok(GatewayInsert::Inserted); } admission_deadline(started)?; - self.pending(bytes)? + let pending = self.pending(bytes)?; + #[cfg(test)] + self.io_failure(FileIoPoint::InstallTarget)?; + pending .persist_noclobber(self.root.join(name)) .map_err(|_| GatewayAttemptError::Unavailable)?; } - sync_directory(&self.root)?; + self.sync_root()?; if crash == Some(BatchCrash::BeforeBatchDelete) { return Ok(GatewayInsert::Inserted); } admission_deadline(started)?; fs::remove_file(self.root.join(BATCH_FILE)) .map_err(|_| GatewayAttemptError::Unavailable)?; - sync_directory(&self.root)?; + self.sync_root()?; Ok(GatewayInsert::Inserted) } @@ -1853,10 +1941,12 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { if started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE { return Err(GatewayAttemptError::Unavailable); } + #[cfg(test)] + self.io_failure(FileIoPoint::Replace)?; pending .persist(self.path_for(keys[0].0, &keys[0].1)) .map_err(|_| GatewayAttemptError::Unavailable)?; - sync_directory(&self.root) + self.sync_root() } fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { @@ -1874,11 +1964,11 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { validate_batch(std::slice::from_ref(entry))?; let bytes = Self::file_bytes(entry)?; let _lock = self.exclusive()?; - match self - .pending(&bytes)? - .persist_noclobber(self.path_for(entry.kind, &entry.key)) - { - Ok(_) => sync_directory(&self.root), + let pending = self.pending(&bytes)?; + #[cfg(test)] + self.io_failure(FileIoPoint::InstallTarget)?; + match pending.persist_noclobber(self.path_for(entry.kind, &entry.key)) { + Ok(_) => self.sync_root(), Err(error) if error.error.kind() == std::io::ErrorKind::AlreadyExists => { Err(GatewayAttemptError::Replay) } @@ -1913,10 +2003,13 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { if Self::read_file(&path, MAX_RECORD_BYTES)?.as_deref() != Some(current) { return Err(GatewayAttemptError::Conflict); } - self.pending(next)? + let pending = self.pending(next)?; + #[cfg(test)] + self.io_failure(FileIoPoint::Replace)?; + pending .persist(&path) .map_err(|_| GatewayAttemptError::Unavailable)?; - sync_directory(&self.root) + self.sync_root() } fn sweep_expired(&self, now: u64, limit: usize) -> Result { @@ -1948,7 +2041,7 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { } } if deleted > 0 { - sync_directory(&self.root)?; + self.sync_root()?; } Ok(deleted) } diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 9eb10d2f7..bf92b23c9 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 397 +freeze_version = 398 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 397 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 143 +"auths.identity.protocol" = 144 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 397 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 140 +"auths.product.public-sdk-contract" = 141 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 397 +"auths.release.public-surface" = 398 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 00ea8d623..1438b4486 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 397, + "freezeVersion": 398, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 143, + "version": 144, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "6db93f3d0214a97c758a857cfffa862ae68c444c862995b2e3ef0f318985ae5e" + "sha256": "53d28ffae974baa7dc43c34351dfce88727018707590c7131ae0e27e6cd49692" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 140, + "version": 141, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "90b969afaf0b1311c36ac7724e254424d90589dc5a8c9378091242706599600c" + "sha256": "d39f83179fc630d005285fc7608bde6a633ba7e477cc3cb7900f051640fd66d6" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 397, + "version": 398, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "5e5f8018e71f481fb105c2af986ac98c9cafbdb4bdfa26441369ad8a2576e37d" + "sha256": "6a26a1516f08d8d763a8cdef710524e223f07b58bf16b132698935365b8e01cd" } ] } From 0c3494b83abaf46958fbdc9f7e034ad8e4b35eee Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 11:34:16 +0000 Subject: [PATCH 076/136] test(gateway): prove PostgreSQL admission rollback at every inserted row --- .github/workflows/postgres-lifecycle.yml | 1 + .../native-postgres-partial-batch.json | 117 ++++++++ compliance.toml | 1 + docs/plans/0074-implementation-status.md | 40 ++- ...ound-effects-and-recovery-state-machine.md | 9 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../src/native_postgres_fault_tests.rs | 250 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 4 + .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/src/store_testkit.rs | 75 ++++++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 13 files changed, 512 insertions(+), 14 deletions(-) create mode 100644 bindings/fixtures/gateway/native-postgres-partial-batch.json create mode 100644 product/runtime/auths-gateway/src/native_postgres_fault_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 7eba187e0..6537bca49 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -50,6 +50,7 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-postgres-partial-batch.json b/bindings/fixtures/gateway/native-postgres-partial-batch.json new file mode 100644 index 000000000..4bc6f87b9 --- /dev/null +++ b/bindings/fixtures/gateway/native-postgres-partial-batch.json @@ -0,0 +1,117 @@ +{ + "schema": "auths.native-postgres-partial-batch/1", + "scope": "full native acquisition engine in separate worker OS processes, actual TLS PostgreSQL transactions and server-side insert exceptions, nontransactional sequence witnesses, signed bounded authority/exact approval, separate local custody and real local HTTP; fixed public test keys and maintained clock", + "excluded": [ + "commit acknowledgement or network delivery ambiguity", + "PostgreSQL server/power failure", + "mutation/disclosure transaction fault matrices", + "whole-store rollback or hostile OS containment", + "human review or provider qualification" + ], + "cases": [ + { + "server_rejected_insert": 1, + "prior_successful_insert_prefix": 0, + "server_insert_sequence": 1, + "all_admission_rows_rolled_back": true, + "failed_worker_leases_and_transport_entries": 0, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "actual_http_reads": 1, + "allocation_count_slot_and_sum_slot": 1, + "terminal_replay_preserves_attempt_and_execution_witness": true + }, + { + "server_rejected_insert": 2, + "prior_successful_insert_prefix": 1, + "server_insert_sequence": 2, + "all_admission_rows_rolled_back": true, + "failed_worker_leases_and_transport_entries": 0, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "actual_http_reads": 1, + "allocation_count_slot_and_sum_slot": 1, + "terminal_replay_preserves_attempt_and_execution_witness": true + }, + { + "server_rejected_insert": 3, + "prior_successful_insert_prefix": 2, + "server_insert_sequence": 3, + "all_admission_rows_rolled_back": true, + "failed_worker_leases_and_transport_entries": 0, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "actual_http_reads": 1, + "allocation_count_slot_and_sum_slot": 1, + "terminal_replay_preserves_attempt_and_execution_witness": true + }, + { + "server_rejected_insert": 4, + "prior_successful_insert_prefix": 3, + "server_insert_sequence": 4, + "all_admission_rows_rolled_back": true, + "failed_worker_leases_and_transport_entries": 0, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "actual_http_reads": 1, + "allocation_count_slot_and_sum_slot": 1, + "terminal_replay_preserves_attempt_and_execution_witness": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 6dcd83833..031c7b01d 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1811,6 +1811,7 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", + "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d57135e44..f4f9cba1a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2046,6 +2046,44 @@ closure regeneration passed after that correction (one artifact-generation test) regenerated gateway closure includes the fault instrumentation and matrix. Hosted exact-head verification and the complete A06 gate remain required. +## Native PostgreSQL partial-admission checkpoint + +- `native_postgres_fault_tests.rs` exercises four real server-side failure + histories through independent native gateway worker processes and the + maintained TLS PostgreSQL adapter. A trigger in each locally owned, isolated + test schema raises an exception on insert1,2,3 or4 of the actual four-record + admission batch. No shipping adapter fault switch, forged decision or alternate + authorization path is introduced. All source/proof/approval/custody and local + HTTP composition is the same native path as the capacity cases. +- A PostgreSQL sequence survives transaction rollback and witnesses exactly the + rejected insert number. Thus each schedule proves the reached server row + prefix, including earlier successful inserts, rather than merely returning a + synthetic adapter error. After the exception, native history is unavailable + and direct server counts show no attempt, lifetime allocation, count slot or + byte-sum slot. The child execution witness and independent HTTP counter both + show no custody lease or external entry. +- The trigger is removed only after the failed worker exits. A reopened native + engine revalidates the unchanged signed inputs under the same logical operation + and produces one response, one lifetime allocation, one count slot and one + byte-sum slot. Exact terminal replay preserves the attempt bytes and execution + witness, with no second HTTP request or charge. Temporary trigger/sequence + objects remain confined to the owned schema that the fixture drops. +- Required artifact generation passed four histories in 4.72 seconds. Exact + feature-gated PostgreSQL CI invocation and consumer evidence anchors include + the new matrix. Strict gateway library/test lint passed without suppressions. + After closure regeneration and rebuild, all fifteen selected native artifact, + helper and closure cases passed without update mode in 6.15 seconds. Existing + capacity, crash, dependency, fixed-window and file-fault artifacts remained + byte-identical after adding the private peer execution witness. The dedicated + TLS containers/network/volume were stopped and removed after verification. + This is transaction-abort/partial-batch evidence, not ambiguous commit delivery, + server/power failure or the complete mutation/disclosure fault matrix. A06 + remains partial and no acceptance requirement is weakened. + +- Release freeze399 advances the reported identity protocol145, public SDK + contract142 and public surface399 subjects. Fresh hosted exact-head evidence + remains required; source-identity counters are not formal acceptance evidence. + ## Phase gates | Phase | State | Outstanding gate | @@ -2069,7 +2107,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O call-site failure matrix / fifteen independent native worker histories generated and executed | PostgreSQL transaction/commit delivery, complete mutation/disclosure schedules and remaining durability cases required | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures and server-rejected PostgreSQL batches / fifteen file I/O fault histories and four real PostgreSQL rejected-prefix transactions executed | Ambiguous commit delivery, complete mutation/disclosure schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index ad3003e0b..4f607bd11 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -726,6 +726,15 @@ request. The failed I/O return is simulated, and production builds contain no selector. Actual device faults/power loss, PostgreSQL commit delivery and the complete mutation/disclosure fault matrix remain separate requirements. +`native-postgres-partial-batch.json` separately rejects each insert of a +four-record native admission transaction using a server trigger confined to an +owned test schema. A nontransactional sequence witnesses the reached row prefix; +actual gateway-table counts must show complete rollback before any credential +lease or HTTP entry. Removing the test fault permits explicit native +reauthorization of the unchanged operation, followed by no-I/O terminal replay. +This is real PostgreSQL transaction-abort evidence, not commit-acknowledgement +ambiguity, power loss or the complete mutation/disclosure fault matrix. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 1904a3902..003cb516d 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"418de3db1bcfede305db78182bc62a5f5f554b771d1b02c4ad692fe8225ec391"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"6b1f68f703f00899036517c778037ffa5e15ce51265090878519689470e0255d"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"419df30827a37dc0a0e5ec043bbfed6fd8d5030f4a14bbf1e21acc66677fab5f"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"65afa33c4c06f5a68707c9ad639a38615406fd8def7ffb41d15d9f86d47b5c59"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"eb63307671525b21f1c2d19eb3acfd2c7079e194fa2a33b6bfe7213c51299ea3"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 8b1beea58..a9cad8618 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -169,3 +169,6 @@ mod native_budget_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_file_fault_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_postgres_fault_tests; diff --git a/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs b/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs new file mode 100644 index 000000000..09817a622 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs @@ -0,0 +1,250 @@ +//! Real server exceptions in the native `PostgreSQL` admission batch. +//! Trigger/sequence fault controls live only in each owned test schema. The +//! shipping adapter and gateway decide and execute the actual transaction. +use crate::native_process_tests::{ + Provider, Setup, acquire, authorize_policy, finish_peer, load_engine, private, runtime, + start_peer, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ArgumentCeilingPolicy, GatewayExecutionWitness, + GatewaySubmitResult, SharedConnection, +}; +use serde_json::{Value, json}; +use std::{ + collections::BTreeMap, + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::fs::PermissionsExt as _, + path::Path, + sync::atomic::Ordering, + thread, + time::{Duration, Instant}, +}; + +const OPERATION: &str = "postgres-partial-batch"; + +fn ready(listener: &TcpListener) -> TcpStream { + let deadline = Instant::now() + Duration::from_secs(15); + loop { + match listener.accept() { + Ok((mut signal, _)) => { + signal.set_nonblocking(false).expect("blocking"); + signal + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + signal + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut marker = [0]; + signal.read_exact(&mut marker).expect("peer ready"); + assert_eq!(marker, *b"R"); + return signal; + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "native peer deadline"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("barrier: {error}"), + } + } +} +fn expected_counts(admitted: bool) -> BTreeMap { + let mut counts = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ]); + if admitted { + for kind in ["attempt", "effect-allocation", "count-slot", "sum-slot"] { + counts.insert(kind.to_owned(), 1); + } + } + counts +} +fn signed_inputs(root: &Path) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| { + std::fs::read(root.join(format!("{OPERATION}.{suffix}"))).expect("signed inputs") + }) + .to_vec() +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: Setup, + provider: Provider, + barrier: TcpListener, + signed: Vec>, +} +impl Case { + fn new() -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(Backend::Postgres); + let provider = Provider::controlled(None); + let barrier = TcpListener::bind("127.0.0.1:0").expect("barrier"); + barrier.set_nonblocking(true).expect("nonblocking"); + let setup = Setup { + backend: "postgres".to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: barrier.local_addr().expect("address").port(), + }; + let runtime = runtime(); + let (engine, connection) = + runtime.block_on(load_engine(&setup, "parent", store.attempts().clone())); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let policy = ArgumentCeilingPolicy::new("maximum_response_bytes", 1024, 3600, 4) + .expect("count") + .with_sum(4096, None) + .expect("sum"); + runtime.block_on(authorize_policy(&engine, &setup.root, OPERATION, &policy)); + let signed = signed_inputs(&setup.root); + assert_eq!( + store.postgres_gateway_record_counts(), + expected_counts(false) + ); + Self { + _directory: directory, + store, + setup, + provider, + barrier, + signed, + } + } + fn fail(&self, fail_at: u64) { + let input = self.setup.root.join("setup.json"); + private(&input, &serde_json::to_vec(&self.setup).expect("setup")); + let mut peer = start_peer(&input, OPERATION); + let mut signal = ready(&self.barrier); + // The child completed installation before the trigger is installed; + // its next insert is the actual native admission batch. + self.store.reject_postgres_batch_insert(fail_at); + signal.write_all(b"G").expect("release peer"); + finish_peer(&mut peer); + let result: Result = serde_json::from_slice( + &std::fs::read(self.setup.root.join(format!("{OPERATION}.result"))).expect("result"), + ) + .expect("native result"); + assert!( + matches!(result, Err(GatewaySubmitResult::Indeterminate { ref code }) if code == "gateway.attempt.state-unavailable") + ); + let witness: GatewayExecutionWitness = serde_json::from_slice( + &std::fs::read(self.setup.root.join(format!("{OPERATION}.witness"))).expect("witness"), + ) + .expect("native witness"); + assert_eq!( + ( + witness.credential_lease_calls, + witness.read_transport_entries, + witness.write_transport_entries + ), + (0, 0, 0) + ); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 0); + assert_eq!( + self.store.clear_postgres_batch_failure(), + fail_at, + "nontransactional server sequence proves the failed row prefix" + ); + assert_eq!( + self.store.postgres_gateway_record_counts(), + expected_counts(false), + "every earlier attempted row rolled back" + ); + assert!(self.store.raw().attempt_keys(4).expect("keys").is_empty()); + assert_eq!(signed_inputs(&self.setup.root), self.signed); + } + fn reopen(&self, fail_at: u64) -> Value { + let runtime = runtime(); + let (engine, _) = + runtime.block_on(load_engine(&self.setup, "reopened", self.store.reopen())); + assert!( + runtime.block_on(engine.content_history(OPERATION)).is_err(), + "rolled-back admission has no history" + ); + let result = runtime + .block_on(acquire(&engine, &self.setup.root, OPERATION)) + .expect("native reauthorization"); + assert_eq!(result.stage, AcquisitionStage::ResponseRecorded); + assert_eq!((result.reserved_calls, result.reserved_bytes), (1, 1024)); + assert_eq!( + (result.policy_count_counters, result.policy_byte_counters), + (1, 1) + ); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!( + self.store.postgres_gateway_record_counts(), + expected_counts(true) + ); + let keys = self.store.raw().attempt_keys(4).expect("keys"); + assert_eq!(keys.len(), 1); + let raw = self + .store + .raw() + .load(crate::GatewayRecordKind::Attempt, &keys[0]) + .expect("load") + .expect("record"); + let record: Value = serde_json::from_slice(&raw).expect("native record"); + assert_eq!(record["state"]["facts"]["allocation"], 0); + assert!(!record["entry"].is_null()); + let witness = engine.execution_witness(); + for _ in 0..2 { + assert_eq!( + runtime + .block_on(acquire(&engine, &self.setup.root, OPERATION)) + .expect("replay"), + result + ); + } + assert_eq!(engine.execution_witness(), witness); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!( + self.store + .raw() + .load(crate::GatewayRecordKind::Attempt, &keys[0]) + .expect("reload") + .expect("record"), + raw + ); + assert_eq!( + self.store.postgres_gateway_record_counts(), + expected_counts(true) + ); + json!({"server_rejected_insert":fail_at,"prior_successful_insert_prefix":fail_at-1,"server_insert_sequence":fail_at,"all_admission_rows_rolled_back":true,"failed_worker_leases_and_transport_entries":0,"same_signed_inputs_reauthorized_after_reopen":true,"native_history":result,"actual_http_reads":1,"allocation_count_slot_and_sum_slot":1,"terminal_replay_preserves_attempt_and_execution_witness":true}) + } +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_partial_batch_fixture_is_current() { + assert!(postgres_configured()); + let cases: Vec<_> = (1..=4) + .map(|fail_at| { + let case = Case::new(); + case.fail(fail_at); + case.reopen(fail_at) + }) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-postgres-partial-batch/1","scope":"full native acquisition engine in separate worker OS processes, actual TLS PostgreSQL transactions and server-side insert exceptions, nontransactional sequence witnesses, signed bounded authority/exact approval, separate local custody and real local HTTP; fixed public test keys and maintained clock","excluded":["commit acknowledgement or network delivery ambiguity","PostgreSQL server/power failure","mutation/disclosure transaction fault matrices","whole-store rollback or hostile OS containment","human review or provider qualification"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-postgres-partial-batch.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index 19f3a6eb0..ffb3c8836 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -366,6 +366,10 @@ fn native_capacity_peer() { signal.read_exact(&mut start).expect("start"); assert_eq!(start, *b"G"); let result = runtime.block_on(acquire(&engine, &setup.root, &operation)); + private( + &setup.root.join(format!("{operation}.witness")), + &serde_json::to_vec(&engine.execution_witness()).expect("execution witness"), + ); private( &setup.root.join(format!("{operation}.result")), &serde_json::to_vec(&result).expect("native result"), diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 4c32b409c..4229879bb 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0ac73c216168574de2f33c0a08c9f7156a1cdcb9e4343366d4992d797bc0ea5b"; + "2740a14f59cfd47637f8ffba4a8c344cb5f7fad58e43d39e67fc64333846c123"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store_testkit.rs b/product/runtime/auths-gateway/src/store_testkit.rs index d16507547..d70aded0e 100644 --- a/product/runtime/auths-gateway/src/store_testkit.rs +++ b/product/runtime/auths-gateway/src/store_testkit.rs @@ -138,6 +138,81 @@ impl TestAttempts { pub(crate) fn raw(&self) -> Arc { raw_at(&self.location) } + + /// Actual server-side insert failure, confined to this test's owned schema. + /// Sequence increments survive rollback and witness the reached row prefix. + #[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn reject_postgres_batch_insert(&self, fail_at: u64) { + assert!((1..=4).contains(&fail_at)); + let schema = self.owned_postgres_schema(); + let statement = format!( + "CREATE SEQUENCE {schema}.fixture_batch_insert_sequence; + CREATE FUNCTION {schema}.fixture_reject_batch_insert() RETURNS trigger + LANGUAGE plpgsql AS $body$ + DECLARE reached bigint; + BEGIN + reached := nextval('{schema}.fixture_batch_insert_sequence'::regclass); + IF reached = {fail_at} THEN + RAISE EXCEPTION 'synthetic native admission insert failure'; + END IF; + RETURN NEW; + END; $body$; + CREATE TRIGGER fixture_reject_batch_insert BEFORE INSERT + ON {schema}.auths_gateway_records FOR EACH ROW + EXECUTE FUNCTION {schema}.fixture_reject_batch_insert();" + ); + off_runtime(move || admin_client().batch_execute(&statement)).expect("test trigger"); + } + + #[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + fn owned_postgres_schema(&self) -> String { + let Location::Postgres { + schema, + owned: true, + } = &self.location + else { + panic!("only a locally owned PostgreSQL test schema may receive a trigger"); + }; + assert!( + schema.starts_with("gateway_") + && schema[8..].bytes().all(|byte| byte.is_ascii_hexdigit()) + ); + schema.clone() + } + + /// Removes the trigger before retry; the nontransactional sequence proves + /// how many actual inserts reached the server before its exception. + #[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn clear_postgres_batch_failure(&self) -> u64 { + let schema = self.owned_postgres_schema(); + off_runtime(move || { + let mut client = admin_client(); + let row = client + .query_one( + &format!("SELECT last_value FROM {schema}.fixture_batch_insert_sequence"), + &[], + ) + .expect("sequence witness"); + let reached: i64 = row.get(0); + client + .batch_execute(&format!( + "DROP TRIGGER fixture_reject_batch_insert ON {schema}.auths_gateway_records" + )) + .expect("remove trigger"); + u64::try_from(reached).expect("finite insert count") + }) + } + + #[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn postgres_gateway_record_counts(&self) -> std::collections::BTreeMap { + let schema = self.owned_postgres_schema(); + off_runtime(move || { + admin_client().query(&format!("SELECT record_kind, count(*) FROM {schema}.auths_gateway_records GROUP BY record_kind ORDER BY record_kind"), &[]).expect("row counts").into_iter().map(|row| { + let count: i64 = row.get(1); + (row.get(0), u64::try_from(count).expect("bounded test count")) + }).collect() + }) + } } impl Drop for TestAttempts { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index bf92b23c9..dabbedf2f 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 398 +freeze_version = 399 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 398 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 144 +"auths.identity.protocol" = 145 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 398 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 141 +"auths.product.public-sdk-contract" = 142 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 398 +"auths.release.public-surface" = 399 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 1438b4486..42064cee3 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 398, + "freezeVersion": 399, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 144, + "version": 145, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "53d28ffae974baa7dc43c34351dfce88727018707590c7131ae0e27e6cd49692" + "sha256": "2f4e23ab35238bb8db232e418d0cbb88ebdd5c6fd7af61676887e64c9bb0e6af" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 141, + "version": 142, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "d39f83179fc630d005285fc7608bde6a633ba7e477cc3cb7900f051640fd66d6" + "sha256": "684e9110f8dabe7a295a95de0eeb66d4584801de829a166718103996586544e9" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 398, + "version": 399, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "6a26a1516f08d8d763a8cdef710524e223f07b58bf16b132698935365b8e01cd" + "sha256": "1d5d88c2647aaf515f218cea7a270b95f2df5b4913bfc2571fc0b74f5445b2e7" } ] } From 884b5bd99737d6927218e064ba27ed2aade02b71 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 11:37:46 +0000 Subject: [PATCH 077/136] fix(formal): align gateway proofs with durable entry and late evidence --- docs/assurance/PROOF_COVERAGE.md | 6 +- formal/Auths/Product/Recovery.lean | 260 ++- formal/Auths/Product/Refinement/Gateway.lean | 295 ++- formal/Auths/Product/SubmitOrder.lean | 352 ++- formal/Auths/Theorems.lean | 7 + formal/README.md | 49 + formal/assurance-manifest-v1.toml | 2049 +++++++++++------ formal/lean-assurance-audit-v1.json | 77 +- formal/proof-coverage-functions-v1.tsv | 194 +- formal/proof-coverage-v1.json | 82 +- .../qualification/aeneas/cases/Gateway.lean | 87 + .../aeneas/generated/gateway/Funs.lean | 1171 ++++++---- .../aeneas/generated/gateway/Types.lean | 103 +- .../aeneas/generated/gateway/translation.json | 639 ++--- .../qualification/aeneas/qualification.toml | 8 +- .../qualification/aeneas/source-closure.json | 8 +- xtask/src/formal_qualification.rs | 4 +- 17 files changed, 3358 insertions(+), 2033 deletions(-) diff --git a/docs/assurance/PROOF_COVERAGE.md b/docs/assurance/PROOF_COVERAGE.md index 5b207aeb5..ec97ff428 100644 --- a/docs/assurance/PROOF_COVERAGE.md +++ b/docs/assurance/PROOF_COVERAGE.md @@ -7,7 +7,7 @@ At the commit that contains this document, 110 of 1,031 decision-scope functions (10.7%) and 1,289 of 11,353 code lines (11.4%) are translated to Lean and reached from audited theorem statements, and 15 of 82 kernel check sites map only to such functions. The rest of the decision path, including the staged verifier control flow, the composition evaluator, the registry handlers, the codec, and the signature suites, is tested, not proved. - Revision: the commit that contains this document and `formal/proof-coverage-v1.json`; a release binds it in its assurance evidence. -- Measurement inputs: sha256 `56f5f8df74c31a2554725ec967451d36bfa6e7c4a49004b3c83bb5cd32c35f52` over the 89 files listed in `formal/proof-coverage-v1.json`. +- Measurement inputs: sha256 `ac052be07bf5d42e8b136ee8c1e0cf94f0cc3253f24c787165acc5b8607e3781` over the 89 files listed in `formal/proof-coverage-v1.json`. - Tool: `cargo xtask formal coverage`, version 1. - Toolchain pins: `formal/lean-toolchain` = `leanprover/lean4:v4.31.0`; `formal/translation-toolchain.lock` sha256 `0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53`. - Role table: `formal/coverage-scope-v1.toml`, sha256 `053f0be216b0003768d422d9ccc92a692726488874284fa80615657b30a495b5`. Figures computed under a different role table are not comparable. @@ -52,7 +52,7 @@ Files in scoped crates with a non-decision role (every other scoped file is deci | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | | decision | 1,031 | 110 (10.7%) | 56 (5.4%) | 110 (10.7%) | 11,353 | 1,289 (11.4%) | 856 (7.5%) | 1,289 (11.4%) | | verifier-core | 785 | 86 (11.0%) | 41 (5.2%) | 86 (11.0%) | 8,802 | 907 (10.3%) | 558 (6.3%) | 907 (10.3%) | -| translated-crates | 1,138 | 210 (18.5%) | 70 (6.2%) | 210 (18.5%) | 10,662 | 2,508 (23.5%) | 1,024 (9.6%) | 2,508 (23.5%) | +| translated-crates | 1,146 | 213 (18.6%) | 70 (6.1%) | 213 (18.6%) | 10,738 | 2,497 (23.3%) | 1,027 (9.6%) | 2,497 (23.3%) | | verifier-closure | 1,083 | 86 (7.9%) | 41 (3.8%) | 86 (7.9%) | 13,762 | 907 (6.6%) | 558 (4.1%) | 907 (6.6%) | | decision-nontrivial | 443 | 81 (18.3%) | 44 (9.9%) | 81 (18.3%) | 9,589 | 1,202 (12.5%) | 820 (8.6%) | 1,202 (12.5%) | @@ -186,7 +186,7 @@ None: every function Aeneas translates is in the refined closure. `cargo xtask formal mutations` runs study 006's three campaigns: S1 applies each case of `formal/refinement-mutations-v1.json`, S2 mutates comparison, Boolean, and result-position operators in the model's `def` bodies, and S3 replaces each translated function's body with `fail .panic`. A mutant is killed when the build of the audited targets fails, and stillborn when its first error lies in the mutated definition itself. The first error (the earliest in the mutated file, else the least location among the failing modules, so that parallel builds record the same one) and its declaration are recorded; an S1 mutant whose build reports no error in its case's named witness is reported as killed elsewhere. Every survivor must be fixed or explained before a release; pull requests are not blocked. -**Some results predate the current formal sources** (current formal inputs `f250c011aa84a978f1f65e91ead3ed8aee7e3b6502e7d80868a583381df305db`); re-run the stale campaigns before a release. +**Some results predate the current formal sources** (current formal inputs `9f655722b5ba3e4322f25ffd60c37fa9149373099562a28a8faa08f3a9848169`); re-run the stale campaigns before a release. | Campaign | Mutants | Killed | Of which killed elsewhere | Survived | Stillborn | Current | | --- | ---: | ---: | ---: | ---: | ---: | --- | diff --git a/formal/Auths/Product/Recovery.lean b/formal/Auths/Product/Recovery.lean index 7d4e55403..357296d29 100644 --- a/formal/Auths/Product/Recovery.lean +++ b/formal/Auths/Product/Recovery.lean @@ -1,4 +1,5 @@ import Mathlib.Logic.ExistsUnique +import Mathlib.Tactic.Tauto /-! # Recovery capability of a gateway recipe @@ -7,7 +8,8 @@ What a recipe can prove after an ambiguous write is a total function of three declarations (the observation locator, the echo, and the idempotency mechanism) plus whether a pre-entry re-read is declared. The class names what a later read-back can establish; `unknownResolution` says whether the gateway -can ever resolve an `unknown` write, which only a verified-locator link can. +can ever resolve an `unknown` write by provider observation, which only a verified-locator link can. +Late source responses and authenticated recipient acknowledgements are separate evidence routes. No declaration makes the provider write conditional. The attempt record then moves through a closed stage table. The gateway store @@ -143,14 +145,23 @@ theorem write_never_conditional (declarations : Declarations) : /-! ## Attempt-record transitions -/ +/-- The independently authorized external boundary of this journal. -/ +inductive Protocol where + | mutation + | acquisition + | disclosure + deriving DecidableEq, Repr + /-- The stage of an attempt record. -/ inductive Stage where - | attempting + | reserved + | entryGranted | notEntered | unknown | responseRecorded | observed | observedByProvider + | acknowledged deriving DecidableEq, Repr /-- The read-back comparison recorded with an `observed` stage. -/ @@ -171,11 +182,15 @@ inductive Link where /-- The fields of one stored attempt record the transition rule inspects; byte strings are empty when absent. -/ structure AttemptView where + protocol : Protocol + revision : Nat fixed : List Nat + entry : List Nat stage : Stage refusal : Bool preEntry : List Nat response : List Nat + acknowledgement : List Nat locator : List Nat reading : Reading evidence : Bool @@ -219,17 +234,49 @@ def providerStage : Stage → Bool /-- The stages with no outgoing transition. -/ def terminalStage : Stage → Bool - | .notEntered | .observed | .observedByProvider => true - | .attempting | .unknown | .responseRecorded => false + | .notEntered | .observed | .observedByProvider | .acknowledged => true + | .reserved | .entryGranted | .unknown | .responseRecorded => false def hasReading : Reading → Bool | .none => false | _ => true +def requiresEntry : Stage → Bool + | .reserved | .notEntered => false + | _ => true + +def acknowledgementStage : Stage → Bool + | .acknowledged => true + | _ => false + +/-- Protocols have disjoint evidence vocabularies. A response is not a delivery +acknowledgement; neither is an independently authorized provider observation. -/ +def protocolConsistent (view : AttemptView) : Bool := + match view.protocol with + | .mutation => decide (view.stage ≠ .acknowledged) && view.acknowledgement.isEmpty + | .acquisition => + (match view.stage with + | .reserved | .entryGranted | .notEntered | .unknown | .responseRecorded => true + | _ => false) && + view.acknowledgement.isEmpty && view.preEntry.isEmpty && view.locator.isEmpty && + !view.observation && !view.evidence && decide (view.reading = .none) && + decide (view.link = .none) + | .disclosure => + (match view.stage with + | .reserved | .entryGranted | .notEntered | .unknown | .acknowledged => true + | _ => false) && + view.response.isEmpty && view.preEntry.isEmpty && view.locator.isEmpty && + !view.observation && !view.evidence && decide (view.reading = .none) && + decide (view.link = .none) + /-- A view's fields agree with its stage. -/ def consistent (view : AttemptView) : Bool := let hasResponse := !view.response.isEmpty - decide (refusalStage view.stage = view.refusal) && + protocolConsistent view && decide (view.revision > 0) && + decide (view.revision ≤ 9007199254740991) && + decide (requiresEntry view.stage ≠ view.entry.isEmpty) && + decide (acknowledgementStage view.stage ≠ view.acknowledgement.isEmpty) && + decide (refusalStage view.stage = view.refusal) && (!requiresResponse view.stage || hasResponse) && (!hasResponse || permitsResponse view.stage) && (view.locator.isEmpty || hasResponse) && @@ -242,28 +289,39 @@ def consistent (view : AttemptView) : Bool := /-- The closed stage table, given the stored plan's link. -/ def stageTransitionAllowed (source target : Stage) (link : Link) : Bool := match source, target with - | .attempting, .attempting | .attempting, .notEntered | .attempting, .unknown - | .attempting, .responseRecorded => true - | .attempting, .observedByProvider => resolvesUnknown link - | .unknown, .observedByProvider => resolvesUnknown link + | .reserved, .reserved | .reserved, .notEntered | .reserved, .entryGranted => true + | .entryGranted, .unknown | .entryGranted, .responseRecorded | .entryGranted, .acknowledged + | .unknown, .responseRecorded | .unknown, .acknowledged => true + | .entryGranted, .observedByProvider | .unknown, .observedByProvider => resolvesUnknown link | .responseRecorded, .observed | .responseRecorded, .observedByProvider => true | _, _ => false def addsPreEntry (source target : Stage) : Bool := match source, target with - | .attempting, .attempting | .attempting, .notEntered => true + | .reserved, .reserved | .reserved, .notEntered => true | _, _ => false def addsResponse (source target : Stage) : Bool := match source, target with - | .attempting, .responseRecorded => true + | .entryGranted, .responseRecorded | .unknown, .responseRecorded => true | _, _ => false def checkpointValid (old new : AttemptView) : Bool := match old.stage, new.stage with - | .attempting, .attempting => old.preEntry.isEmpty && !new.preEntry.isEmpty + | .reserved, .reserved => old.preEntry.isEmpty && !new.preEntry.isEmpty | _, _ => true +def entryKept (old new : AttemptView) : Bool := + match old.stage, new.stage with + | .reserved, .entryGranted => old.entry.isEmpty && !new.entry.isEmpty + | _, _ => decide (old.entry = new.entry) + +def acknowledgementKept (old new : AttemptView) : Bool := + match old.stage, new.stage with + | .entryGranted, .acknowledged | .unknown, .acknowledged => + old.acknowledgement.isEmpty && !new.acknowledgement.isEmpty + | _, _ => decide (old.acknowledgement = new.acknowledgement) + def preEntryKept (old new : AttemptView) : Bool := if old.preEntry.isEmpty then new.preEntry.isEmpty || addsPreEntry old.stage new.stage else decide (old.preEntry = new.preEntry) @@ -277,9 +335,11 @@ def planKept (old new : AttemptView) : Bool := /-- Whether `new` may replace `old`. -/ def validTransition (old new : AttemptView) : Bool := - decide (old.fixed = new.fixed) && planKept old new && + decide (old.protocol = new.protocol) && decide (old.revision < 9007199254740991) && + decide (new.revision = old.revision + 1) && consistent old && entryKept old new && + decide (old.fixed = new.fixed) && planKept old new && stageTransitionAllowed old.stage new.stage old.link && checkpointValid old new && - preEntryKept old new && responseKept old new && consistent new + preEntryKept old new && responseKept old new && acknowledgementKept old new && consistent new /-- Each record replaces the previous one by a valid transition. -/ def validChain : List AttemptView → Prop @@ -311,27 +371,45 @@ theorem transition_consistent {old new : AttemptView} (valid : validTransition o simp only [validTransition, Bool.and_eq_true] at valid exact valid.2 +/-- Every accepted transition retains its protocol, advances exactly one bounded +revision, and preserves a grant once present. This is a projection invariant; +the runtime authenticates the grant before constructing the view. -/ +theorem transition_ownership {old new : AttemptView} (valid : validTransition old new = true) : + new.protocol = old.protocol ∧ new.revision = old.revision + 1 ∧ + new.revision ≤ 9007199254740991 ∧ + (old.entry ≠ [] → new.entry = old.entry) := by + have parts := valid + simp only [validTransition, Bool.and_eq_true, decide_eq_true_eq] at parts + have consistentOld : consistent old = true := by tauto + have consistentNew : consistent new = true := by tauto + have kept : entryKept old new = true := by tauto + refine ⟨by tauto, by tauto, ?_, ?_⟩ + · simp only [consistent, Bool.and_eq_true, decide_eq_true_eq] at consistentNew + tauto + · intro present + cases oldStage : old.stage <;> cases newStage : new.stage <;> + simp_all [entryKept, consistent, requiresEntry, List.isEmpty_iff] + theorem transition_keeps {old new : AttemptView} (consistentOld : consistent old = true) (valid : validTransition old new = true) : Keeps old new := by simp only [validTransition, Bool.and_eq_true, decide_eq_true_eq] at valid - obtain ⟨⟨⟨⟨⟨⟨fixedEq, planEq⟩, _⟩, _⟩, preKept⟩, responseKeptEq⟩, _⟩ := valid + have fixedEq : old.fixed = new.fixed := by tauto + have planEq : planKept old new = true := by tauto + have preKept : preEntryKept old new = true := by tauto + have responseKeptEq : responseKept old new = true := by tauto simp only [planKept, Bool.and_eq_true, decide_eq_true_eq] at planEq refine ⟨fixedEq.symm, planEq.1.symm, planEq.2.symm, fun present => ?_, fun present => ?_⟩ · have nonempty : old.preEntry.isEmpty = false := by cases equal : old.preEntry with | nil => exact absurd equal present | cons _ _ => rfl - simp only [preEntryKept, nonempty, Bool.false_eq_true, if_false, decide_eq_true_eq] - at preKept + simp only [preEntryKept, nonempty, Bool.false_eq_true, if_false, decide_eq_true_eq] at preKept exact preKept.symm - · simp only [responseKept, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq] - at responseKeptEq + · simp only [responseKept, Bool.or_eq_true, Bool.and_eq_true, decide_eq_true_eq] at responseKeptEq rcases responseKeptEq with adds | ⟨responseEq, locatorEq⟩ · exfalso - rcases old with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ - cases stage <;> cases equal : new.stage <;> simp_all [addsResponse] <;> - cases response <;> simp_all [consistent, permitsResponse] + cases oldStage : old.stage <;> cases newStage : new.stage <;> + simp_all [addsResponse, consistent, permitsResponse, List.isEmpty_iff] · exact ⟨responseEq.symm, locatorEq.symm⟩ theorem chain_step {views : List AttemptView} (chain : validChain views) (index : Nat) @@ -386,75 +464,133 @@ theorem chain_keeps (views : List AttemptView) (chain : validChain views) exact induction restChain restStart earlier later (by omega) (by simp at bound; omega) -/-- A record in `unknown` leaves it only for `observed-by-provider`, only -with a verified-locator link (the link of exactly the `linked` class), and -only on a transition that records provider evidence; over every valid -sequence of records, the same holds at every position. -/ +/-- Only the separately linked provider-evidence route resolves an unknown +as observed-by-provider. Late source responses and recipient ACKs carry distinct +facts; they do not establish this observation claim. -/ theorem unknown_resolves_only_linked : (∀ old new : AttemptView, validTransition old new = true → old.stage = .unknown → - new.stage = .observedByProvider ∧ old.link = .verified ∧ new.link = .verified ∧ - new.evidence = true) ∧ + new.stage = .observedByProvider → + old.link = .verified ∧ new.link = .verified ∧ new.evidence = true) ∧ (∀ views : List AttemptView, validChain views → ∀ (index : Nat) (bound : index + 1 < views.length), (views[index]'(by omega)).stage = .unknown → - views[index + 1].stage = .observedByProvider ∧ - views[index + 1].link = .verified ∧ views[index + 1].evidence = true) ∧ + views[index + 1].stage = .observedByProvider → + views[index + 1].link = .verified ∧ views[index + 1].evidence = true) ∧ (∀ declarations : Declarations, linkOf (capability declarations).providerLink = .verified ↔ (capability declarations).recoveryClass = .linked) := by have single : ∀ old new : AttemptView, validTransition old new = true → - old.stage = .unknown → - new.stage = .observedByProvider ∧ old.link = .verified ∧ new.link = .verified ∧ - new.evidence = true := by - intro old new valid unknown - rcases old with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ - rcases new with ⟨fixed', stage', refusal', preEntry', response', locator', reading', - evidence', observation', link'⟩ - subst unknown - cases stage' <;> cases link <;> - simp_all [validTransition, planKept, stageTransitionAllowed, resolvesUnknown, consistent, - providerStage] + old.stage = .unknown → new.stage = .observedByProvider → + old.link = .verified ∧ new.link = .verified ∧ new.evidence = true := by + intro old new valid unknown provider + have stage : stageTransitionAllowed old.stage new.stage old.link = true := by + simp only [validTransition, Bool.and_eq_true] at valid + tauto + have plan : planKept old new = true := by + simp only [validTransition, Bool.and_eq_true] at valid + tauto + have consistency := transition_consistent valid + cases link : old.link <;> + simp_all [stageTransitionAllowed, resolvesUnknown, planKept, consistent, providerStage] refine ⟨single, ?_, ?_⟩ - · intro views chain index bound unknown - obtain ⟨stage, _, link, evidence⟩ := single _ _ (chain_step chain index bound) unknown - exact ⟨stage, link, evidence⟩ + · intro views chain index bound unknown provider + exact (single _ _ (chain_step chain index bound) unknown provider).2 · intro declarations obtain ⟨observation, echo, idempotency, preEntry⟩ := declarations - cases observation <;> cases echo <;> - simp [capability, providerLink, classOf, linkOf] + cases observation <;> cases echo <;> simp [capability, providerLink, classOf, linkOf] + +/-- The closed unknown exit table includes late source evidence, but forbids +re-entry, a new reservation, and a refunding not-entered result. -/ +theorem unknown_exits_with_bound_evidence (old new : AttemptView) + (valid : validTransition old new = true) (unknown : old.stage = .unknown) : + new.stage = .responseRecorded ∨ new.stage = .acknowledged ∨ + (new.stage = .observedByProvider ∧ old.link = .verified) := by + have stage : stageTransitionAllowed old.stage new.stage old.link = true := by + simp only [validTransition, Bool.and_eq_true] at valid + tauto + cases target : new.stage <;> cases link : old.link <;> + simp_all [stageTransitionAllowed, resolvesUnknown] + +/-- A late response retains the source grant and protocol and advances one +revision, records a nonempty response, and does not assert provider observation. +Runtime validation of the response/source binding is outside this byte projection. -/ +theorem late_response_retains_source (old new : AttemptView) + (valid : validTransition old new = true) (unknown : old.stage = .unknown) + (response : new.stage = .responseRecorded) : + new.protocol = old.protocol ∧ new.revision = old.revision + 1 ∧ + new.entry = old.entry ∧ old.entry ≠ [] ∧ new.response ≠ [] ∧ + new.evidence = false ∧ new.acknowledgement = [] := by + have own := transition_ownership valid + have oldCons : consistent old = true := by + simp only [validTransition, Bool.and_eq_true] at valid + tauto + have newCons := transition_consistent valid + have entry : old.entry ≠ [] := by + simp [consistent, unknown, requiresEntry, List.isEmpty_iff] at oldCons + tauto + have newFields : new.response ≠ [] ∧ new.evidence = false ∧ new.acknowledgement = [] := by + simp [consistent, response, requiresResponse, providerStage, acknowledgementStage, + List.isEmpty_iff] at newCons + tauto + exact ⟨own.1, own.2.1, own.2.2.2 entry, entry, newFields⟩ + +/-- A late recipient ACK is restricted to the disclosure protocol. It keeps the +source grant/revision lineage, carries nonempty authenticated evidence, and +cannot be confused with a response or provider observation. Signature and exact +recipient/challenge binding are checked before the runtime projects these bytes. -/ +theorem late_acknowledgement_retains_source (old new : AttemptView) + (valid : validTransition old new = true) (unknown : old.stage = .unknown) + (acknowledged : new.stage = .acknowledged) : + old.protocol = .disclosure ∧ new.protocol = .disclosure ∧ + new.revision = old.revision + 1 ∧ new.entry = old.entry ∧ old.entry ≠ [] ∧ + new.acknowledgement ≠ [] ∧ new.response = [] ∧ new.evidence = false := by + have own := transition_ownership valid + have oldCons : consistent old = true := by + simp only [validTransition, Bool.and_eq_true] at valid + tauto + have newCons := transition_consistent valid + have entry : old.entry ≠ [] := by + simp [consistent, unknown, requiresEntry, List.isEmpty_iff] at oldCons + tauto + have fields : new.protocol = .disclosure ∧ new.acknowledgement ≠ [] ∧ + new.response = [] ∧ new.evidence = false := by + cases protocol : new.protocol <;> + simp [consistent, protocolConsistent, protocol, acknowledged, acknowledgementStage, + providerStage, permitsResponse, List.isEmpty_iff] at newCons <;> + simp_all only [and_true, true_and] <;> tauto + exact ⟨own.1 ▸ fields.1, fields.1, own.2.1, own.2.2.2 entry, entry, fields.2⟩ /-- `observed-by-provider` is reached only through a transition that records provider evidence, under a declared link of the plan stored at the claim: -from `response-recorded`, or from `attempting` or `unknown` only with a -verified-locator link. For a sequence starting from a claimed `attempting` +from `response-recorded`, or from `entry-granted` or `unknown` only with a +verified-locator link. For a sequence starting from a claimed `reserved` record, every `observed-by-provider` record was reached this way. -/ theorem provider_claim_requires_evidence : (∀ old new : AttemptView, validTransition old new = true → new.stage = .observedByProvider → new.evidence = true ∧ hasLink new.link = true ∧ new.link = old.link ∧ (old.stage = .responseRecorded ∨ - ((old.stage = .attempting ∨ old.stage = .unknown) ∧ old.link = .verified))) ∧ - (∀ (first : AttemptView) (rest : List AttemptView), first.stage = .attempting → + ((old.stage = .entryGranted ∨ old.stage = .unknown) ∧ old.link = .verified))) ∧ + (∀ (first : AttemptView) (rest : List AttemptView), first.stage = .reserved → consistent first = true → validChain (first :: rest) → ∀ (index : Nat) (bound : index < rest.length), rest[index].stage = .observedByProvider → rest[index].evidence = true ∧ rest[index].link = first.link ∧ hasLink first.link = true ∧ (((first :: rest)[index]'(by simp; omega)).stage = .responseRecorded ∨ - ((((first :: rest)[index]'(by simp; omega)).stage = .attempting ∨ + ((((first :: rest)[index]'(by simp; omega)).stage = .entryGranted ∨ ((first :: rest)[index]'(by simp; omega)).stage = .unknown) ∧ first.link = .verified))) := by have single : ∀ old new : AttemptView, validTransition old new = true → new.stage = .observedByProvider → new.evidence = true ∧ hasLink new.link = true ∧ new.link = old.link ∧ (old.stage = .responseRecorded ∨ - ((old.stage = .attempting ∨ old.stage = .unknown) ∧ old.link = .verified)) := by + ((old.stage = .entryGranted ∨ old.stage = .unknown) ∧ old.link = .verified)) := by intro old new valid provider - rcases old with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ - rcases new with ⟨fixed', stage', refusal', preEntry', response', locator', reading', - evidence', observation', link'⟩ + rcases old with ⟨protocol, revision, fixed, entry, stage, refusal, preEntry, response, acknowledgement, + locator, reading, evidence, observation, link⟩ + rcases new with ⟨protocol', revision', fixed', entry', stage', refusal', preEntry', response', acknowledgement', + locator', reading', evidence', observation', link'⟩ subst provider cases stage <;> cases link <;> cases link' <;> simp_all [validTransition, planKept, stageTransitionAllowed, resolvesUnknown, consistent, @@ -478,12 +614,12 @@ theorem provider_claim_requires_evidence : · rw [← previousLink] exact source -/-- `not-entered`, `observed`, and `observed-by-provider` are exactly the +/-- `not-entered`, `observed`, `observed-by-provider`, and `acknowledged` are the terminal stages; no transition leaves them, so in every valid sequence a terminal record is the last. -/ theorem terminal_stages_final : (∀ stage : Stage, terminalStage stage = true ↔ - stage = .notEntered ∨ stage = .observed ∨ stage = .observedByProvider) ∧ + stage = .notEntered ∨ stage = .observed ∨ stage = .observedByProvider ∨ stage = .acknowledged) ∧ (∀ old new : AttemptView, terminalStage old.stage = true → validTransition old new = false) ∧ (∀ views : List AttemptView, validChain views → @@ -492,8 +628,8 @@ theorem terminal_stages_final : have single : ∀ old new : AttemptView, terminalStage old.stage = true → validTransition old new = false := by intro old new terminal - rcases old with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ + rcases old with ⟨protocol, revision, fixed, entry, stage, refusal, preEntry, response, acknowledgement, + locator, reading, evidence, observation, link⟩ cases stage <;> simp_all [terminalStage, validTransition, stageTransitionAllowed] refine ⟨fun stage => by cases stage <;> simp [terminalStage], single, ?_⟩ intro views chain index bound terminal diff --git a/formal/Auths/Product/Refinement/Gateway.lean b/formal/Auths/Product/Refinement/Gateway.lean index ee13c66c5..8b466a866 100644 --- a/formal/Auths/Product/Refinement/Gateway.lean +++ b/formal/Auths/Product/Refinement/Gateway.lean @@ -1796,11 +1796,6 @@ theorem translated_relative_basis_refines_model (value : Std.U64) (subtrahend : section Order open Auths.Product.SubmitOrder -def modeOf : order.Mode → Mode - | .Entry => .entry - | .ReadBack => .readBack - | .Reobserve => .reobserve - def planOf (plan : order.SubmitPlan) : Plan where accountScope := plan.account_scope accountRead := plan.account_read @@ -1817,22 +1812,21 @@ def phaseOf : order.Phase → Phase | .Scope => .scope | .Prepare => .prepare | .Claim => .claim - | .Resume => .resume - | .Reload mode => .reload (modeOf mode) - | .Lease mode => .lease (modeOf mode) - | .Prefix mode => .prefixGuard (modeOf mode) - | .Account mode => .account (modeOf mode) - | .Denied mode index => .denied (modeOf mode) index.val + | .Reload => .reload + | .Lease => .lease + | .Prefix => .prefixGuard + | .Account => .account + | .Denied index => .denied index.val | .PreEntry => .preEntry | .Ceiling => .ceiling | .Checkpoint => .checkpoint | .EntryReload => .entryReload | .Deadline => .deadline + | .Grant => .grant | .Send => .send | .RecordResponse => .recordResponse | .RecordUnknown => .recordUnknown | .RecordNotEntered => .recordNotEntered - | .ReadBack mode => .readBack (modeOf mode) | .Done => .done def stateOf (state : order.SubmitState) : State where @@ -1845,7 +1839,7 @@ def verificationOf : order.Verification → Verification | .Authorized argument => .authorized argument.val def claimOf : order.ClaimResult → ClaimResult - | .Inserted => .inserted + | .Reserved => .reserved | .Refused => .refused | .Replay => .replay | .Unavailable => .unavailable @@ -1870,13 +1864,12 @@ def ceilingOf : order.CeilingRead → CeilingRead | .Read basis bindsEqual => .read basis.val bindsEqual def writeOf : order.WriteResult → WriteResult - | .NotEntered => .notEntered | .Unknown => .unknown | .Response => .response def responseOf : order.ResponseRecord → ResponseRecord | .Failed => .failed - | .Recorded observable => .recorded observable + | .Recorded => .recorded def eventOf : order.SubmitEvent → Event | .Start => .start @@ -1886,7 +1879,6 @@ def eventOf : order.SubmitEvent → Event | .Scope bound => .scope bound | .Preparation prepared => .preparation prepared | .Claim result => .claim (claimOf result) - | .Resume resumable => .resume resumable | .Reload unchanged => .reload unchanged | .Lease leased => .lease leased | .Prefix allowed => .prefixGuard allowed @@ -1896,6 +1888,7 @@ def eventOf : order.SubmitEvent → Event | .Ceiling read => .ceiling (ceilingOf read) | .Recorded stored => .recorded stored | .Deadline within => .deadline within + | .Granted granted => .granted granted | .Write result => .write (writeOf result) | .Response record => .response (responseOf record) @@ -1922,8 +1915,8 @@ def stopOf : order.Stop → Stop | .NotEntered => .notEntered | .Unknown => .unknown | .Response => .response - | .Observed => .observed - | .ReplayRefused => .replayRefused + | .Stored => .stored + | .GrantUnavailable => .grantUnavailable | .Halted => .halted def actionOf : order.SubmitAction → Action @@ -1933,22 +1926,21 @@ def actionOf : order.SubmitAction → Action | .BindScope => .bindScope | .Prepare => .prepare | .Claim => .claim - | .Resume => .resume - | .Reload mode => .reload (modeOf mode) - | .Lease mode => .lease (modeOf mode) - | .CheckPrefix mode => .checkPrefix (modeOf mode) - | .ReadAccount mode => .readAccount (modeOf mode) - | .DeniedRead mode index => .deniedRead (modeOf mode) index.val + | .Reload => .reload + | .Lease => .lease + | .CheckPrefix => .checkPrefix + | .ReadAccount => .readAccount + | .DeniedRead index => .deniedRead index.val | .PreEntryRead => .preEntryRead | .CeilingRead => .ceilingRead | .RecordCheckpoint => .recordCheckpoint | .ReloadBeforeEntry => .reloadBeforeEntry | .CheckDeadline => .checkDeadline + | .GrantEntry => .grantEntry | .Send => .send | .RecordResponse => .recordResponse | .RecordUnknown => .recordUnknown | .RecordNotEntered refusal => .recordNotEntered (refusalCodeOf refusal) - | .ReadBack mode => .readBack (modeOf mode) | .Stop reason => .stop (stopOf reason) def decisionOf (decision : order.SubmitDecision) : Decision where @@ -1964,9 +1956,9 @@ theorem translated_start_refines_model (plan : order.SubmitPlan) : /-- The next denied index of a refused read never overflows `u8`: it is at most the declared count. -/ -theorem after_denied_refused_spec (state : order.SubmitState) (mode : order.Mode) (index : Std.U8) : - order.after_denied state mode index .Refused ⦃ decision => - decisionOf decision = afterDenied (stateOf state) (modeOf mode) index.val .refused ⦄ := by +theorem after_denied_refused_spec (state : order.SubmitState) (index : Std.U8) : + order.after_denied state index .Refused ⦃ decision => + decisionOf decision = afterDenied (stateOf state) index.val .refused ⦄ := by unfold order.after_denied simp only [afterDenied, stateOf, planOf] split @@ -1987,11 +1979,10 @@ theorem after_denied_refused_spec (state : order.SubmitState) (mode : order.Mode have done' : ¬ next.val < state.plan.denied_reads.val := by simpa using done rw [nextVal'] at done' simp only [done', if_false] - rcases mode with _ | _ | _ all_goals - simp [order.after_credentials, order.pre_entry_from, order.ceiling_from, - order.after_reads, order.go, afterCredentials, preEntryFrom, ceilingFrom, afterReads, go, - decisionOf, stateOf, planOf, phaseOf, actionOf, modeOf] + simp [order.pre_entry_from, order.ceiling_from, + order.after_reads, order.go, preEntryFrom, ceilingFrom, afterReads, go, + decisionOf, stateOf, planOf, phaseOf, actionOf] repeat' split all_goals simp_all · rename_i above @@ -2009,18 +2000,17 @@ theorem after_denied_refused_spec (state : order.SubmitState) (mode : order.Mode @[simp] theorem stateOf_argument (state : order.SubmitState) : (stateOf state).argument = state.argument.val := rfl -theorem after_denied_spec (state : order.SubmitState) (mode : order.Mode) (index : Std.U8) +theorem after_denied_spec (state : order.SubmitState) (index : Std.U8) (result : order.DeniedResult) : - order.after_denied state mode index result ⦃ decision => + order.after_denied state index result ⦃ decision => decisionOf decision = - afterDenied (stateOf state) (modeOf mode) index.val (deniedOf result) ⦄ := by + afterDenied (stateOf state) index.val (deniedOf result) ⦄ := by match result with - | .Refused => exact after_denied_refused_spec state mode index + | .Refused => exact after_denied_refused_spec state index | .Answered | .Unavailable => - rcases mode with _ | _ | _ <;> - simp [order.after_denied, order.lease_failed, order.not_entered, order.stop, order.go, - afterDenied, leaseFailed, notEntered, stop, go, decisionOf, stateOf, phaseOf, actionOf, - refusalCodeOf, stopOf, deniedOf, modeOf] + simp [order.after_denied, order.not_entered, order.stop, order.go, + afterDenied, notEntered, stop, go, decisionOf, stateOf, phaseOf, actionOf, + refusalCodeOf, stopOf, deniedOf] theorem after_ceiling_spec (state : order.SubmitState) (read : order.CeilingRead) : order.after_ceiling state read ⦃ decision => @@ -2046,26 +2036,25 @@ theorem translated_next_step_refines_model (state : order.SubmitState) order.next_step state event ⦃ decision => decisionOf decision = nextStep (stateOf state) (eventOf event) ⦄ := by rcases state with ⟨plan, phase, argument⟩ - rcases phase with _ | _ | _ | _ | _ | _ | _ | _ | (_ | _ | _) | (_ | _ | _) | (_ | _ | _) | - (_ | _ | _) | ⟨(_ | _ | _), _⟩ | _ | _ | _ | _ | _ | _ | _ | _ | _ | (_ | _ | _) | _ <;> - rcases event with _ | _ | (_ | _) | _ | _ | _ | (_ | _ | _ | _) | _ | _ | _ | _ | - (_ | _ | _) | _ | (_ | _ | _) | _ | _ | _ | (_ | _ | _) | (_ | _) <;> + rcases phase with _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ <;> + rcases event with _ | _ | (_ | _) | _ | _ | _ | (_ | _ | _ | _) | _ | _ | _ | + (_ | _ | _) | _ | (_ | _ | _) | _ | _ | _ | _ | (_ | _) | (_ | _) <;> simp only [order.next_step, order.pre_claim_step, order.lease_step, order.entry_step, - nextStep, preClaimStep, leaseStep, entryStep, stateOf_phase, phaseOf, eventOf, modeOf] <;> + nextStep, preClaimStep, leaseStep, entryStep, stateOf_phase, phaseOf, eventOf] <;> first - | exact after_denied_spec _ _ _ _ + | exact after_denied_spec _ _ _ | exact after_ceiling_spec _ _ | skip all_goals - simp [order.go, order.stop, order.halt, order.not_entered, order.lease_failed, - order.after_reads, order.ceiling_from, order.pre_entry_from, order.after_credentials, + simp [order.go, order.stop, order.halt, order.not_entered, + order.after_reads, order.ceiling_from, order.pre_entry_from, order.denied_from, order.after_prefix, order.after_admission, order.pre_claim, order.after_claim, order.after_account, order.after_pre_entry, order.after_write, - order.after_response, order.after_read_back, go, stop, halt, notEntered, leaseFailed, - afterReads, ceilingFrom, preEntryFrom, afterCredentials, deniedFrom, afterPrefix, + order.after_response, go, stop, halt, notEntered, + afterReads, ceilingFrom, preEntryFrom, deniedFrom, afterPrefix, afterAdmission, preClaim, afterClaim, afterAccount, afterPreEntry, afterWrite, - afterResponse, afterReadBack, decisionOf, stateOf, planOf, phaseOf, actionOf, refusalCodeOf, - stopOf, modeOf, verificationOf, claimOf, accountOf, preEntryOf, writeOf, + afterResponse, decisionOf, stateOf, planOf, phaseOf, actionOf, refusalCodeOf, + stopOf, verificationOf, claimOf, accountOf, preEntryOf, writeOf, responseOf] <;> (repeat' split) <;> simp_all @@ -2089,14 +2078,22 @@ theorem byteList_inj {left right : List Std.U8} : byteList left = byteList right · intro equal rw [equal] +def protocolOf : transition.Protocol → Auths.Product.Recovery.Protocol + | .Mutation => .mutation + | .Acquisition => .acquisition + | .Disclosure => .disclosure + def stageOf : transition.Stage → Auths.Product.Recovery.Stage - | .Attempting => .attempting + | .Reserved => .reserved + | .EntryGranted => .entryGranted | .NotEntered => .notEntered | .Unknown => .unknown | .ResponseRecorded => .responseRecorded | .Observed => .observed | .ObservedByProvider => .observedByProvider + | .Acknowledged => .acknowledged + def readingOf : transition.Reading → Auths.Product.Recovery.Reading | .None => .none | .Match => .matched @@ -2109,6 +2106,10 @@ def storedLinkOf : transition.Link → Auths.Product.Recovery.Link | .AfterResponse => .afterResponse def viewOf (view : transition.AttemptView) : Auths.Product.Recovery.AttemptView where + protocol := protocolOf view.protocol + revision := view.revision.val + entry := byteList view.entry.val + acknowledgement := byteList view.acknowledgement.val fixed := byteList view.fixed.val stage := stageOf view.stage refusal := view.refusal @@ -2204,46 +2205,166 @@ theorem same_bytes_eq (left right : Slice Std.U8) : have := congrArg List.length same simpa [byteList] using this +namespace TransitionFacts + +open Auths.Product.Recovery + +theorem requires_entry_eq (value : transition.Stage) : + transition.requires_entry value = ok (requiresEntry (stageOf value)) := by + cases value <;> rfl + +theorem acknowledgement_stage_eq (value : transition.Stage) : + transition.acknowledgement_stage value = ok (acknowledgementStage (stageOf value)) := by + cases value <;> rfl + +theorem refusal_stage_eq (value : transition.Stage) : + transition.refusal_stage value = ok (refusalStage (stageOf value)) := by + cases value <;> rfl + +theorem requires_response_eq (value : transition.Stage) : + transition.requires_response value = ok (requiresResponse (stageOf value)) := by + cases value <;> rfl + +theorem permits_response_eq (value : transition.Stage) : + transition.permits_response value = ok (permitsResponse (stageOf value)) := by + cases value <;> rfl + +theorem observed_stage_eq (value : transition.Stage) : + transition.observed_stage value = ok (observedStage (stageOf value)) := by + cases value <;> rfl + +theorem provider_stage_eq (value : transition.Stage) : + transition.provider_stage value = ok (providerStage (stageOf value)) := by + cases value <;> rfl + +theorem has_reading_eq (value : transition.Reading) : + transition.has_reading value = ok (hasReading (readingOf value)) := by + cases value <;> rfl + +theorem has_link_eq (value : transition.Link) : + transition.has_link value = ok (hasLink (storedLinkOf value)) := by + cases value <;> rfl + +theorem resolves_unknown_eq (value : transition.Link) : + transition.resolves_unknown value = ok (resolvesUnknown (storedLinkOf value)) := by + cases value <;> rfl + +theorem protocol_consistent_eq (view : transition.AttemptView) : + transition.protocol_consistent view = ok (protocolConsistent (viewOf view)) := by + rcases view with ⟨protocol, revision, fixed, entry, stage, refusal, preEntry, response, + acknowledgement, locator, reading, evidence, observation, link⟩ + cases protocol <;> cases stage <;> cases reading <;> cases link <;> + simp [transition.protocol_consistent, transition.acknowledgement_stage, absent_eq, + alloc.vec.Vec.deref, protocolConsistent, viewOf, protocolOf, stageOf, readingOf, + storedLinkOf] <;> (repeat' split) <;> simp_all + theorem consistent_eq (view : transition.AttemptView) : - transition.consistent view = ok (Auths.Product.Recovery.consistent (viewOf view)) := by - rcases view with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ - simp only [transition.consistent, absent_eq, bind_tc_ok, alloc.vec.Vec.deref, - Auths.Product.Recovery.consistent, viewOf] - rcases stage with _ | _ | _ | _ | _ | _ <;> rcases reading with _ | _ | _ | _ <;> - rcases link with _ | _ | _ <;> - simp [transition.refusal_stage, transition.requires_response, transition.permits_response, - transition.observed_stage, transition.provider_stage, transition.has_reading, - transition.has_link, transition.resolves_unknown, stageOf, readingOf, storedLinkOf, - Auths.Product.Recovery.refusalStage, Auths.Product.Recovery.requiresResponse, - Auths.Product.Recovery.permitsResponse, Auths.Product.Recovery.observedStage, - Auths.Product.Recovery.providerStage, Auths.Product.Recovery.hasReading, - Auths.Product.Recovery.hasLink, Auths.Product.Recovery.resolvesUnknown] <;> + transition.consistent view = ok (consistent (viewOf view)) := by + rcases view with ⟨protocol, revision, fixed, entry, stage, refusal, preEntry, response, + acknowledgement, locator, reading, evidence, observation, link⟩ + cases stage <;> cases reading <;> cases link <;> + simp [transition.consistent, absent_eq, protocol_consistent_eq, requires_entry_eq, + acknowledgement_stage_eq, refusal_stage_eq, requires_response_eq, permits_response_eq, + observed_stage_eq, provider_stage_eq, has_reading_eq, has_link_eq, resolves_unknown_eq, + alloc.vec.Vec.deref, consistent, viewOf, UScalar.lt_equiv, UScalar.le_equiv, + stageOf, readingOf, storedLinkOf, requiresEntry, acknowledgementStage, refusalStage, + requiresResponse, permitsResponse, observedStage, providerStage, hasReading, + hasLink, resolvesUnknown] <;> (repeat' split) <;> simp_all + +theorem same_protocol_eq (left right : transition.Protocol) : + transition.same_protocol left right = ok (decide (protocolOf left = protocolOf right)) := by + cases left <;> cases right <;> rfl + +theorem link_equal_eq (left right : transition.Link) : + transition.link_equal left right = ok (decide (storedLinkOf left = storedLinkOf right)) := by + cases left <;> cases right <;> rfl + +theorem stage_transition_allowed_eq (source target : transition.Stage) (link : transition.Link) : + transition.stage_transition_allowed source target link = + ok (stageTransitionAllowed (stageOf source) (stageOf target) (storedLinkOf link)) := by + cases source <;> cases target <;> cases link <;> rfl + +theorem adds_pre_entry_eq (source target : transition.Stage) : + transition.adds_pre_entry source target = ok (addsPreEntry (stageOf source) (stageOf target)) := by + cases source <;> cases target <;> rfl + +theorem adds_response_eq (source target : transition.Stage) : + transition.adds_response source target = ok (addsResponse (stageOf source) (stageOf target)) := by + cases source <;> cases target <;> rfl + +theorem checkpoint_valid_eq (old new : transition.AttemptView) : + transition.checkpoint_valid old new = ok (checkpointValid (viewOf old) (viewOf new)) := by + cases oldStage : old.stage <;> cases newStage : new.stage <;> + simp [transition.checkpoint_valid, checkpointValid, viewOf, + oldStage, newStage, stageOf, absent_eq, same_bytes_eq, alloc.vec.Vec.deref] <;> + (repeat' split) <;> simp_all + +theorem entry_kept_eq (old new : transition.AttemptView) : + transition.entry_kept old new = ok (entryKept (viewOf old) (viewOf new)) := by + cases oldStage : old.stage <;> cases newStage : new.stage <;> + simp [transition.entry_kept, entryKept, viewOf, + oldStage, newStage, stageOf, absent_eq, same_bytes_eq, alloc.vec.Vec.deref] <;> + (repeat' split) <;> simp_all + +theorem acknowledgement_kept_eq (old new : transition.AttemptView) : + transition.acknowledgement_kept old new = ok (acknowledgementKept (viewOf old) (viewOf new)) := by + cases oldStage : old.stage <;> cases newStage : new.stage <;> + simp [transition.acknowledgement_kept, transition.acknowledgement_stage, acknowledgementKept, viewOf, + oldStage, newStage, stageOf, absent_eq, same_bytes_eq, alloc.vec.Vec.deref] <;> (repeat' split) <;> simp_all -/-- The translated transition rule returns exactly the model's decision for -every pair of records. -/ +theorem pre_entry_kept_eq (old new : transition.AttemptView) : + transition.pre_entry_kept old new = ok (preEntryKept (viewOf old) (viewOf new)) := by + simp only [transition.pre_entry_kept, preEntryKept, viewOf, absent_eq, same_bytes_eq, + alloc.vec.Vec.deref, adds_pre_entry_eq, bind_tc_ok] + (repeat' split) <;> simp_all + +theorem response_kept_eq (old new : transition.AttemptView) : + transition.response_kept old new = ok (responseKept (viewOf old) (viewOf new)) := by + simp only [transition.response_kept, responseKept, viewOf, same_bytes_eq, + alloc.vec.Vec.deref, adds_response_eq, bind_tc_ok] + (repeat' split) <;> simp_all + +theorem plan_kept_eq (old new : transition.AttemptView) : + transition.plan_kept old new = ok (planKept (viewOf old) (viewOf new)) := by + simp only [transition.plan_kept, planKept, viewOf, link_equal_eq] + (repeat' split) <;> simp_all + +end TransitionFacts + +private theorem result_guard (condition : Prop) [Decidable condition] (value : Bool) : + (if condition then ok value else ok false) = ok (decide condition && value) := by + by_cases condition <;> simp_all + +/-- Exact refinement for all three protocols, including revision overflow refusal, +immutable entry grants, and distinct response, recipient ACK and observation evidence. -/ theorem translated_valid_transition_refines_model (old new : transition.AttemptView) : transition.valid_transition old new ⦃ valid => valid = Auths.Product.Recovery.validTransition (viewOf old) (viewOf new) ⦄ := by - rcases old with ⟨fixed, stage, refusal, preEntry, response, locator, reading, evidence, - observation, link⟩ - rcases new with ⟨fixed', stage', refusal', preEntry', response', locator', reading', evidence', - observation', link'⟩ - simp only [transition.valid_transition, transition.plan_kept, transition.checkpoint_valid, - transition.pre_entry_kept, transition.response_kept, same_bytes_eq, absent_eq, - consistent_eq, bind_tc_ok, alloc.vec.Vec.deref, Auths.Product.Recovery.validTransition, - Auths.Product.Recovery.planKept, Auths.Product.Recovery.checkpointValid, - Auths.Product.Recovery.preEntryKept, Auths.Product.Recovery.responseKept, viewOf] - rcases stage with _ | _ | _ | _ | _ | _ <;> rcases stage' with _ | _ | _ | _ | _ | _ <;> - rcases link with _ | _ | _ <;> rcases link' with _ | _ | _ <;> - simp [transition.stage_transition_allowed, transition.adds_pre_entry, - transition.adds_response, transition.link_equal, transition.resolves_unknown, stageOf, - storedLinkOf, Auths.Product.Recovery.stageTransitionAllowed, - Auths.Product.Recovery.addsPreEntry, Auths.Product.Recovery.addsResponse, - Auths.Product.Recovery.resolvesUnknown, List.isEmpty_iff] <;> - (repeat' split) <;> simp_all <;> - (repeat' split) <;> simp_all + unfold transition.valid_transition + rw [TransitionFacts.same_protocol_eq, bind_tc_ok] + by_cases protocol : protocolOf old.protocol = protocolOf new.protocol + · simp only [protocol, decide_true, if_true] + by_cases bounded : old.revision < 9007199254740991#u64 + · simp only [bounded, if_true] + have bounded' : old.revision.val < 9007199254740991 := by simpa using bounded + have fits : old.revision.val + (1#u64 : Std.U64).val ≤ UScalar.max .U64 := by + scalar_tac + obtain ⟨next, nextEq, nextVal⟩ := + spec_imp_exists (UScalar.add_spec (x := old.revision) (y := 1#u64) fits) + rw [nextEq, bind_tc_ok] + have revisionEq : (new.revision = next) ↔ new.revision.val = old.revision.val + 1 := by + rw [UScalar.eq_equiv, nextVal] + simp + simp only [TransitionFacts.consistent_eq, TransitionFacts.entry_kept_eq, + TransitionFacts.plan_kept_eq, TransitionFacts.stage_transition_allowed_eq, + TransitionFacts.checkpoint_valid_eq, TransitionFacts.pre_entry_kept_eq, + TransitionFacts.response_kept_eq, TransitionFacts.acknowledgement_kept_eq, + same_bytes_eq, alloc.vec.Vec.deref, bind_tc_ok, revisionEq, result_guard, spec_ok] + simp [Auths.Product.Recovery.validTransition, viewOf, protocol, bounded', Bool.and_assoc] + · have bounded' : ¬ old.revision.val < 9007199254740991 := by simpa using bounded + simp [bounded, Auths.Product.Recovery.validTransition, viewOf, bounded', spec_ok] + · simp [protocol, Auths.Product.Recovery.validTransition, viewOf, spec_ok] end Transition diff --git a/formal/Auths/Product/SubmitOrder.lean b/formal/Auths/Product/SubmitOrder.lean index f1cdc1c16..2f1c50b14 100644 --- a/formal/Auths/Product/SubmitOrder.lean +++ b/formal/Auths/Product/SubmitOrder.lean @@ -22,13 +22,6 @@ namespace Auths.Product.SubmitOrder open Auths.Product.RelativeCeiling (admits) -/-- Why a lease is taken. -/ -inductive Mode where - | entry - | readBack - | reobserve - deriving DecidableEq, Repr - /-- The declarations the order depends on, fixed before the machine starts. -/ structure Plan where accountScope : Bool @@ -48,22 +41,21 @@ inductive Phase where | scope | prepare | claim - | resume - | reload (mode : Mode) - | lease (mode : Mode) - | prefixGuard (mode : Mode) - | account (mode : Mode) - | denied (mode : Mode) (index : Nat) + | reload + | lease + | prefixGuard + | account + | denied (index : Nat) | preEntry | ceiling | checkpoint | entryReload | deadline + | grant | send | recordResponse | recordUnknown | recordNotEntered - | readBack (mode : Mode) | done deriving DecidableEq, Repr @@ -83,7 +75,7 @@ inductive Verification where /-- The claim result. -/ inductive ClaimResult where - | inserted + | reserved | refused | replay | unavailable @@ -118,7 +110,6 @@ inductive CeilingRead where /-- The provider write result. -/ inductive WriteResult where - | notEntered | unknown | response deriving DecidableEq, Repr @@ -126,7 +117,7 @@ inductive WriteResult where /-- The result of recording the response. -/ inductive ResponseRecord where | failed - | recorded (observable : Bool) + | recorded deriving DecidableEq, Repr /-- The result of the action the previous decision named. -/ @@ -138,7 +129,6 @@ inductive Event where | scope (bound : Bool) | preparation (prepared : Bool) | claim (result : ClaimResult) - | resume (resumable : Bool) | reload (unchanged : Bool) | lease (leased : Bool) | prefixGuard (allowed : Bool) @@ -148,6 +138,7 @@ inductive Event where | ceiling (read : CeilingRead) | recorded (stored : Bool) | deadline (within : Bool) + | granted (granted : Bool) | write (result : WriteResult) | response (record : ResponseRecord) deriving DecidableEq, Repr @@ -178,8 +169,8 @@ inductive Stop where | notEntered | unknown | response - | observed - | replayRefused + | stored + | grantUnavailable | halted deriving DecidableEq, Repr @@ -191,22 +182,21 @@ inductive Action where | bindScope | prepare | claim - | resume - | reload (mode : Mode) - | lease (mode : Mode) - | checkPrefix (mode : Mode) - | readAccount (mode : Mode) - | deniedRead (mode : Mode) (index : Nat) + | reload + | lease + | checkPrefix + | readAccount + | deniedRead (index : Nat) | preEntryRead | ceilingRead | recordCheckpoint | reloadBeforeEntry | checkDeadline + | grantEntry | send | recordResponse | recordUnknown | recordNotEntered (refusal : Refusal) - | readBack (mode : Mode) | stop (stop : Stop) deriving DecidableEq, Repr @@ -232,12 +222,6 @@ def halt (state : State) : Decision := stop state .halted def notEntered (state : State) (refusal : Refusal) : Decision := go state .recordNotEntered (.recordNotEntered refusal) -def leaseFailed (state : State) (mode : Mode) (refusal : Refusal) : Decision := - match mode with - | .entry => notEntered state refusal - | .readBack => stop state .response - | .reobserve => stop state .replayRefused - def afterReads (state : State) : Decision := if state.plan.preEntry || state.plan.relativeCeiling then go state .checkpoint .recordCheckpoint @@ -250,21 +234,15 @@ def ceilingFrom (state : State) : Decision := def preEntryFrom (state : State) : Decision := if state.plan.preEntry then go state .preEntry .preEntryRead else ceilingFrom state -def afterCredentials (state : State) (mode : Mode) : Decision := - match mode with - | .entry => preEntryFrom state - | .readBack => go state (.readBack .readBack) (.readBack .readBack) - | .reobserve => go state (.readBack .reobserve) (.readBack .reobserve) - -def deniedFrom (state : State) (mode : Mode) (index : Nat) : Decision := +def deniedFrom (state : State) (index : Nat) : Decision := if index < state.plan.deniedReads then - go state (.denied mode index) (.deniedRead mode index) + go state (.denied index) (.deniedRead index) else - afterCredentials state mode + preEntryFrom state -def afterPrefix (state : State) (mode : Mode) : Decision := - if state.plan.accountRead then go state (.account mode) (.readAccount mode) - else deniedFrom state mode 0 +def afterPrefix (state : State) : Decision := + if state.plan.accountRead then go state .account .readAccount + else deniedFrom state 0 def afterAdmission (state : State) : Decision := if state.plan.accountScope then go state .scope .bindScope else go state .prepare .prepare @@ -273,21 +251,21 @@ def preClaim (state : State) (passed : Bool) (next : Decision) : Decision := if passed then next else stop state .refused def afterClaim (state : State) : ClaimResult → Decision - | .inserted => go state (.reload .entry) (.reload .entry) + | .reserved => go state .reload .reload | .refused => stop state .claimRefused - | .replay => go state .resume .resume + | .replay => stop state .stored | .unavailable => stop state .storeUnavailable -def afterAccount (state : State) (mode : Mode) : AccountResult → Decision - | .equal => deniedFrom state mode 0 - | .mismatch => leaseFailed state mode .accountMismatch - | .unavailable => leaseFailed state mode .accountUnavailable +def afterAccount (state : State) : AccountResult → Decision + | .equal => deniedFrom state 0 + | .mismatch => notEntered state .accountMismatch + | .unavailable => notEntered state .accountUnavailable -def afterDenied (state : State) (mode : Mode) (index : Nat) : DeniedResult → Decision +def afterDenied (state : State) (index : Nat) : DeniedResult → Decision | .refused => - if index < state.plan.deniedReads then deniedFrom state mode (index + 1) else halt state - | .answered => leaseFailed state mode .capabilityExcess - | .unavailable => leaseFailed state mode .capabilityUnavailable + if index < state.plan.deniedReads then deniedFrom state (index + 1) else halt state + | .answered => notEntered state .capabilityExcess + | .unavailable => notEntered state .capabilityUnavailable def afterPreEntry (state : State) : PreEntryResult → Decision | .satisfied => ceilingFrom state @@ -304,23 +282,12 @@ def afterCeiling (state : State) : CeilingRead → Decision else notEntered state .ceilingAbove def afterWrite (state : State) : WriteResult → Decision - | .notEntered => notEntered state .transportNotEntered | .unknown => go state .recordUnknown .recordUnknown | .response => go state .recordResponse .recordResponse def afterResponse (state : State) : ResponseRecord → Decision | .failed => stop state .unknown - | .recorded observable => - if observable then go state (.reload .readBack) (.reload .readBack) - else stop state .response - -def afterReadBack (state : State) (mode : Mode) (recorded : Bool) : Decision := - if recorded then stop state .observed - else - match mode with - | .entry => halt state - | .readBack => stop state .response - | .reobserve => stop state .replayRefused + | .recorded => stop state .response /-- The step before the claim. -/ def preClaimStep (state : State) (event : Event) : Decision := @@ -339,19 +306,16 @@ def preClaimStep (state : State) (event : Event) : Decision := /-- A lease-time step. -/ def leaseStep (state : State) (event : Event) : Decision := match state.phase, event with - | .resume, .resume resumable => - if resumable then go state (.reload .reobserve) (.reload .reobserve) - else stop state .replayRefused - | .reload mode, .reload unchanged => - if unchanged then go state (.lease mode) (.lease mode) - else leaseFailed state mode .connectionChanged - | .lease mode, .lease leased => - if leased then go state (.prefixGuard mode) (.checkPrefix mode) - else leaseFailed state mode .credentialUnavailable - | .prefixGuard mode, .prefixGuard allowed => - if allowed then afterPrefix state mode else leaseFailed state mode .modeGuard - | .account mode, .account result => afterAccount state mode result - | .denied mode index, .denied result => afterDenied state mode index result + | .reload, .reload unchanged => + if unchanged then go state .lease .lease + else notEntered state .connectionChanged + | .lease, .lease leased => + if leased then go state .prefixGuard .checkPrefix + else notEntered state .credentialUnavailable + | .prefixGuard, .prefixGuard allowed => + if allowed then afterPrefix state else notEntered state .modeGuard + | .account, .account result => afterAccount state result + | .denied index, .denied result => afterDenied state index result | _, _ => halt state /-- A step between the credential checks and the stop. -/ @@ -365,23 +329,24 @@ def entryStep (state : State) (event : Event) : Decision := if unchanged then go state .deadline .checkDeadline else notEntered state .connectionChanged | .deadline, .deadline within => - if within then go state .send .send else notEntered state .entryDeadline + if within then go state .grant .grantEntry else notEntered state .entryDeadline + | .grant, .granted granted => + if granted then go state .send .send else stop state .grantUnavailable | .send, .write result => afterWrite state result | .recordResponse, .response record => afterResponse state record | .recordUnknown, .recorded _ => stop state .unknown | .recordNotEntered, .recorded stored => if stored then stop state .notEntered else stop state .unknown - | .readBack mode, .recorded recorded => afterReadBack state mode recorded | _, _ => halt state /-- The next state and action for `event`. -/ def nextStep (state : State) (event : Event) : Decision := match state.phase with | .start | .clock | .verify | .admit | .scope | .prepare | .claim => preClaimStep state event - | .resume | .reload _ | .lease _ | .prefixGuard _ | .account _ | .denied _ _ => + | .reload | .lease | .prefixGuard | .account | .denied _ => leaseStep state event - | .preEntry | .ceiling | .checkpoint | .entryReload | .deadline | .send | .recordResponse - | .recordUnknown | .recordNotEntered | .readBack _ => entryStep state event + | .preEntry | .ceiling | .checkpoint | .entryReload | .deadline | .grant | .send | .recordResponse + | .recordUnknown | .recordNotEntered => entryStep state event | .done => halt state /-! ## Traces -/ @@ -421,12 +386,12 @@ def Emitted (trace : List Step) (action : Action) : Prop := /-- The actions that write the attempt store. -/ def writesStore : Action → Bool | .claim | .recordCheckpoint | .recordNotEntered _ | .recordResponse | .recordUnknown - | .readBack _ => true + | .grantEntry => true | _ => false /-- The actions that touch the credential or the provider write. -/ def leasesOrSends : Action → Bool - | .lease _ | .send => true + | .lease | .send => true | _ => false theorem run_append (state : State) (events : List Event) (event : Event) : @@ -507,9 +472,9 @@ theorem nextStep_plan (state : State) (event : Event) : rcases state with ⟨plan, phase, argument⟩ cases phase <;> cases event <;> simp only [nextStep, preClaimStep, leaseStep, entryStep, go, stop, halt, notEntered, - leaseFailed, afterReads, ceilingFrom, preEntryFrom, afterCredentials, deniedFrom, + afterReads, ceilingFrom, preEntryFrom, deniedFrom, afterPrefix, afterAdmission, preClaim, afterClaim, afterAccount, afterDenied, afterPreEntry, - afterCeiling, afterWrite, afterResponse, afterReadBack] <;> + afterCeiling, afterWrite, afterResponse] <;> (repeat' split) <;> rfl /-- Induction over a trace one event at a time, from the end. -/ @@ -535,21 +500,19 @@ theorem stateAfter_plan (plan : Plan) (events : List Event) : def Verified (trace : List Step) (argument : Nat) : Prop := Answered trace .verify (.verification (.authorized argument)) -/-- The claim a lease mode depends on: an inserted claim for the entry and -its read-back, a replayed claim for a re-observation. -/ -def Claimed (trace : List Step) : Mode → Prop - | .entry | .readBack => Answered trace .claim (.claim .inserted) - | .reobserve => Answered trace .claim (.claim .replay) +/-- The durable reservation accepted before credential access. -/ +def Claimed (trace : List Step) : Prop := + Answered trace .claim (.claim .reserved) -/-- Every credential check of a lease in `mode` passed: the lease, the +/-- Every credential check passed: the lease, the prefix guard, the account read when declared, and every declared denied read. -/ -def CredentialsChecked (trace : List Step) (plan : Plan) (mode : Mode) : Prop := - Answered trace (.lease mode) (.lease true) ∧ - Answered trace (.prefixGuard mode) (.prefixGuard true) ∧ - (plan.accountRead = true → Answered trace (.account mode) (.account .equal)) ∧ +def CredentialsChecked (trace : List Step) (plan : Plan) : Prop := + Answered trace .lease (.lease true) ∧ + Answered trace .prefixGuard (.prefixGuard true) ∧ + (plan.accountRead = true → Answered trace .account (.account .equal)) ∧ ∀ index, index < plan.deniedReads → - Answered trace (.denied mode index) (.denied .refused) + Answered trace (.denied index) (.denied .refused) /-- The relative-ceiling read produced a basis with every bind equal, and the ratio admits `argument`. -/ @@ -570,46 +533,47 @@ def Facts (trace : List Step) (state : State) : Prop := | .prepare | .claim => Verified trace state.argument ∧ (state.plan.accountScope = true → Answered trace .scope (.scope true)) - | .resume => Verified trace state.argument ∧ Claimed trace .reobserve - | .reload mode | .lease mode => Verified trace state.argument ∧ Claimed trace mode - | .prefixGuard mode => - Verified trace state.argument ∧ Claimed trace mode ∧ - Answered trace (.lease mode) (.lease true) - | .account mode => - Verified trace state.argument ∧ Claimed trace mode ∧ - Answered trace (.lease mode) (.lease true) ∧ - Answered trace (.prefixGuard mode) (.prefixGuard true) - | .denied mode index => - Verified trace state.argument ∧ Claimed trace mode ∧ - Answered trace (.lease mode) (.lease true) ∧ - Answered trace (.prefixGuard mode) (.prefixGuard true) ∧ - (state.plan.accountRead = true → Answered trace (.account mode) (.account .equal)) ∧ - ∀ earlier, earlier < index → Answered trace (.denied mode earlier) (.denied .refused) - | .readBack mode => - Verified trace state.argument ∧ Claimed trace mode ∧ - CredentialsChecked trace state.plan mode + | .reload | .lease => Verified trace state.argument ∧ Claimed trace + | .prefixGuard => + Verified trace state.argument ∧ Claimed trace ∧ + Answered trace .lease (.lease true) + | .account => + Verified trace state.argument ∧ Claimed trace ∧ + Answered trace .lease (.lease true) ∧ + Answered trace .prefixGuard (.prefixGuard true) + | .denied index => + Verified trace state.argument ∧ Claimed trace ∧ + Answered trace .lease (.lease true) ∧ + Answered trace .prefixGuard (.prefixGuard true) ∧ + (state.plan.accountRead = true → Answered trace .account (.account .equal)) ∧ + ∀ earlier, earlier < index → Answered trace (.denied earlier) (.denied .refused) | .preEntry => - Verified trace state.argument ∧ Claimed trace .entry ∧ - CredentialsChecked trace state.plan .entry + Verified trace state.argument ∧ Claimed trace ∧ + CredentialsChecked trace state.plan | .ceiling => - Verified trace state.argument ∧ Claimed trace .entry ∧ - CredentialsChecked trace state.plan .entry ∧ + Verified trace state.argument ∧ Claimed trace ∧ + CredentialsChecked trace state.plan ∧ (state.plan.preEntry = true → Answered trace .preEntry (.preEntry .satisfied)) | .checkpoint | .entryReload => - Verified trace state.argument ∧ Claimed trace .entry ∧ - CredentialsChecked trace state.plan .entry ∧ + Verified trace state.argument ∧ Claimed trace ∧ + CredentialsChecked trace state.plan ∧ ReadsPassed trace state.plan state.argument - | .deadline | .send | .recordResponse | .recordUnknown => - Verified trace state.argument ∧ Claimed trace .entry ∧ - CredentialsChecked trace state.plan .entry ∧ + | .deadline => + Verified trace state.argument ∧ Claimed trace ∧ + CredentialsChecked trace state.plan ∧ ReadsPassed trace state.plan state.argument ∧ Answered trace .entryReload (.reload true) - -theorem denied_extend {trace : List Step} {mode : Mode} {index bound : Nat} - (prior : ∀ earlier, earlier < index → Answered trace (.denied mode earlier) (.denied .refused)) + | .grant | .send | .recordResponse | .recordUnknown => + Verified trace state.argument ∧ Claimed trace ∧ + CredentialsChecked trace state.plan ∧ ReadsPassed trace state.plan state.argument ∧ + Answered trace .entryReload (.reload true) ∧ + Answered trace .deadline (.deadline true) + +theorem denied_extend {trace : List Step} {index bound : Nat} + (prior : ∀ earlier, earlier < index → Answered trace (.denied earlier) (.denied .refused)) (within : bound ≤ index + 1) : ∀ earlier, earlier < bound → - Answered trace (.denied mode earlier) (.denied .refused) ∨ index = earlier := by + Answered trace (.denied earlier) (.denied .refused) ∨ index = earlier := by intro earlier below by_cases before : earlier < index · exact Or.inl (prior earlier before) @@ -622,9 +586,9 @@ theorem facts_step (trace : List Step) (state : State) (event : Event) rcases state with ⟨plan, phase, argument⟩ cases phase <;> cases event <;> simp only [nextStep, preClaimStep, leaseStep, entryStep, go, stop, halt, notEntered, - leaseFailed, afterReads, ceilingFrom, preEntryFrom, afterCredentials, deniedFrom, + afterReads, ceilingFrom, preEntryFrom, deniedFrom, afterPrefix, afterAdmission, preClaim, afterClaim, afterAccount, afterDenied, afterPreEntry, - afterCeiling, afterWrite, afterResponse, afterReadBack] at facts ⊢ <;> + afterCeiling, afterWrite, afterResponse] at facts ⊢ <;> (repeat' split) <;> simp_all [Facts, Verified, Claimed, CredentialsChecked, CeilingAdmitted, ReadsPassed, answered_append] <;> @@ -648,15 +612,12 @@ def preClaimAction : Action → Bool /-- The phases the machine can be in once it named the write. -/ def afterSend : Phase → Bool - | .send | .recordResponse | .recordUnknown | .recordNotEntered | .done - | .reload .readBack | .lease .readBack | .prefixGuard .readBack | .account .readBack - | .denied .readBack _ | .readBack .readBack => true + | .send | .recordResponse | .recordUnknown | .done => true | _ => false -/-- The phases the machine can be in once a claim replayed. -/ +/-- A replay returns the retained record without another effect. -/ def replaying : Phase → Bool - | .resume | .reload .reobserve | .lease .reobserve | .prefixGuard .reobserve - | .account .reobserve | .denied .reobserve _ | .readBack .reobserve | .done => true + | .done => true | _ => false /-- The ordering invariant of a trace ending in `state`. -/ @@ -686,11 +647,11 @@ set_option hygiene false in /-- Unfolds one step of the machine and closes each case of the case split. -/ macro "step_cases" : tactic => `(tactic| ( rcases state with ⟨plan, phase, argument⟩ - cases phase <;> (try cases ‹Mode›) <;> cases event <;> (try cases ‹Verification›) <;> + cases phase <;> cases event <;> (try cases ‹Verification›) <;> simp only [nextStep, preClaimStep, leaseStep, entryStep, go, stop, halt, notEntered, - leaseFailed, afterReads, ceilingFrom, preEntryFrom, afterCredentials, deniedFrom, + afterReads, ceilingFrom, preEntryFrom, deniedFrom, afterPrefix, afterAdmission, preClaim, afterClaim, afterAccount, afterDenied, afterPreEntry, - afterCeiling, afterWrite, afterResponse, afterReadBack] <;> + afterCeiling, afterWrite, afterResponse] <;> (repeat' split) <;> simp_all [argumentAfter, beforeVerification, beforeClaim, preClaimAction, afterSend, replaying])) @@ -713,7 +674,7 @@ theorem before_claim_step (state : State) (event : Event) theorem send_step (state : State) (event : Event) (sent : (nextStep state event).action = .send) : - state.phase = .deadline ∧ event = .deadline true ∧ (nextStep state event).state.phase = .send := by + state.phase = .grant ∧ event = .granted true ∧ (nextStep state event).state.phase = .send := by revert sent step_cases @@ -800,9 +761,9 @@ theorem ordered_step (trace : List Step) (state : State) (event : Event) rw [phaseEq] at this cases this -theorem lease_named (state : State) (event : Event) (mode : Mode) - (leased : (nextStep state event).action = .lease mode) : - state.phase = .reload mode ∧ event = .reload true := by +theorem lease_named (state : State) (event : Event) + (leased : (nextStep state event).action = .lease) : + state.phase = .reload ∧ event = .reload true := by revert leased step_cases @@ -836,36 +797,31 @@ theorem invariant (plan : Plan) (events : List Event) : /-! ## Ordering theorems -/ -/-- A credential lease is named only on a successful connection reload in -the reload phase of its mode, after native verification authorized the -action, and after the claim it depends on: an inserted claim for the entry -and its read-back, a replayed claim for a re-observation. -/ +/-- A credential lease requires native authorization and a durable reservation. -/ theorem lease_requires_verified_claim (plan : Plan) (pre : List Event) (event : Event) - (mode : Mode) (leased : (nextStep (stateAfter plan pre) event).action = .lease mode) : - event = .reload true ∧ (stateAfter plan pre).phase = .reload mode ∧ + (leased : (nextStep (stateAfter plan pre) event).action = .lease) : + event = .reload true ∧ (stateAfter plan pre).phase = .reload ∧ (∃ argument, Verified (steps plan pre) argument) ∧ - (mode = .reobserve → Answered (steps plan pre) .claim (.claim .replay)) ∧ - (mode ≠ .reobserve → Answered (steps plan pre) .claim (.claim .inserted)) := by - obtain ⟨phase, eventEq⟩ := lease_named _ _ _ leased + Answered (steps plan pre) .claim (.claim .reserved) := by + obtain ⟨phase, eventEq⟩ := lease_named _ _ leased have facts := (invariant plan pre).1 unfold Facts at facts rw [phase] at facts - obtain ⟨verified, claimed⟩ := facts - refine ⟨eventEq, phase, ⟨_, verified⟩, ?_, ?_⟩ <;> intro modeEq <;> cases mode <;> - simp_all [Claimed] - -/-- The write is named only on a successful deadline check, after the entry -lease succeeded, after the declared pre-entry re-read was satisfied, after -the connection reload before entry found the record unchanged, and after an -inserted claim of a verified action. -/ + exact ⟨eventEq, phase, ⟨_, facts.1⟩, facts.2⟩ + +/-- The write is named only on a successful durable grant, after the deadline +check and entry lease, after the declared pre-entry re-read was satisfied, +after the connection reload found the record unchanged, and after a durable +reservation of a verified action. -/ theorem send_requires_lease_and_deadline (plan : Plan) (pre : List Event) (event : Event) (sent : (nextStep (stateAfter plan pre) event).action = .send) : - event = .deadline true ∧ (stateAfter plan pre).phase = .deadline ∧ + event = .granted true ∧ (stateAfter plan pre).phase = .grant ∧ (∃ argument, Verified (steps plan pre) argument) ∧ - Answered (steps plan pre) .claim (.claim .inserted) ∧ - Answered (steps plan pre) (.lease .entry) (.lease true) ∧ + Answered (steps plan pre) .claim (.claim .reserved) ∧ + Answered (steps plan pre) .lease (.lease true) ∧ (plan.preEntry = true → Answered (steps plan pre) .preEntry (.preEntry .satisfied)) ∧ - Answered (steps plan pre) .entryReload (.reload true) := by + Answered (steps plan pre) .entryReload (.reload true) ∧ + Answered (steps plan pre) .deadline (.deadline true) := by obtain ⟨phase, eventEq, _⟩ := send_step _ _ sent have facts := (invariant plan pre).1 unfold Facts at facts @@ -878,10 +834,10 @@ check: the prefix guard, the account read with equal commitments when declared, and every declared denied read refused with a declared status. -/ theorem send_requires_credential_checks (plan : Plan) (pre : List Event) (event : Event) (sent : (nextStep (stateAfter plan pre) event).action = .send) : - Answered (steps plan pre) (.prefixGuard .entry) (.prefixGuard true) ∧ - (plan.accountRead = true → Answered (steps plan pre) (.account .entry) (.account .equal)) ∧ + Answered (steps plan pre) .prefixGuard (.prefixGuard true) ∧ + (plan.accountRead = true → Answered (steps plan pre) .account (.account .equal)) ∧ ∀ index, index < plan.deniedReads → - Answered (steps plan pre) (.denied .entry index) (.denied .refused) := by + Answered (steps plan pre) (.denied index) (.denied .refused) := by obtain ⟨phase, _, _⟩ := send_step _ _ sent have facts := (invariant plan pre).1 unfold Facts at facts @@ -948,13 +904,13 @@ theorem pre_claim_refusal_stores_nothing (plan : Plan) (pre : List Event) (event records, by phase and event; `none` for every other step. -/ def refusalOf (state : State) (event : Event) : Option Refusal := match state.phase, event with - | .reload .entry, .reload false => some .connectionChanged - | .lease .entry, .lease false => some .credentialUnavailable - | .prefixGuard .entry, .prefixGuard false => some .modeGuard - | .account .entry, .account .mismatch => some .accountMismatch - | .account .entry, .account .unavailable => some .accountUnavailable - | .denied .entry _, .denied .answered => some .capabilityExcess - | .denied .entry _, .denied .unavailable => some .capabilityUnavailable + | .reload, .reload false => some .connectionChanged + | .lease, .lease false => some .credentialUnavailable + | .prefixGuard, .prefixGuard false => some .modeGuard + | .account, .account .mismatch => some .accountMismatch + | .account, .account .unavailable => some .accountUnavailable + | .denied _, .denied .answered => some .capabilityExcess + | .denied _, .denied .unavailable => some .capabilityUnavailable | .preEntry, .preEntry .conditionFalse => some .preEntryConditionFalse | .preEntry, .preEntry .unavailable => some .preEntryUnavailable | .ceiling, .ceiling .unavailable => some .ceilingUnavailable @@ -963,7 +919,6 @@ def refusalOf (state : State) (event : Event) : Option Refusal := if admits state.argument basis state.plan.basisPoints then none else some .ceilingAbove | .entryReload, .reload false => some .connectionChanged | .deadline, .deadline false => some .entryDeadline - | .send, .write .notEntered => some .transportNotEntered | _, _ => none /-- The per-phase table: a step records `not-entered` with a refusal exactly @@ -982,30 +937,29 @@ theorem not_entered_phase (state : State) (event : Event) (refusal : Refusal) theorem refusal_claimed (trace : List Step) (state : State) (event : Event) (refusal : Refusal) (facts : Facts trace state) (assigned : refusalOf state event = some refusal) : - Answered trace .claim (.claim .inserted) := by + Answered trace .claim (.claim .reserved) := by rcases state with ⟨plan, phase, argument⟩ - cases phase <;> (try cases ‹Mode›) <;> simp_all [Facts, Claimed, refusalOf] + cases phase <;> simp_all [Facts, Claimed, refusalOf] theorem refusal_after_send (state : State) (event : Event) (refusal : Refusal) (sent : afterSend state.phase = true) (assigned : refusalOf state event = some refusal) : - refusal = .transportNotEntered := by + False := by rcases state with ⟨plan, phase, argument⟩ - cases phase <;> (try cases ‹Mode›) <;> cases event <;> simp_all [afterSend, refusalOf] <;> + cases phase <;> cases event <;> simp_all [afterSend, refusalOf] <;> (repeat' split at assigned) <;> simp_all /-- Over every trace: a step records `not-entered` exactly when the claim -was inserted and the step's phase and event are a failure the table assigns +was reserved and the step's phase and event are a failure the table assigns a refusal to, and the recorded refusal is that failure's. Once the write was -named, the only such failure is the transport's refusal before network -entry. -/ +named, no such refusal can be emitted. -/ theorem post_claim_refusal_records_not_entered (plan : Plan) (pre : List Event) (event : Event) (refusal : Refusal) : ((nextStep (stateAfter plan pre) event).action = .recordNotEntered refusal ↔ - Answered (steps plan pre) .claim (.claim .inserted) ∧ + Answered (steps plan pre) .claim (.claim .reserved) ∧ refusalOf (stateAfter plan pre) event = some refusal) ∧ ((nextStep (stateAfter plan pre) event).action = .recordNotEntered refusal → (nextStep (stateAfter plan pre) event).state.phase = .recordNotEntered ∧ - (Emitted (steps plan pre) .send → refusal = .transportNotEntered)) := by + ¬ Emitted (steps plan pre) .send) := by obtain ⟨facts, _, _, _, _, sent, _⟩ := invariant plan pre refine ⟨⟨fun recorded => ?_, fun ⟨_, assigned⟩ => ?_⟩, fun recorded => ?_⟩ · have assigned := (not_entered_refusal_table _ _ _).mp recorded @@ -1014,4 +968,28 @@ theorem post_claim_refusal_records_not_entered (plan : Plan) (pre : List Event) · refine ⟨not_entered_phase _ _ _ recorded, fun emitted => ?_⟩ exact refusal_after_send _ _ _ (sent emitted) ((not_entered_refusal_table _ _ _).mp recorded) +/-- A recorded response is a terminal submission result. Observation requires a +separate authorized operation; the submission machine emits no follow-up read. -/ +theorem response_stops_without_read (state : State) (phase : state.phase = .recordResponse) : + nextStep state (.response .recorded) = stop state .response := by + rcases state with ⟨plan, phase', argument⟩ + cases phase + rfl + +/-- Losing or replaying an existing reservation returns its retained record; +it cannot resume credential acquisition or issue another entry grant. -/ +theorem replay_returns_stored (state : State) (phase : state.phase = .claim) : + nextStep state (.claim .replay) = stop state .stored := by + rcases state with ⟨plan, phase', argument⟩ + cases phase + rfl + +/-- A failed durable grant stops without sending, and never fabricates a +not-entered refund after the authority boundary. -/ +theorem refused_grant_stops_without_send (state : State) (phase : state.phase = .grant) : + nextStep state (.granted false) = stop state .grantUnavailable := by + rcases state with ⟨plan, phase', argument⟩ + cases phase + rfl + end Auths.Product.SubmitOrder diff --git a/formal/Auths/Theorems.lean b/formal/Auths/Theorems.lean index ede497928..5c390bcdb 100644 --- a/formal/Auths/Theorems.lean +++ b/formal/Auths/Theorems.lean @@ -182,6 +182,10 @@ def theoremInventory : List Lean.Name := `Auths.Product.Recovery.class_matches_declarations, `Auths.Product.Recovery.write_never_conditional, `Auths.Product.Recovery.unknown_resolves_only_linked, + `Auths.Product.Recovery.unknown_exits_with_bound_evidence, + `Auths.Product.Recovery.transition_ownership, + `Auths.Product.Recovery.late_response_retains_source, + `Auths.Product.Recovery.late_acknowledgement_retains_source, `Auths.Product.Recovery.provider_claim_requires_evidence, `Auths.Product.Recovery.terminal_stages_final, `Auths.Product.Recovery.transitions_preserve_identity, @@ -191,6 +195,9 @@ def theoremInventory : List Lean.Name := `Auths.Product.SubmitOrder.send_requires_relative_ceiling, `Auths.Product.SubmitOrder.account_scope_requires_binding, `Auths.Product.SubmitOrder.at_most_one_send, + `Auths.Product.SubmitOrder.response_stops_without_read, + `Auths.Product.SubmitOrder.replay_returns_stored, + `Auths.Product.SubmitOrder.refused_grant_stops_without_send, `Auths.Product.SubmitOrder.pre_claim_refusal_stores_nothing, `Auths.Product.SubmitOrder.not_entered_refusal_table, `Auths.Product.SubmitOrder.post_claim_refusal_records_not_entered, diff --git a/formal/README.md b/formal/README.md index c94b8ae7d..6254e1fcd 100644 --- a/formal/README.md +++ b/formal/README.md @@ -125,3 +125,52 @@ the translation, toolchain, source, and evidence inputs still match. Changes to those inputs require two fresh, byte-identical reproductions. The complete qualified path remains in hosted CI; contributors do not need to install the formal toolchains locally to receive proof diagnostics. + +## AP074 gateway correspondence review + +The AP074 repair replaces the earlier implicit-read submission model with the +shipping `order::next_step` machine. A successful deadline check names durable +grant creation; only `Granted(true)` names `Send`. A replay stops with `Stored`, +and recording a response stops with `Response`. The ordering proofs retain +native verification, durable reservation, credential checks, pre-entry reads, +relative ceilings, and at most one send. A post-send path cannot produce a +refunding `NotEntered` result. + +The attempt projection now includes its protocol, bounded revision, entry grant, +and recipient acknowledgement. `translated_valid_transition_refines_model` +proves exact correspondence for every pair of translated views, including +revision-overflow refusal. The natural model proves protocol retention, +revision advancement, grant retention, and terminal-stage finality. Its unknown +exit table distinguishes three evidence routes: + +- A late source response retains the original grant and records response facts, + without asserting provider observation. +- A late recipient acknowledgement is restricted to disclosure, retains the + original grant, and cannot claim a provider response or observation. +- An independently authorized linked observation can establish + `ObservedByProvider` from unknown only with the retained verified-locator link + and recorded provider evidence. + +The first two routes have separate `late_response_retains_source` and +`late_acknowledgement_retains_source` theorems. The qualified unknown-observation +claim is deliberately conditional on the target being `ObservedByProvider`; +`unknown_exits_with_bound_evidence` proves the complete exit table. The old +statement that *every* unknown exit must be provider observation is no longer +true of the shipping contract and is not advertised as such. + +These are proofs about the decision leaves and canonical byte projections. +They do not prove signature verification, exact recipient/challenge binding, +source provenance, store atomicity, or external I/O. The runtime must establish +those facts before constructing the projection and must authorize recovery as a +separate operation. Nonempty acknowledgement bytes in the model are not a +substitute for the runtime's authentication checks. Process, store, transport, +and cryptographic tests remain required alongside these proofs. + +The reviewed gateway translation inventory is 126 local functions with zero +external or opaque local functions. AP074 adds `acknowledgement_kept`, +`acknowledgement_stage`, `entry_kept`, `protocol_consistent`, `requires_entry`, +and `same_protocol`; all are closed transition checks covered by refinement. +It removes `after_credentials`, `after_read_back`, and `lease_failed`, which +implemented the obsolete mode-dependent implicit-read route. Regeneration uses +the unchanged pinned Charon/Aeneas/Lean toolchains and two clean translations; +the inventory change is not an exception to the translation or axiom gates. diff --git a/formal/assurance-manifest-v1.toml b/formal/assurance-manifest-v1.toml index ee29fb643..b34c2d9e1 100644 --- a/formal/assurance-manifest-v1.toml +++ b/formal/assurance-manifest-v1.toml @@ -1,8 +1,8 @@ schema = "auths-proof-formal-assurance/v1" lean_toolchain = "leanprover/lean4:v4.31.0" toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" -statement_review = "native-k-of-n-approvals-2026-09-30" -statement_inventory_sha256 = "717939bc5edda0732568a53e598d571b4c3e7584267b23dd1536de29ca0b9838" +statement_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +statement_inventory_sha256 = "09e7c08798aa84244d364c0de8c4d5258978f57ef5a4a62f6b1409e00540db40" allowed_axioms = [ "Classical.choice", "Quot.sound", @@ -15,7 +15,7 @@ claim_text = "Lean proves the rich authority property: finiteSet subset refl." claim_status = "proved" lean_declaration = "Auths.Rich.finiteSet_subset_refl" lean_statement_sha256 = "cac9d4b80390ce990484b56aee1f0d20fcb8d1b2b2b8f07ef1fa819caca6982c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -77,7 +77,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -97,7 +97,7 @@ claim_text = "Lean proves the rich authority property: finiteSet subset trans." claim_status = "proved" lean_declaration = "Auths.Rich.finiteSet_subset_trans" lean_statement_sha256 = "620ac85f39efb4108727cc41c2b3b7663eea53ffde7ef5d782ee2e5897e161da" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -159,7 +159,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -179,7 +179,7 @@ claim_text = "Lean proves the rich authority property: finiteSet subset antisymm claim_status = "proved" lean_declaration = "Auths.Rich.finiteSet_subset_antisymm" lean_statement_sha256 = "04c8f87dfb0552e7abf656cf19ca4e29a5a81369e1178eb7d9aa634966a115be" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -241,7 +241,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -261,7 +261,7 @@ claim_text = "Lean proves the rich authority property: finiteSet membership mono claim_status = "proved" lean_declaration = "Auths.Rich.finiteSet_membership_monotone" lean_statement_sha256 = "526bdf55ccea3aa1a07aef06197ef303b18a5c083994c97056422713106028a2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -323,7 +323,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -343,7 +343,7 @@ claim_text = "Lean proves the rich authority property: window contained refl." claim_status = "proved" lean_declaration = "Auths.Rich.window_contained_refl" lean_statement_sha256 = "52b61c239b76a3ec75ebc375c19ba060e170f9c88ab845652188da7e1f32c715" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -405,7 +405,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -422,7 +422,7 @@ claim_text = "Lean proves the rich authority property: window contained trans." claim_status = "proved" lean_declaration = "Auths.Rich.window_contained_trans" lean_statement_sha256 = "ed63f2b8060617d8e042f212bea8d9df13b58494cd94ef01081d7c849e19de7b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -484,7 +484,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -505,7 +505,7 @@ claim_text = "Lean proves the rich authority property: window contained antisymm claim_status = "proved" lean_declaration = "Auths.Rich.window_contained_antisymm" lean_statement_sha256 = "a263d89be575fd98940d6a3324ec862360cfe26b2024dd38a13b828b763aa74a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -567,7 +567,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -588,7 +588,7 @@ claim_text = "Lean proves the rich authority property: window coverage monotone. claim_status = "proved" lean_declaration = "Auths.Rich.window_coverage_monotone" lean_statement_sha256 = "e8d8a9503bde767273a9b55883a18365323b88ae798ebd4de744ffd822ee9dd7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -650,7 +650,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -671,7 +671,7 @@ claim_text = "Lean proves the rich authority property: action constraint refl." claim_status = "proved" lean_declaration = "Auths.Rich.action_constraint_refl" lean_statement_sha256 = "6b41a97add7b56d69dde91e7008ca41e34f568ca4081d8b81ca5b728342e5c1d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -733,7 +733,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -753,7 +753,7 @@ claim_text = "Lean proves the rich authority property: action constraint trans." claim_status = "proved" lean_declaration = "Auths.Rich.action_constraint_trans" lean_statement_sha256 = "1510dabf7d9cf6d4c1bdb99de295ced7f32f3c44678519aef38aa3fb58dcdee0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -815,7 +815,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -836,7 +836,7 @@ claim_text = "Lean proves the rich authority property: action constraint antisym claim_status = "proved" lean_declaration = "Auths.Rich.action_constraint_antisymm" lean_statement_sha256 = "59a7fb2812568c3a9eabd67248452de770baf4d2e1daf9ebf2dbea0baa42c81d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -898,7 +898,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -919,7 +919,7 @@ claim_text = "Lean proves the rich authority property: action constraint canonic claim_status = "proved" lean_declaration = "Auths.Rich.action_constraint_canonical_antisymm" lean_statement_sha256 = "47d8802981c338d34dedf567e68555c3cca9f298dd13c681ba4b3baa927a6813" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -981,7 +981,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1002,7 +1002,7 @@ claim_text = "Lean proves the rich authority property: action constraint allows claim_status = "proved" lean_declaration = "Auths.Rich.action_constraint_allows_monotone" lean_statement_sha256 = "49927a15dec0e627c64244b981bd81ca171589f5ada904616bcec9811746efe2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1064,7 +1064,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1085,7 +1085,7 @@ claim_text = "Lean proves the rich authority property: budget refl." claim_status = "proved" lean_declaration = "Auths.Rich.budget_refl" lean_statement_sha256 = "54ffb1f592e48a7292cb925afd2f0e1c4c2412a46b7b5d8aeec7113fe58fc09a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1147,7 +1147,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1164,7 +1164,7 @@ claim_text = "Lean proves the rich authority property: budget trans." claim_status = "proved" lean_declaration = "Auths.Rich.budget_trans" lean_statement_sha256 = "313fe44a88fa3efd9bc1800bf0e6169039c5bcec051b847ea86c71d27318e0ae" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1226,7 +1226,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1243,7 +1243,7 @@ claim_text = "Lean proves the rich authority property: budget antisymm." claim_status = "proved" lean_declaration = "Auths.Rich.budget_antisymm" lean_statement_sha256 = "569b03bd90e823b38193e8a9681faf27341786455644132e4861c779c8c3395b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1305,7 +1305,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1322,7 +1322,7 @@ claim_text = "Lean proves the rich authority property: budget coverage monotone. claim_status = "proved" lean_declaration = "Auths.Rich.budget_coverage_monotone" lean_statement_sha256 = "594cf3b8740d3b68643756cf665f0be72b2b5b010227f5efc0407ce78fc91520" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1384,7 +1384,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1401,7 +1401,7 @@ claim_text = "Lean proves the rich authority property: budget action coverage mo claim_status = "proved" lean_declaration = "Auths.Rich.budget_action_coverage_monotone" lean_statement_sha256 = "986470888869bfa94623fd5d5f4a7a72820170912004d0710b39127565ab0379" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1463,7 +1463,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1480,7 +1480,7 @@ claim_text = "An expressible profile with no budget request under a bounded ceil claim_status = "proved" lean_declaration = "Auths.Rich.budgetCoversAction_expressible_absent_bounded" lean_statement_sha256 = "9b30941cc8a5c3b3aa4c70e4703fb0e902ed07d7d0f5d07536f087234423a0b4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1542,7 +1542,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 budget coverage over opaque identity carriers." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1559,7 +1559,7 @@ claim_text = "Lean proves the rich authority property: extensions refl." claim_status = "proved" lean_declaration = "Auths.Rich.extensions_refl" lean_statement_sha256 = "3deb6e01a441a7e322859de8eadaec18124a1cb370b09a38322fb4e17dfcb4cf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1621,7 +1621,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1638,7 +1638,7 @@ claim_text = "Lean proves the rich authority property: extensions trans." claim_status = "proved" lean_declaration = "Auths.Rich.extensions_trans" lean_statement_sha256 = "90aa05bf5d3bdaa2f0a8df2b7738628d66fdc848f306b392a015a2e1e12ba9e4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1700,7 +1700,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1717,7 +1717,7 @@ claim_text = "Lean proves the rich authority property: extensions le pinned iff. claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_pinned_iff" lean_statement_sha256 = "98fe643cba56dcda0d75b3dc27de128995feff749567004d74f0bf6a8ecf7e37" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1779,7 +1779,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1796,7 +1796,7 @@ claim_text = "Lean proves the rich authority property: extensions le false of dr claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_false_of_dropped" lean_statement_sha256 = "46a605cf7dea5af58e69b6f0bbc4ffed2ed34084cda7ea99b680ca975ac47f3a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1858,7 +1858,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1875,7 +1875,7 @@ claim_text = "Lean proves a child that strips a pinned critical-extension identi claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_false_of_stripped" lean_statement_sha256 = "92f064c6de7f9415d2483d26e88473b421a0b266b431f939de9f4178952ef6cd" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -1937,7 +1937,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -1954,7 +1954,7 @@ claim_text = "Lean proves a child whose payload for a pinned identifier its law claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_false_of_refused" lean_statement_sha256 = "4639baf3f61027f8833b78149c26c0af128dc39852f0360464e854e34acb944d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2016,7 +2016,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2033,7 +2033,7 @@ claim_text = "Lean proves a child that adds an identifier whose law refuses addi claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_false_of_refused_addition" lean_statement_sha256 = "7c57bc9d5691c1cb44f74f95653c02818b7a982cc8ed01c05d43aaed876b38a6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2095,7 +2095,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2112,7 +2112,7 @@ claim_text = "Lean proves the rich authority property: extensions le refuses a d claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_refuses_a_dropped_singleton" lean_statement_sha256 = "b0e6555b3ea818523fe6e8df539811645a6a7ee61e8a03c464b8852fb184829a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2174,7 +2174,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2194,7 +2194,7 @@ claim_text = "Lean proves per-identifier extension attenuation admits no world t claim_status = "proved" lean_declaration = "Auths.Rich.extensions_le_narrows" lean_statement_sha256 = "b84fc2cf70c513867276c1398608b399a6e3ca9f2c01905b3c339810dd1496d8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2256,7 +2256,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2273,7 +2273,7 @@ claim_text = "Lean proves the rich authority property: status refl." claim_status = "proved" lean_declaration = "Auths.Rich.status_refl" lean_statement_sha256 = "7d5310e68d00575620e99f894080ddc254f48770537a07e1a7e4acdae0090d63" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2335,7 +2335,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2352,7 +2352,7 @@ claim_text = "Lean proves the rich authority property: status trans." claim_status = "proved" lean_declaration = "Auths.Rich.status_trans" lean_statement_sha256 = "7e9d6580025807c2b2c984e8b167029b84ac610f9dcd280179e4c176872a04a1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2414,7 +2414,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2431,7 +2431,7 @@ claim_text = "Lean proves the rich authority property: status antisymm." claim_status = "proved" lean_declaration = "Auths.Rich.status_antisymm" lean_statement_sha256 = "a3badc32c1fcd22da760494c3c6eb256e637312f34fa7691591e7283f504867e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2493,7 +2493,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2513,7 +2513,7 @@ claim_text = "Lean proves the rich authority property: status satisfaction monot claim_status = "proved" lean_declaration = "Auths.Rich.status_satisfaction_monotone" lean_statement_sha256 = "7f5f3cfc2e90f4a2bdf90499b6b596a0711d27f3668d3d99bcf8c5a0a146e022" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2575,7 +2575,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2592,7 +2592,7 @@ claim_text = "Lean proves the rich authority property: profile refl." claim_status = "proved" lean_declaration = "Auths.Rich.profile_refl" lean_statement_sha256 = "c256b640094e0458a6cb336c78c358b8f35906d7838c86142f649c4d7c3cf9ea" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2654,7 +2654,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2674,7 +2674,7 @@ claim_text = "Lean proves the rich authority property: profile trans." claim_status = "proved" lean_declaration = "Auths.Rich.profile_trans" lean_statement_sha256 = "bc702fae63c302ea1b30323b66eaa633f2c489dd14a84bda0802852888da4e5d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2736,7 +2736,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2756,7 +2756,7 @@ claim_text = "Lean proves the rich authority property: profile antisymm." claim_status = "proved" lean_declaration = "Auths.Rich.profile_antisymm" lean_statement_sha256 = "306251093aa948294a625b5fd0e2707c52d9d391f172185ca36949ee0bd022ba" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2818,7 +2818,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2838,7 +2838,7 @@ claim_text = "Lean proves the rich authority property: profile coverage monotone claim_status = "proved" lean_declaration = "Auths.Rich.profile_coverage_monotone" lean_statement_sha256 = "fa6e1ec9008031df18e845bb6457030c5169bff159a30e5a30e4be9d7b445c16" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2900,7 +2900,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -2920,7 +2920,7 @@ claim_text = "Lean proves the rich authority property: structural scope le refl. claim_status = "proved" lean_declaration = "Auths.Rich.structural_scope_le_refl" lean_statement_sha256 = "d62dc8e9720475e1f9aef453def070f12382d75b5d1836e28810c50a123fe1b4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -2982,7 +2982,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3002,7 +3002,7 @@ claim_text = "Lean proves the rich authority property: structural scope le trans claim_status = "proved" lean_declaration = "Auths.Rich.structural_scope_le_trans" lean_statement_sha256 = "6cbce72d938dea6cd1a9f4814ba78cb52e8c5f4c7cddd2469a6526bb1662bb94" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3064,7 +3064,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3085,7 +3085,7 @@ claim_text = "Lean proves the rich authority property: scope le canonical antisy claim_status = "proved" lean_declaration = "Auths.Rich.scope_le_canonical_antisymmetry" lean_statement_sha256 = "197fe00cdc067ce9188485dd0e9b76f9561669b95ca225396561d8ce855f4542" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3147,7 +3147,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3168,7 +3168,7 @@ claim_text = "Lean proves the rich authority property: action coverage downward claim_status = "proved" lean_declaration = "Auths.Rich.action_coverage_downward_closed" lean_statement_sha256 = "f76fefd95f4dae279b6fcfbe014a5e8fdd7a9a7c1641f42c19045b7b16a9c486" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3230,7 +3230,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3251,7 +3251,7 @@ claim_text = "Lean proves the rich authority property: evidence requirements dow claim_status = "proved" lean_declaration = "Auths.Rich.evidence_requirements_downward_closed" lean_statement_sha256 = "3fca86b2826d0c6807da5e6d6c742bb51084ff7bd9914f1cc40003a0eaae08b4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3313,7 +3313,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3333,7 +3333,7 @@ claim_text = "Lean proves the rich authority property: complete admission downwa claim_status = "proved" lean_declaration = "Auths.Rich.complete_admission_downward_closed" lean_statement_sha256 = "4894f6f4a2eb7bef73ad797ae1601d7c07994e4d1bff74e873b8f1df4ba6657b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3395,7 +3395,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3416,7 +3416,7 @@ claim_text = "Lean proves the rich authority property: semantic attenuation preo claim_status = "proved" lean_declaration = "Auths.Rich.semantic_attenuation_preorder_refl" lean_statement_sha256 = "7ae1373433d76ff6136509d9662dab1b8e34867c4b4b067f1242499fb06ba0fd" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3478,7 +3478,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3498,7 +3498,7 @@ claim_text = "Lean proves the rich authority property: semantic attenuation preo claim_status = "proved" lean_declaration = "Auths.Rich.semantic_attenuation_preorder_trans" lean_statement_sha256 = "9b916eba63a367eacf049d8c8cb710908e7ca06d6e624f1b3d474bf6cb3fced9" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3560,7 +3560,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3580,7 +3580,7 @@ claim_text = "Lean proves the rich authority property: structural scope le impli claim_status = "proved" lean_declaration = "Auths.Rich.structural_scope_le_implies_semantic_attenuation" lean_statement_sha256 = "5218e5c6169c0fc0af43cb425d0a837930029032da4962d4168fd025f932d431" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3642,7 +3642,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3663,7 +3663,7 @@ claim_text = "Lean proves the rich authority property: scope semantic equivalenc claim_status = "proved" lean_declaration = "Auths.Rich.scope_semantic_equivalence" lean_statement_sha256 = "ab0d42af5b5cf85e211b3660953239b56f008cd416570dd57f51d3d0c60175d2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3725,7 +3725,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3745,7 +3745,7 @@ claim_text = "Lean proves the rich authority property: structural scope le decid claim_status = "proved" lean_declaration = "Auths.Rich.structural_scope_le_decides_declared_v1_relation" lean_statement_sha256 = "d21c9865f8d29bd1fef0778402eddb386af93dcea402725cc09a63a41c590529" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3807,7 +3807,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3828,7 +3828,7 @@ claim_text = "Lean proves the rich authority property: delegate implies scope le claim_status = "proved" lean_declaration = "Auths.Rich.delegate_implies_scope_le" lean_statement_sha256 = "492a39565c693001c3f03fbb40573d3d3c6f08ddacf36e7b5f996ab04df0109f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3890,7 +3890,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3910,7 +3910,7 @@ claim_text = "Lean proves the rich authority property: delegate preserves root." claim_status = "proved" lean_declaration = "Auths.Rich.delegate_preserves_root" lean_statement_sha256 = "6b5a9d3d8a41d6753cf6787bd5df8afeffa2c2679fa0217b2fdfa59d8a1f46b2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -3972,7 +3972,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -3992,7 +3992,7 @@ claim_text = "Lean proves the rich authority property: delegate updates subject claim_status = "proved" lean_declaration = "Auths.Rich.delegate_updates_subject_and_parent" lean_statement_sha256 = "73aea20a45df311686451843eb0a05632aee895859fd5b12a91d950b9f30b581" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4054,7 +4054,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4074,7 +4074,7 @@ claim_text = "Lean proves the rich authority property: anchored chain preserves claim_status = "proved" lean_declaration = "Auths.Rich.anchored_chain_preserves_provenance" lean_statement_sha256 = "854d2853a17bef32a429e1da533bb6ea9dec3428bf7a6649fc0dc5711331b9ee" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4136,7 +4136,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4156,7 +4156,7 @@ claim_text = "Lean proves the rich authority property: singleton context selects claim_status = "proved" lean_declaration = "Auths.Rich.singleton_context_selects_fresh_self_rooted_start" lean_statement_sha256 = "f110660181e70518b73b5360585a5eab8dad1d5ec2af11ac92b85c15569aabc8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4218,7 +4218,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4238,7 +4238,7 @@ claim_text = "Lean proves the rich authority property: chain descends from one r claim_status = "proved" lean_declaration = "Auths.Authority.chain_descends_from_one_root" lean_statement_sha256 = "854d2853a17bef32a429e1da533bb6ea9dec3428bf7a6649fc0dc5711331b9ee" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4300,7 +4300,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4320,7 +4320,7 @@ claim_text = "Lean proves the rich authority property: delegate strict depth." claim_status = "proved" lean_declaration = "Auths.Rich.delegate_strict_depth" lean_statement_sha256 = "996384a43e290522990e26bb761fc181d37e551f3b2c11190e7ef4a55cd5a930" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4382,7 +4382,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4402,7 +4402,7 @@ claim_text = "Lean proves the rich authority property: delegate never widens." claim_status = "proved" lean_declaration = "Auths.Rich.delegate_never_widens" lean_statement_sha256 = "492a39565c693001c3f03fbb40573d3d3c6f08ddacf36e7b5f996ab04df0109f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4464,7 +4464,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4484,7 +4484,7 @@ claim_text = "Lean proves the rich authority property: remaining depth well foun claim_status = "proved" lean_declaration = "Auths.Rich.remaining_depth_well_founded" lean_statement_sha256 = "dcf9ed58cbeb7f0b6d9c7fa332d1b3f696f0114cee5ab770d2ad31b27d8698eb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4546,7 +4546,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4566,7 +4566,7 @@ claim_text = "Lean proves the rich authority property: finite delegation chain." claim_status = "proved" lean_declaration = "Auths.Rich.finite_delegation_chain" lean_statement_sha256 = "c54457dda6f3f87e19a7224a424211e04f7da7706c7a6b950084ba630f0741f5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4628,7 +4628,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4648,7 +4648,7 @@ claim_text = "Lean proves the rich authority property: chain transitive attenuat claim_status = "proved" lean_declaration = "Auths.Rich.chain_transitive_attenuation" lean_statement_sha256 = "941e203039eef42df31f5c80208d2de0ac1345ff01f73b04ce139c9d57995c83" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4710,7 +4710,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4731,7 +4731,7 @@ claim_text = "Lean proves the rich authority property: authorized action covered claim_status = "proved" lean_declaration = "Auths.Rich.authorized_action_covered" lean_statement_sha256 = "7a3a3213af6f0aed9678912e472e816a9bbfb0f9b0040452f3fcde79d32152b0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4793,7 +4793,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4814,7 +4814,7 @@ claim_text = "Lean proves the rich authority property: extensions dimension is e claim_status = "proved" lean_declaration = "Auths.Rich.extensions_dimension_is_exact" lean_statement_sha256 = "ade313b34026661e080eb2b6ae656b39acb694efc597028eb0352fcc3c119bb8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4876,7 +4876,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4897,7 +4897,7 @@ claim_text = "Lean proves the generated extension dimension is false for a grant claim_status = "proved" lean_declaration = "Auths.Rich.extensions_dimension_false_of_stripped" lean_statement_sha256 = "978bd5383ecf2efee06ce1391d5355821d353f4e454cbe15d8a0bec2d925aea2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -4959,7 +4959,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -4980,7 +4980,7 @@ claim_text = "Lean proves the rich authority property: altered extensions deny e claim_status = "proved" lean_declaration = "Auths.Rich.altered_extensions_deny_every_projection" lean_statement_sha256 = "02f306f478ccb5919a689482ba1e101e9723e5d365d3f7bd4c71d303a37c5383" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5042,7 +5042,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5063,7 +5063,7 @@ claim_text = "Lean proves every accepted edge carries the grant's extension set, claim_status = "proved" lean_declaration = "Auths.Rich.delegate_attenuates_pinned_extensions" lean_statement_sha256 = "24acb38fc7066db51bd66b9e07dd5b6376010f969e2466acd191d080bbf01040" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5125,7 +5125,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5145,7 +5145,7 @@ claim_text = "Lean proves every state reachable along a delegation chain carries claim_status = "proved" lean_declaration = "Auths.Rich.chain_retains_pinned_extension_identifiers" lean_statement_sha256 = "cd2cd919349232f6b3b498154eae98ab6070edd0936d891646946968b3cc6ac4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5207,7 +5207,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5227,7 +5227,7 @@ claim_text = "Lean proves an accepted delegation never widens authority, includi claim_status = "proved" lean_declaration = "Auths.Rich.delegate_never_widens_authority" lean_statement_sha256 = "459fd80f79b0474a17b23f31d1ea894170a59be8af9ca849fa17b930850855f5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5289,7 +5289,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5310,7 +5310,7 @@ claim_text = "Lean proves no state reachable along a delegation chain admits an claim_status = "proved" lean_declaration = "Auths.Rich.chain_never_widens_authority" lean_statement_sha256 = "badba34df0ad02950772de9a16a08ed704b00d13161ca3adb9690156fa9528d9" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5372,7 +5372,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5393,7 +5393,7 @@ claim_text = "Lean proves the rich authority property: rich projection accepts i claim_status = "proved" lean_declaration = "Auths.Rich.rich_projection_accepts_iff_root_and_scope_depth_checks" lean_statement_sha256 = "8701007d8b4c42f2059cd7e02a841fe632ae4380470f3b2a396d0702e8371f46" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5455,7 +5455,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5476,7 +5476,7 @@ claim_text = "Lean proves the rich authority property: apply grant success iff l claim_status = "proved" lean_declaration = "Auths.Rich.apply_grant_success_iff_linked_and_projection" lean_statement_sha256 = "d1e837214c3e2d92a11750a81de8f7a132d3615cd87b3d826e3952408a44d1b5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5538,7 +5538,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5559,7 +5559,7 @@ claim_text = "Lean proves the rich authority property: apply grant success iff d claim_status = "proved" lean_declaration = "Auths.Rich.apply_grant_success_iff_delegates" lean_statement_sha256 = "60adbaa9a7b69216f9a63e2d01e0d46c696e2e5c06b47a6b4b4a0bdac13e6550" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5621,7 +5621,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5642,7 +5642,7 @@ claim_text = "Lean proves the rich authority property: apply grant success uniqu claim_status = "proved" lean_declaration = "Auths.Rich.apply_grant_success_unique" lean_statement_sha256 = "e5f71557dd61f8b0a5479564c6418fd399bf7ab28dc31f18d2fcb8acd3ee169d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5704,7 +5704,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5725,7 +5725,7 @@ claim_text = "Lean proves the rich authority property: authority delegate diagno claim_status = "proved" lean_declaration = "Auths.Rich.authority_delegate_diagnostic_sound_complete" lean_statement_sha256 = "1b03026088d20c617111ac18f843d1a98eff2a0d88aee42703c1f9bbfbfc6202" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5787,7 +5787,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5808,7 +5808,7 @@ claim_text = "Lean proves the rich authority property: authority delegate first claim_status = "proved" lean_declaration = "Auths.Rich.authority_delegate_first_failure" lean_statement_sha256 = "4520e0f85b7efe3d629a9e1beaf601ea16ba7d9728759bab9dfbd2f208ddffcf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5870,7 +5870,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5891,7 +5891,7 @@ claim_text = "Lean proves the rich authority property: author planning diagnosti claim_status = "proved" lean_declaration = "Auths.Rich.author_planning_diagnostic_sound_complete" lean_statement_sha256 = "b6e9eff61245c569032bf56f08d2e4024342839385feca01eec87393f6fb6e58" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -5953,7 +5953,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -5974,7 +5974,7 @@ claim_text = "Lean proves the rich authority property: coverage decision ok iff claim_status = "proved" lean_declaration = "Auths.Rich.coverage_decision_ok_iff_covers" lean_statement_sha256 = "bba6affe418888d125471704869356f8eda4861176df0aa5e75b72e873bb4a31" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6036,7 +6036,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6056,7 +6056,7 @@ claim_text = "Lean proves the rich authority property: rooted of origin." claim_status = "proved" lean_declaration = "Auths.Rich.rooted_of_origin" lean_statement_sha256 = "273f922682334f0d8d4d60194e8517e3c842a615da43e0ec829e231893fbed43" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6118,7 +6118,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6138,7 +6138,7 @@ claim_text = "Lean proves the rich authority property: reachable accepted." claim_status = "proved" lean_declaration = "Auths.Rich.reachable_accepted" lean_statement_sha256 = "9072a66c7332af7b2d27fea1b83fae0893fc14f9158106ce72fd5c7fb60cce48" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6200,7 +6200,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6220,7 +6220,7 @@ claim_text = "Lean proves the rich authority property: rooted of reachable." claim_status = "proved" lean_declaration = "Auths.Rich.rooted_of_reachable" lean_statement_sha256 = "ff692ede01812e450cc8984ab3fef696b0e1d71fb93086a53dd1117c27eefdd9" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6282,7 +6282,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6302,7 +6302,7 @@ claim_text = "Lean proves the rich authority property: registry coverage decisio claim_status = "proved" lean_declaration = "Auths.Rich.registry_coverage_decision_ok_iff_covers" lean_statement_sha256 = "75c5f00e47dfec8a229951c0220026fd984afd3ffce7b03b32f61bcc8a50672c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6364,7 +6364,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6384,7 +6384,7 @@ claim_text = "Lean proves the rich authority property: extensions not forgeable. claim_status = "proved" lean_declaration = "Auths.Rich.CertifiedProjection.extensions_not_forgeable" lean_statement_sha256 = "77fa3bfc160297a578bb99027f43b51d5f93820a10000030043dbcb37f577bcf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6446,7 +6446,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6467,7 +6467,7 @@ claim_text = "Lean proves the rich authority property: root not forgeable." claim_status = "proved" lean_declaration = "Auths.Rich.CertifiedProjection.root_not_forgeable" lean_statement_sha256 = "5e5412a76d954a30bb8e5581001dc229b77ddde589cfc4209756972e667e02a6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6529,7 +6529,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6550,7 +6550,7 @@ claim_text = "Lean proves the rich authority property: validity start direction. claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.validity_start_direction" lean_statement_sha256 = "b131c8323adfe2d1fdfb276e8b57d8ecbeeadc7ba76c42e142e9e60a1c7c8bd0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6612,7 +6612,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6633,7 +6633,7 @@ claim_text = "Lean proves the rich authority property: validity end direction." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.validity_end_direction" lean_statement_sha256 = "64a8422660d220c34ccf2286b3d2b656caee30d180efb50390b98109f012cb9b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6695,7 +6695,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6716,7 +6716,7 @@ claim_text = "Lean proves the rich authority property: permission subset directi claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.permission_subset_direction" lean_statement_sha256 = "460b9c2c8b40e2c47974aa6f40439a0921401af0a741e636dca7e8ce1e1128cb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6778,7 +6778,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6799,7 +6799,7 @@ claim_text = "Lean proves the rich authority property: audience subset direction claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.audience_subset_direction" lean_statement_sha256 = "1efdeced0d7cc63e210e3eed78bf72af7188d0b4b89988645067c065df38d4ca" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6861,7 +6861,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6882,7 +6882,7 @@ claim_text = "Lean proves the rich authority property: permission membership dec claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.permission_membership_decision" lean_statement_sha256 = "5562c113f4b1600e9fa2e351daefdf7ad676c95399913cfaf5366a4d02693859" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -6944,7 +6944,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -6964,7 +6964,7 @@ claim_text = "Lean proves the rich authority property: audience membership decis claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.audience_membership_decision" lean_statement_sha256 = "5562c113f4b1600e9fa2e351daefdf7ad676c95399913cfaf5366a4d02693859" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7026,7 +7026,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7046,7 +7046,7 @@ claim_text = "Lean proves the rich authority property: body digest membership de claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.body_digest_membership_decision" lean_statement_sha256 = "40e8f579841509c93f52d9b1e8ceeb0068d9deee142398402b148d5dcab74f52" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7108,7 +7108,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7128,7 +7128,7 @@ claim_text = "Lean proves the rich authority property: body digest subset direct claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.body_digest_subset_direction" lean_statement_sha256 = "6f6d71aafc31d6e2f5f5d6b41450fab50ccbcc47ea24ff1a4d10a06f547e7a3b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7190,7 +7190,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7211,7 +7211,7 @@ claim_text = "Lean proves the rich authority property: action exact equality." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.action_exact_equality" lean_statement_sha256 = "12d3ee8161fd73a2b9a4c289c074a70dbe838e01889bae915eb1a28a5e0b5cbf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7273,7 +7273,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7293,7 +7293,7 @@ claim_text = "Lean proves the rich authority property: action constructor fallba claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.action_constructor_fallback" lean_statement_sha256 = "52a8700eb9047be465715d24eb7cce83a544f68beb675fc0ca746b20adcef29d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7355,7 +7355,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7376,7 +7376,7 @@ claim_text = "Lean proves the rich authority property: action singleton exact re claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.action_singleton_exact_rejection" lean_statement_sha256 = "f748a54bcd87a1105b376fd789d539dcba915c55b382c4d84d0764697544e403" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7438,7 +7438,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7459,7 +7459,7 @@ claim_text = "Lean proves the rich authority property: budget value direction." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.budget_value_direction" lean_statement_sha256 = "e5c3c785f61156754ca58b613f917897b7204e66cf2904be240c6ae56dc234d5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7521,7 +7521,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7542,7 +7542,7 @@ claim_text = "Lean proves the rich authority property: budget algebra equality." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.budget_algebra_equality" lean_statement_sha256 = "856f719d1d4fe6a2b19dab9c3bcfd40873e74a55abaf10f945308fbb05b95652" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7604,7 +7604,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7625,7 +7625,7 @@ claim_text = "Lean proves the rich authority property: optional budget bounded p claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.optional_budget_bounded_parent" lean_statement_sha256 = "35b7c28a001e2386a652f5e174baa301a265a3eadd74a8c68c3b43d6d0cde025" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7687,7 +7687,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7708,7 +7708,7 @@ claim_text = "Lean proves the rich authority property: optional budget no reques claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.optional_budget_no_request" lean_statement_sha256 = "b661893af19ee64775f156871b07d71fd53478d22876735146530e3d0d624299" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7770,7 +7770,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7790,7 +7790,7 @@ claim_text = "Lean proves the rich authority property: delegation depth strictne claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.delegation_depth_strictness" lean_statement_sha256 = "7c203a21398399f9e247a106c21958e147051c105775efb5696c6103d3fcef53" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7852,7 +7852,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7873,7 +7873,7 @@ claim_text = "Lean proves the rich authority property: status age direction." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.status_age_direction" lean_statement_sha256 = "bcd2dc8a61a687aa05525983f0a82d8eb2c30f82bd8714e98f4538219ffa4018" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -7935,7 +7935,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -7956,7 +7956,7 @@ claim_text = "Lean proves the rich authority property: status method equality." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.status_method_equality" lean_statement_sha256 = "65eb51069ff53dc4a198806e1fd34df0d06c718b805fe98af2c9ce6b81818c8f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8018,7 +8018,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8039,7 +8039,7 @@ claim_text = "Lean proves the rich authority property: assurance equality." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.assurance_equality" lean_statement_sha256 = "682a5d15cb1ed38aafddcb2a5e0e987609428320b263e5bbae4cbea456d9d8ca" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8101,7 +8101,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8122,7 +8122,7 @@ claim_text = "Lean kills the mutation that accepts a child critical extension wi claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.critical_extension_law" lean_statement_sha256 = "23f565b7d27ba7241114c8362d3604ec74ed08a4e05b82d5a97dce2500c87970" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8184,7 +8184,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8205,7 +8205,7 @@ claim_text = "Lean proves the rich authority property: critical extensions rever claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.critical_extensions_reversed_not_sorted" lean_statement_sha256 = "1ac76c3db510279b30c76d84b5538b47ad6c5f46fd2e3ae71a45976fea3131dc" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8267,7 +8267,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8284,7 +8284,7 @@ claim_text = "Lean proves the rich authority property: profile version equality. claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.profile_version_equality" lean_statement_sha256 = "d061c3229df6d475f2f0dfc7a492dc1dce9c34555a20bd03b530e579a1b34d72" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8346,7 +8346,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8367,7 +8367,7 @@ claim_text = "Lean proves the rich authority property: principal linkage equalit claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.principal_linkage_equality" lean_statement_sha256 = "399766c14541a0cf9533a13cbb97e40432b86f182ea9b99bfc835aa86556998d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8429,7 +8429,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8450,7 +8450,7 @@ claim_text = "Lean proves the rich authority property: grant linkage equality." claim_status = "proved" lean_declaration = "Auths.Rich.Mutations.grant_linkage_equality" lean_statement_sha256 = "78a60f2b43f1db4ae1ea88249aa8edab996999d314cc0d09a55151ae5170fb0c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8512,7 +8512,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8533,7 +8533,7 @@ claim_text = "Lean proves the rich authority property: coverage diagnostic sound claim_status = "proved" lean_declaration = "Auths.Rich.coverage_diagnostic_sound_complete" lean_statement_sha256 = "77658775391d0d2d6b38529f58c690b9aa08a5146284dbb022765523106519e5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -8595,7 +8595,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -8615,7 +8615,7 @@ claim_text = "The mechanically translated production author-scope evaluator retu claim_status = "qualified" lean_declaration = "Auths.Refinement.translated_rust_refines_rich_spec" lean_statement_sha256 = "195ddcaa796803794574579d593c5a78f7fbd9611d32492de2a095e044fe2ca8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_authority::evaluate_author_scope_view", "auths_model::profile_ref_equal", @@ -8696,7 +8696,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The exact translated pre-signing scope evaluator over validated bounded views, including all ten scope/depth dimensions and ordered diagnostics, for every set of critical-extension laws." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises are trusted.", @@ -8733,7 +8733,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-055" @@ -8741,7 +8741,7 @@ claim_text = "The mechanically translated terminal-coverage evaluator returns ex claim_status = "qualified" lean_declaration = "Auths.Refinement.translated_coverage_refines_rich_spec" lean_statement_sha256 = "e8deba0035a09886221c46411be908f1ac8c30e0e3755ca956a62884a416a0fa" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_authority::evaluate_action_coverage_view", "auths_authority::root_linkage", @@ -8818,7 +8818,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The crate-private raw translated evaluator over validated authority/action views. The public EffectiveAuthority::authorizes boundary resolves budget expressibility from AcceptedRegistries and the exact action profile before calling it." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises are trusted.", @@ -8854,7 +8854,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-056" @@ -8862,7 +8862,7 @@ claim_text = "The mechanically translated delegation evaluator returns exactly t claim_status = "qualified" lean_declaration = "Auths.Refinement.translated_delegation_refines_rich_spec" lean_statement_sha256 = "45782f85b6ded4714d9ca4e4b6a8ee2dc0e70c99395691101d834087a89c2fe1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_authority::evaluate_grant_view", "auths_authority::root_linkage", @@ -8952,7 +8952,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The crate-private raw evaluator over validated parent/grant views, including root linkage, strict depth, every attenuation dimension, and the unique accepted transition, for every set of critical-extension laws." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises are trusted.", @@ -8989,7 +8989,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-104" @@ -8997,7 +8997,7 @@ claim_text = "The regenerated Aeneas translation of optional_budget_covers answe claim_status = "proved" lean_declaration = "Auths.Refinement.translated_bounded_ceiling_denies_absent_request" lean_statement_sha256 = "9c4ea11fa46f39a993ab4038263180284eca394df782a70259346c8167d7e4fc" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9059,7 +9059,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9080,7 +9080,7 @@ claim_text = "Lean proves the rich authority property: translated expressible ab claim_status = "proved" lean_declaration = "Auths.Refinement.translated_expressible_absent_request_is_denied" lean_statement_sha256 = "90aa025faf3b73862f51432d5b07d0ef69c1bd67826d739083b6e42d65f00e4a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9142,7 +9142,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9163,7 +9163,7 @@ claim_text = "Lean proves the rich authority property: translated inexpressible claim_status = "proved" lean_declaration = "Auths.Refinement.translated_inexpressible_absent_request_is_covered" lean_statement_sha256 = "294ac2be47b25a2f72d528f66b974cb3acc2dfd8a330a8c6696b8dad12fb8d97" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9225,7 +9225,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9246,7 +9246,7 @@ claim_text = "Lean proves the rich authority property: translated absent ceiling claim_status = "proved" lean_declaration = "Auths.Refinement.translated_absent_ceiling_covers_anything" lean_statement_sha256 = "90df3548fb3d56bed30812c94acb18b2d6b0028f77aff11cd44aade8e2889961" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9308,7 +9308,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9329,7 +9329,7 @@ claim_text = "Lean proves the bounded product-policy property: configuration mat claim_status = "proved" lean_declaration = "Auths.Product.configuration_match_refl" lean_statement_sha256 = "1d3b3a5ed6156f4e5616d877b35e9942f824f876e6db3aa3cd39729305a8ed4e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9391,7 +9391,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9408,7 +9408,7 @@ claim_text = "Lean proves the bounded product-policy property: configuration mat claim_status = "proved" lean_declaration = "Auths.Product.configuration_match_deterministic" lean_statement_sha256 = "0b97aea7619fab2ffebd442c8d6376a02779d0e4c9673837e48f45c99488c8e0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9470,7 +9470,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9487,7 +9487,7 @@ claim_text = "Lean proves the bounded product-policy property: checked add never claim_status = "proved" lean_declaration = "Auths.Product.checked_add_never_wraps" lean_statement_sha256 = "f2e86c112c2021bab2444682e85973ad5b3f3de473bf5e093a47c65ebd74cf06" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9549,7 +9549,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9566,7 +9566,7 @@ claim_text = "Lean proves the bounded product-policy property: checked sub never claim_status = "proved" lean_declaration = "Auths.Product.checked_sub_never_underflows" lean_statement_sha256 = "fc97e83a1f988edafe17d5d775cafb333138ff36e1ee3ac65609f48844129fa5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9628,7 +9628,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9645,7 +9645,7 @@ claim_text = "Lean proves the bounded product-policy property: checked div rejec claim_status = "proved" lean_declaration = "Auths.Product.checked_div_rejects_zero" lean_statement_sha256 = "004c9c8a21f3a6416181d4d561ae3dd38aebca10d640f288eb8af0e4bba34ba4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9707,7 +9707,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9724,7 +9724,7 @@ claim_text = "Lean proves the bounded product-policy property: three way partiti claim_status = "proved" lean_declaration = "Auths.Product.three_way_partition" lean_statement_sha256 = "fa4bfacdd689bfe94265f7c2627598a8d758ae6ac3667bc6270f581219151e3e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9786,7 +9786,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9803,7 +9803,7 @@ claim_text = "Lean proves the bounded product-policy property: product contract claim_status = "proved" lean_declaration = "Auths.Product.product_contract_configuration_safety" lean_statement_sha256 = "18957d267951e86ccae5c49b3b704e2e45d87c427d023f4e0a3684b895e461d5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9865,7 +9865,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9882,7 +9882,7 @@ claim_text = "Lean proves the bounded product-policy property: product contract claim_status = "proved" lean_declaration = "Auths.Product.product_contract_output_completeness" lean_statement_sha256 = "b4fa5d97dd43b72133cc583f8834921ed1c968fde6ac3eb4f7c4b5ecc49f1c08" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -9944,7 +9944,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -9964,7 +9964,7 @@ claim_text = "Lean proves the bounded product-policy property: translated config claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_configuration_refines_projection" lean_statement_sha256 = "a988d91b2f65fea6451fdbe5ebc0b75ea7324b27c0b4031b1b49144eb15ef297" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10026,7 +10026,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10043,7 +10043,7 @@ claim_text = "Lean proves the bounded product-policy property: translated checke claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_checked_add_refines_nat" lean_statement_sha256 = "eed21c6bdc5e0ba56c0c8dd9249ee1d51053fa42b8df3958a762399ba0bf7ab5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10105,7 +10105,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10126,7 +10126,7 @@ claim_text = "Lean proves the bounded product-policy property: translated checke claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_checked_sub_refines_nat" lean_statement_sha256 = "fed19d1701dac7a6f928957a78799fcf63eaf80d24ea0cbed66d77e490ed879c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10188,7 +10188,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10209,7 +10209,7 @@ claim_text = "Lean proves the bounded product-policy property: translated checke claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_checked_mul_refines_nat" lean_statement_sha256 = "f2e5d31dcc8e7f7651c0223bfdabccadc850be49cb8431aebf966aee9f7acc35" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10271,7 +10271,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10292,7 +10292,7 @@ claim_text = "Lean proves the bounded product-policy property: translated checke claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_checked_div_rejects_zero" lean_statement_sha256 = "cb30a894abfc0b326ba704c9d0979adb434cb7fc94f0134e14442c313e8670fb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10354,7 +10354,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 bounded product-policy commitments, checked arithmetic, configuration gating, and eligibility." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10375,7 +10375,7 @@ claim_text = "The mechanically translated window index returns exactly the natur claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.translated_window_index_refines_nat" lean_statement_sha256 = "2d4076b355c9fd4faad8b9663b8a68e1c49f619da2cf11c74e9bdb30f7d480da" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_bounded_policy::kernel::window_index"] semantic_source_closure = [ "formal/Auths.lean", @@ -10437,7 +10437,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of u64 time and window length." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -10463,7 +10463,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-263" @@ -10471,7 +10471,7 @@ claim_text = "The mechanically translated digest comparison returns exactly the claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.BoundedPolicy.translated_digest_equal_refines_model" lean_statement_sha256 = "d8411964df44b9e93b4d097961e55e60bef00a8ef71c89d7b3bec08963599b85" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::bounded_policy::digest_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -10533,7 +10533,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of 32-byte digests." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -10559,7 +10559,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-264" @@ -10567,7 +10567,7 @@ claim_text = "The mechanically translated parent-link check returns exactly the claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.BoundedPolicy.translated_bounded_policy_link_accepts_refines_model" lean_statement_sha256 = "7c7c5aec926901e72f22a2b9c4b1c6c4bb833c010440f657fcb79d7e827144d7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::bounded_policy::bounded_policy_link_accepts", "auths_model::bounded_policy::digest_equal", @@ -10632,7 +10632,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every optional child link and optional parent digest." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -10658,7 +10658,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-186" @@ -10666,7 +10666,7 @@ claim_text = "Lean proves the translated argument-ceiling evaluation leaf comput claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_ceiling_count_refines_model" lean_statement_sha256 = "ada2be3af3def88e58de1ff9aef4485651996241a5c2a0f8ce0dd50d27728b1e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10728,7 +10728,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The Aeneas-translated argument-ceiling window-count leaves of auths-bounded-policy, under the pinned translation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10748,7 +10748,7 @@ claim_text = "Lean proves the translated argument-ceiling tightening leaf comput claim_status = "proved" lean_declaration = "Auths.Product.Refinement.translated_ceiling_count_tightens_refines_model" lean_statement_sha256 = "9477f8ea177a765c5ac61d23ce7032ca8156309063f5963bad218c829d08981c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -10810,7 +10810,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The Aeneas-translated argument-ceiling window-count leaves of auths-bounded-policy, under the pinned translation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -10830,7 +10830,7 @@ claim_text = "The mechanically translated count leaf returns exactly the model's claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.translated_chain_counts_admit_refines_model" lean_statement_sha256 = "f71baa54d41b494f3c2a69f250c2183339389bbe1d5d94fd64d8b5ed9afb7d67" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_bounded_policy::kernel::chain_counts_admit"] semantic_source_closure = [ "formal/Auths.lean", @@ -10892,7 +10892,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of u64 slices of counter values and capacities, including slices of different lengths." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -10918,7 +10918,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-237" @@ -10926,7 +10926,7 @@ claim_text = "The mechanically translated sum leaf returns exactly the model's s claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.translated_chain_sums_admit_refines_model" lean_statement_sha256 = "c75fcec112558e4eca8125e5996cd4dea6d1e2a76cd45bf1b1accbf1c0dfc5ee" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_bounded_policy::kernel::chain_sums_admit"] semantic_source_closure = [ "formal/Auths.lean", @@ -10988,7 +10988,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 argument and pair of u64 slices of running sums and capacities, including slices of different lengths." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -11014,7 +11014,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-238" @@ -11022,7 +11022,7 @@ claim_text = "The mechanically translated tightening decider of policy /2 return claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.translated_argument_policy_tightens_refines_model" lean_statement_sha256 = "f20279e5c8f3b5e9d3f9e56408c91d6f0151b2106434969f9890a5ef5389c337" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_bounded_policy::kernel::argument_policy_tightens", "auths_bounded_policy::kernel::ceiling_count_tightens", @@ -11087,7 +11087,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of policy members: argument names, ceilings, windows, counts, optional sums with optional partitions, and optional scopes with value lists of any length." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -11113,7 +11113,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-175" @@ -11121,7 +11121,7 @@ claim_text = "Lean proves the argument-ceiling evaluation is eligible exactly wh claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.code_eligible_iff" lean_statement_sha256 = "ca2f3dfef380a22f6280465f8320e1aca773e3ca0290cc38f7babe12f6642e63" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11183,7 +11183,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11200,7 +11200,7 @@ claim_text = "Lean proves the argument-ceiling tightening decider of policy /2 d claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.decider_iff_tightens" lean_statement_sha256 = "ae8a39a1e41e905d9464cc4dad8638cf1047017ff0ad58d77cceba6498a1a2a3" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11262,7 +11262,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11282,7 +11282,7 @@ claim_text = "Lean proves a tighter argument-ceiling policy never admits a conte claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.tightening_never_admits_more" lean_statement_sha256 = "fbdda26118f2596fdad003444f236e79a1bf12754a1a6beb0d61e30dd66e6287" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11344,7 +11344,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11365,7 +11365,7 @@ claim_text = "Lean proves the argument-ceiling tightening decider is sound: a ch claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.decider_sound" lean_statement_sha256 = "9be80ea95233697c96ff6a9b5dce9aca5f84988261dcb57119c5e7bf0b7af0e8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11427,7 +11427,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11448,7 +11448,7 @@ claim_text = "Lean proves a smaller argument ceiling never authorizes more." claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.smaller_ceiling_never_authorizes_more" lean_statement_sha256 = "9e56daaf4f09d2a01150daf784d6584c590f59545639139ae91bfa6be4025690" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11510,7 +11510,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11531,7 +11531,7 @@ claim_text = "Lean proves a smaller count per fixed window never authorizes more claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.smaller_count_never_authorizes_more" lean_statement_sha256 = "ddcd9f8d9141338018e9fb5a68fca37b7e157619f0ca917c0550cef5c8a828a6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11593,7 +11593,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11614,7 +11614,7 @@ claim_text = "Lean proves argument-ceiling tightening is reflexive." claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.tightens_refl" lean_statement_sha256 = "3c2b30687d72f28f07c13e1069f9e8f49ad2ca604c8d0b9561ad86e64090dec6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11676,7 +11676,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11696,7 +11696,7 @@ claim_text = "Lean proves argument-ceiling tightening is transitive." claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.tightens_trans" lean_statement_sha256 = "27bddfea8d4eaa275419f7461e14c30f42db2e6aa67ed049e2baafe0c113b7fd" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11758,7 +11758,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -11775,7 +11775,7 @@ claim_text = "Lean proves the bounded-policy extension law the gateway enforces claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.bounded_policy_law_lawful" lean_statement_sha256 = "b5311babd266c58b0a167f530675436fd804cf4ba0af4a66d33f6b8ba37fa749" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11837,7 +11837,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Product-layer premise of the bounded-policy-commitment-v1 extension. The kernel checks only that a delegated commitment links the digest of its parent's extension bytes; narrowing is discharged here by the registered evaluator's tightening decider, which the gateway runs on every linked pair before eligibility. This is not a kernel theorem." residual_assumptions = [ "Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted.", @@ -11861,7 +11861,7 @@ claim_text = "Lean proves the bounded-policy extension law accepts adding a boun claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.bounded_policy_law_accepts_addition" lean_statement_sha256 = "1025dc58f2d798f02e8a8a643c4c3a76c544e76302970c2d7ce99ed6274cf89b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -11923,7 +11923,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Product-layer premise of the bounded-policy-commitment-v1 extension. The kernel checks only that a delegated commitment links the digest of its parent's extension bytes; narrowing is discharged here by the registered evaluator's tightening decider, which the gateway runs on every linked pair before eligibility. This is not a kernel theorem." residual_assumptions = [ "Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted.", @@ -11946,7 +11946,7 @@ claim_text = "Lean proves the argument-ceiling evaluator satisfies the shared fi claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.ceiling_count_fixed_context_tightening" lean_statement_sha256 = "30accc61db6512783cf3b568eefa9d09579eccc72e3ce2d0ca196d3e27efbd40" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12008,7 +12008,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's registered argument-ceiling window-count evaluator /2: fixed-context evaluation over verified unsigned and text arguments and the counters of one fixed, epoch-aligned window, semantic tightening with the sum, partition, and scope rules, and the registered tightening decider." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12029,7 +12029,7 @@ claim_text = "Lean proves reserving a chain's counters is all or none: either no claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.reserve_all_or_none" lean_statement_sha256 = "6ab5bb8963257698a595bbad3d04e33cf7a4284948372b3c1217489fd81cb0ef" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12091,7 +12091,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12111,7 +12111,7 @@ claim_text = "Lean proves that, for every arrival order in one fixed window, a l claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.aggregate_count_bound" lean_statement_sha256 = "0f5accd437257509195f6034a9d50f0713a21aeab2c655b0fecb95527124eb8d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12173,7 +12173,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12193,7 +12193,7 @@ claim_text = "Lean proves that, for every arrival order in one fixed window, the claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.aggregate_spend_bound" lean_statement_sha256 = "8bc18ab4c3404924341910f3b156124dad2a029e37e2fdef41b52a5117a13340" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12255,7 +12255,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12275,7 +12275,7 @@ claim_text = "Lean proves that, for every arrival order in one fixed window, a l claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.aggregate_sum_bound" lean_statement_sha256 = "37700c8ea564cd8346ffd48a8f33774fae3436abd135c0584bc7704afe7ff07f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12337,7 +12337,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12357,7 +12357,7 @@ claim_text = "Lean proves delegation never multiplies a count: in one fixed wind claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.delegation_never_multiplies" lean_statement_sha256 = "f09ba1275f7a50f260a64fc78ed3663ea70f459ba704b3acb4598f685fdd9184" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12419,7 +12419,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12439,7 +12439,7 @@ claim_text = "Lean proves delegation never multiplies a sum: in one fixed window claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.sum_delegation_never_multiplies" lean_statement_sha256 = "289fea63130a02da951fd05c805bb6df285781948437b27519116a3e1b2defaf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12501,7 +12501,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12521,7 +12521,7 @@ claim_text = "Lean proves an admitted chain's scope and partition values are in claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.scope_admits_only_listed" lean_statement_sha256 = "cad1fcf6fbaf3064577c894a1a8ea868c3e4085020bb580625abbb168f84a49f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12583,7 +12583,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12603,7 +12603,7 @@ claim_text = "Lean proves the count leaf's model, over a chain's distinct count claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.chain_counts_part" lean_statement_sha256 = "e93ff36670cc1ff2df9e0af15ff3bef912520b07c55b67ade09e6b84ce314f2a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12665,7 +12665,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12686,7 +12686,7 @@ claim_text = "Lean proves the sum leaf's model, over a chain's distinct sum coun claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.chain_sums_part" lean_statement_sha256 = "f10a2dd1bc798c06920ade27ff1bfeba59a7fbfa6653d81664b258ad231ed7f2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12748,7 +12748,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12769,7 +12769,7 @@ claim_text = "Lean proves chain admission is exactly the per-link argument, ceil claim_status = "proved" lean_declaration = "Auths.Product.CeilingCount.chain_admits_parts" lean_statement_sha256 = "3b815dca82bdd32ac7a47c9a5b5c29a70942dffb774dbe00ed4940ff34eeb880" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12831,7 +12831,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The gateway's chain admission and reservation over the counters of one fixed, epoch-aligned window: each bounded grant of the authorized branch is a link whose count and sum counters are keyed by its subject, so every admitted action of the subject and of each delegate charges them. Store atomicity and the unauthenticated gateway clock are residual assumptions." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12851,7 +12851,7 @@ claim_text = "Lean proves the gateway recipe property: capability total determin claim_status = "proved" lean_declaration = "Auths.Product.Recovery.capability_total_deterministic" lean_statement_sha256 = "6f4fc1fec3bdae5a436cbf7894e76aa835bec591fc37b7dbf002aca033c13667" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12913,7 +12913,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -12922,7 +12922,7 @@ axioms = [] [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-203" @@ -12930,7 +12930,7 @@ claim_text = "Lean proves the gateway recipe property: class matches declaration claim_status = "proved" lean_declaration = "Auths.Product.Recovery.class_matches_declarations" lean_statement_sha256 = "117884bcb89669e3376db0b00e75a96265c1bfdb3392000fde1430b59ea3a078" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -12992,7 +12992,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13001,7 +13001,7 @@ axioms = ["propext"] [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-204" @@ -13009,7 +13009,7 @@ claim_text = "Lean proves the gateway recipe property: write never conditional." claim_status = "proved" lean_declaration = "Auths.Product.Recovery.write_never_conditional" lean_statement_sha256 = "a29b4d1636de3467039d88777f399f89ed9748f66ca901ced1ebe540275f3832" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13071,7 +13071,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13080,15 +13080,15 @@ axioms = [] [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-215" -claim_text = "Lean proves the gateway recipe property: unknown resolves only linked." +claim_text = "Lean proves that an unknown reaching provider observation retains a verified-locator link and records provider evidence; late source responses and recipient acknowledgements are distinct routes." claim_status = "proved" lean_declaration = "Auths.Product.Recovery.unknown_resolves_only_linked" -lean_statement_sha256 = "375c42a9e70d6c1717fd9e451f43612cae8141cfff4f9cdd00c28f38970b6383" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "1a756a3cb1a5eb1f238e64bf9724e78fc92671f995385e2a9f8e1dbd4a6bf6a6" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13150,7 +13150,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13162,15 +13162,331 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" + +[[claims]] +claim_id = "AP-FORMAL-RICH-313" +claim_text = "Lean proves the gateway recipe property: unknown exits with bound evidence." +claim_status = "proved" +lean_declaration = "Auths.Product.Recovery.unknown_exits_with_bound_evidence" +lean_statement_sha256 = "0da149d7ad7a06229ef88d294abdccd8a8b4e80df4356246b05ada0b733afc78" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/Recovery.lean" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" + +[[claims]] +claim_id = "AP-FORMAL-RICH-314" +claim_text = "Lean proves the gateway recipe property: transition ownership." +claim_status = "proved" +lean_declaration = "Auths.Product.Recovery.transition_ownership" +lean_statement_sha256 = "504422bb822a66679164c3ddc04582e541e483297ea461e19f919fd04cde85e9" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/Recovery.lean" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" + +[[claims]] +claim_id = "AP-FORMAL-RICH-315" +claim_text = "Lean proves the gateway recipe property: late response retains source." +claim_status = "proved" +lean_declaration = "Auths.Product.Recovery.late_response_retains_source" +lean_statement_sha256 = "ceebf2b4398ba515895efd291b628ae9aeda3c65342bb40129ffc79b025a06ce" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/Recovery.lean" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" + +[[claims]] +claim_id = "AP-FORMAL-RICH-316" +claim_text = "Lean proves the gateway recipe property: late acknowledgement retains source." +claim_status = "proved" +lean_declaration = "Auths.Product.Recovery.late_acknowledgement_retains_source" +lean_statement_sha256 = "d5c65641ea4deca74f99e636eb849180b5ade14f3212c5f04b67180f97eb1cb2" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/Recovery.lean" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-216" claim_text = "Lean proves the gateway recipe property: provider claim requires evidence." claim_status = "proved" lean_declaration = "Auths.Product.Recovery.provider_claim_requires_evidence" -lean_statement_sha256 = "def91039f3a07a5683a962f3ee33d303addaae9a5689dda0f604fcd20b6167d0" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "7b62af78f9946db240bf59c1e04cd40c271023404a326a7478d20c3be87f33c4" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13232,7 +13548,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13245,15 +13561,15 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-217" claim_text = "Lean proves the gateway recipe property: terminal stages final." claim_status = "proved" lean_declaration = "Auths.Product.Recovery.terminal_stages_final" -lean_statement_sha256 = "9d46111d329a79a4788b23cc5a64f81e8853791104d67e3fd1992bf904f80684" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "65dc627394212edcac36e0f8391e85611724b9ba1c114b29c9dac2954c10daa8" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13315,7 +13631,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13327,7 +13643,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-218" @@ -13335,7 +13651,7 @@ claim_text = "Lean proves the gateway recipe property: transitions preserve iden claim_status = "proved" lean_declaration = "Auths.Product.Recovery.transitions_preserve_identity" lean_statement_sha256 = "ecbc5c29d6d4e0eeeb25fe5f4b2267aa8fc7b10bf316d501eac0e2f32af18bd1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13397,7 +13713,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13410,15 +13726,15 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/Recovery.lean" -sha256 = "54b0c7fa26dfa03b5a9659875100a4b5bc845dfe010f73d0ac96bc981c208b70" +sha256 = "04c16abce67bebe1cb1a395a1a025a5c5cc9f84f6e2e34327bae0af88cb48d5c" [[claims]] claim_id = "AP-FORMAL-RICH-219" claim_text = "Lean proves the gateway recipe property: lease requires verified claim." claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.lease_requires_verified_claim" -lean_statement_sha256 = "c909a8624ee83d30cce1508a08b66b2f2844cffe645297855e5b6eb63f537092" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "ff698cb0bfd03fc9e57c0efe4ce166518ffb9d6750434de0ceeb957dd9a2341b" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13480,7 +13796,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13492,15 +13808,15 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-220" -claim_text = "Lean proves the gateway recipe property: send requires lease and deadline." +claim_text = "Lean proves that sending requires a successful durable entry grant after native verification, reservation, credential lease, declared pre-entry checks, connection reload, and deadline validation." claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.send_requires_lease_and_deadline" -lean_statement_sha256 = "b7308523e47d7da1dd32e3799a7794b90d040b26648e64f8200af2bbbc3b93f3" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "726a3d5cb31a8fc6a47c978ceb36144dacad3dfc363ff931fd306cfc8cf5ba01" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13562,7 +13878,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13574,15 +13890,15 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-221" claim_text = "Lean proves the gateway recipe property: send requires credential checks." claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.send_requires_credential_checks" -lean_statement_sha256 = "dee08ab850d6d85d371a7e39dce3e204411a2e20d9619258d27bf67b313e5039" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "f704e163d11883021606a89f21440d172e6d0e06b87e91b9c4f0214dd7496bdf" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13644,7 +13960,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13656,7 +13972,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-222" @@ -13664,7 +13980,7 @@ claim_text = "Lean proves the gateway recipe property: send requires relative ce claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.send_requires_relative_ceiling" lean_statement_sha256 = "bb8d3c138ad18d9b9963c22bf746dbf1de793b9a6f64a37658db9b8854d22986" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13726,7 +14042,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13738,7 +14054,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-223" @@ -13746,7 +14062,7 @@ claim_text = "Lean proves the gateway recipe property: account scope requires bi claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.account_scope_requires_binding" lean_statement_sha256 = "246b93cf15db6b83675a162d97172251edb9bef8f6d9131fd4cecc7884ce6914" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13808,7 +14124,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13820,7 +14136,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-224" @@ -13828,7 +14144,7 @@ claim_text = "Lean proves the gateway recipe property: at most one send." claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.at_most_one_send" lean_statement_sha256 = "19162c884a8ed60f9a15dfbb26e95aa35015ede017313498984ffada67a3ff50" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13890,7 +14206,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13902,7 +14218,244 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" + +[[claims]] +claim_id = "AP-FORMAL-RICH-317" +claim_text = "Lean proves the gateway recipe property: response stops without read." +claim_status = "proved" +lean_declaration = "Auths.Product.SubmitOrder.response_stops_without_read" +lean_statement_sha256 = "b41dcd2e88d39fdb460f461f623c58be530fd77e3ec7cc28a55dbf4c6e07b032" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/SubmitOrder.lean" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" + +[[claims]] +claim_id = "AP-FORMAL-RICH-318" +claim_text = "Lean proves the gateway recipe property: replay returns stored." +claim_status = "proved" +lean_declaration = "Auths.Product.SubmitOrder.replay_returns_stored" +lean_statement_sha256 = "7bcd77b4b74a511e910a7f93a59fa82bdb64b0bef69bcab062fd7c797eeaed13" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/SubmitOrder.lean" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" + +[[claims]] +claim_id = "AP-FORMAL-RICH-319" +claim_text = "Lean proves the gateway recipe property: refused grant stops without send." +claim_status = "proved" +lean_declaration = "Auths.Product.SubmitOrder.refused_grant_stops_without_send" +lean_statement_sha256 = "4c8415d14c2229561309e9c1e978adfb395285233fd507d0eed3f7ed8a76754c" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" +rust_symbols = [] +semantic_source_closure = [ + "formal/Auths.lean", + "formal/Auths/Approval.lean", + "formal/Auths/AssuranceAudit.lean", + "formal/Auths/Attenuation.lean", + "formal/Auths/Authority.lean", + "formal/Auths/Base.lean", + "formal/Auths/Composition.lean", + "formal/Auths/Diversity.lean", + "formal/Auths/ExtensionLaw.lean", + "formal/Auths/Generated/Algebra.lean", + "formal/Auths/Lifecycle/Refinement.lean", + "formal/Auths/Lifecycle/Semantics.lean", + "formal/Auths/Lifecycle/Theorems.lean", + "formal/Auths/Observation.lean", + "formal/Auths/Product/Arithmetic.lean", + "formal/Auths/Product/CeilingCount.lean", + "formal/Auths/Product/Commitment.lean", + "formal/Auths/Product/ConnectionGenerations.lean", + "formal/Auths/Product/Eligibility.lean", + "formal/Auths/Product/Recovery.lean", + "formal/Auths/Product/Refinement.lean", + "formal/Auths/Product/Refinement/BoundedPolicy.lean", + "formal/Auths/Product/Refinement/Connections.lean", + "formal/Auths/Product/Refinement/Gateway.lean", + "formal/Auths/Product/RelativeCeiling.lean", + "formal/Auths/Product/RequestConstruction.lean", + "formal/Auths/Product/SubmitOrder.lean", + "formal/Auths/Product/Theorems.lean", + "formal/Auths/Product/Tightening.lean", + "formal/Auths/Refinement/Approval.lean", + "formal/Auths/Refinement/Observation.lean", + "formal/Auths/Refinement/Production.lean", + "formal/Auths/Rich/Mutations.lean", + "formal/Auths/Rich/Semantics.lean", + "formal/Auths/Rich/Theorems.lean", + "formal/Auths/Rich/Types.lean", + "formal/Auths/Theorems.lean", + "formal/algebra-contract-v1.toml", + "formal/lake-manifest.json", + "formal/lakefile.toml", + "formal/lean-toolchain", + "formal/qualification/aeneas/generated/algebra/Funs.lean", + "formal/qualification/aeneas/generated/algebra/Types.lean", + "formal/qualification/aeneas/generated/authority/Funs.lean", + "formal/qualification/aeneas/generated/authority/FunsExternal.lean", + "formal/qualification/aeneas/generated/authority/Types.lean", + "formal/qualification/aeneas/generated/authority/TypesExternal.lean", + "formal/qualification/aeneas/generated/bounded_policy/Funs.lean", + "formal/qualification/aeneas/generated/bounded_policy/Types.lean", + "formal/qualification/aeneas/generated/connections/Funs.lean", + "formal/qualification/aeneas/generated/connections/Types.lean", + "formal/qualification/aeneas/generated/gateway/Funs.lean", + "formal/qualification/aeneas/generated/gateway/Types.lean", + "formal/qualification/aeneas/generated/lifecycle/Funs.lean", + "formal/qualification/aeneas/generated/lifecycle/Types.lean", + "formal/qualification/aeneas/generated/model/Funs.lean", + "formal/qualification/aeneas/generated/model/FunsExternal.lean", + "formal/qualification/aeneas/generated/model/Types.lean", +] +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" +scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." +residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] +toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" +axioms = ["propext"] + +[[claims.evidence]] +kind = "lean-proof" +artifact = "formal/Auths/Product/SubmitOrder.lean" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-225" @@ -13910,7 +14463,7 @@ claim_text = "Lean proves the gateway recipe property: pre claim refusal stores claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.pre_claim_refusal_stores_nothing" lean_statement_sha256 = "d8266ccd00249eba927b1fbbf7e505db7e3ca06f100684c3b07d2fdc8006ec30" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -13972,7 +14525,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -13984,7 +14537,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-226" @@ -13992,7 +14545,7 @@ claim_text = "Lean proves the gateway recipe property: not entered refusal table claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.not_entered_refusal_table" lean_statement_sha256 = "177dc8c4accfb1fced3209eccd723ab3b00afdf8b4c71396393a772a862ff947" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14054,7 +14607,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14066,15 +14619,15 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-227" claim_text = "Lean proves the gateway recipe property: post claim refusal records not entered." claim_status = "proved" lean_declaration = "Auths.Product.SubmitOrder.post_claim_refusal_records_not_entered" -lean_statement_sha256 = "192a3f34693f8a77fa76cfd8218a26fb32cd4e000c260923dc49f212bcda9ebe" -formal_review = "native-k-of-n-approvals-2026-09-30" +lean_statement_sha256 = "6608158b0cdeba4e352b3b9c138f5708428ebb0bbefbeea7e4dcc19b65962cb4" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14136,7 +14689,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14148,7 +14701,7 @@ axioms = [ [[claims.evidence]] kind = "lean-proof" artifact = "formal/Auths/Product/SubmitOrder.lean" -sha256 = "6b2fc0797bc4b8ccc5c5e53072c8388fc3267fc4131786cfdb761be02b50f722" +sha256 = "c3a785617ab737b1a9df676404241163616a426827ffbb55c5e26369f59099dc" [[claims]] claim_id = "AP-FORMAL-RICH-228" @@ -14156,7 +14709,7 @@ claim_text = "Lean proves the gateway recipe property: relative ceiling exact." claim_status = "proved" lean_declaration = "Auths.Product.RelativeCeiling.relative_ceiling_exact" lean_statement_sha256 = "ccaec2583a29ff660d59afea3cbc28bc6c2d81811b173ca661a752950597cf61" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14218,7 +14771,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14235,7 +14788,7 @@ claim_text = "Lean proves the gateway recipe property: relative ceiling never ex claim_status = "proved" lean_declaration = "Auths.Product.RelativeCeiling.relative_ceiling_never_exceeds_ratio" lean_statement_sha256 = "ddc05e7aac856e77fe875dc9327bb2f3de7d3c89a1c998ba9d0579239d51e192" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14297,7 +14850,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14314,7 +14867,7 @@ claim_text = "Lean proves the gateway recipe property: relative ceiling monotone claim_status = "proved" lean_declaration = "Auths.Product.RelativeCeiling.relative_ceiling_monotone" lean_statement_sha256 = "0d104c40d0dd9c30ee55e8a8708d8c13f59c95a81c2ef0fea5335ca5db706848" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14376,7 +14929,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14397,7 +14950,7 @@ claim_text = "Lean proves the gateway recipe property: relative basis never nega claim_status = "proved" lean_declaration = "Auths.Product.RelativeCeiling.relative_basis_never_negative" lean_statement_sha256 = "4ed5440adb7ca11dfa8288e59aaad29468d967cb1c8654cfc5d3331fbbc57b4b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14459,7 +15012,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, closed request construction over every compiled plan and argument list, the attempt-record transition rule over every sequence of records, the admission order over every event trace, and the exact relative ceiling." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14480,7 +15033,7 @@ claim_text = "Lean proves the gateway recipe property: method and origin fixed." claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.method_and_origin_fixed" lean_statement_sha256 = "7bcf7156c75568a5207b8689d2b3be7a890a5007f80deb6dfb4242603d1abd5e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14542,7 +15095,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14559,7 +15112,7 @@ claim_text = "Lean proves the gateway recipe property: path from declared segmen claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.path_from_declared_segments" lean_statement_sha256 = "80f90e7a0f1a764d352c074a03cb29c5a8f0190e431604b216eca137f5cdce0a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14621,7 +15174,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14641,7 +15194,7 @@ claim_text = "Lean proves the gateway recipe property: headers within declaratio claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.headers_within_declaration" lean_statement_sha256 = "1767a7004a5b634fa8269968caa485cf114ffcdf718ae1c2a1218f06c950ce98" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14703,7 +15256,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14720,7 +15273,7 @@ claim_text = "Lean proves the gateway recipe property: account scope header exac claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.account_scope_header_exact" lean_statement_sha256 = "10c9fb25aece47a2f6c82a3c90711b6fe27ee7b0b0ab111e86168e1548ec93c5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14782,7 +15335,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14799,7 +15352,7 @@ claim_text = "Lean proves the gateway recipe property: credential reads fixed." claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.credential_reads_fixed" lean_statement_sha256 = "02766f5e9149ca84b35952a07902a0d150524636fc1f4d9c50789dd03a159abb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14861,7 +15414,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14878,7 +15431,7 @@ claim_text = "Lean proves the gateway recipe property: body bounded." claim_status = "proved" lean_declaration = "Auths.Product.RequestConstruction.body_bounded" lean_statement_sha256 = "b9ff16f851122675e417ffb5cf618b0960a474aba638473d9fd6c139cb4fa182" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -14940,7 +15493,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure gateway recipe semantics: the recovery capability a recipe's declarations determine, and closed request construction over every compiled plan and argument list." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -14960,7 +15513,7 @@ claim_text = "The mechanically translated initial submit state returns exactly t claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_start_refines_model" lean_statement_sha256 = "0352a3ca2e917c34188e99770f714387e9fda7d0420d45b399c294fae164fce5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::order::start"] semantic_source_closure = [ "formal/Auths.lean", @@ -15022,7 +15575,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every submit plan." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -15038,17 +15591,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-211" @@ -15056,7 +15609,7 @@ claim_text = "The mechanically translated recovery-capability leaf returns exact claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_recovery_capability_refines_model" lean_statement_sha256 = "427ce8baf2a9bf87c27a0b185a87ef6d7cf57dfaaf3b89f6e43bfd50e7de8c92" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::recovery::recovery_capability"] semantic_source_closure = [ "formal/Auths.lean", @@ -15118,7 +15671,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every observation locator, echo flag, idempotency declaration, and pre-entry flag." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the listed foundational axioms, and the theorem's explicit representation-validity premise (every buffer the leaf builds is shorter than u32::MAX bytes) are trusted.", @@ -15133,17 +15686,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-212" @@ -15151,7 +15704,7 @@ claim_text = "The mechanically translated write construction returns exactly the claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_construct_write_refines_model" lean_statement_sha256 = "4a1b4fdc57bc755532f723f0e489a52178d1e1e905b9665f6c5f92cb0afeb155" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::construct::construct_write"] semantic_source_closure = [ "formal/Auths.lean", @@ -15213,7 +15766,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every write plan and argument list: path validation and percent-encoding, the canonical JSON or form body with the echo, version, account-scope, and idempotency headers, and the path and body bounds." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the listed foundational axioms, and the theorem's explicit representation-validity premise (every buffer the leaf builds is shorter than u32::MAX bytes) are trusted.", @@ -15229,17 +15782,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-213" @@ -15247,7 +15800,7 @@ claim_text = "The mechanically translated action-read construction returns exact claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_construct_action_read_refines_model" lean_statement_sha256 = "bb5c93a4929e5313fe181638a0bd81b0e4f2dffb612feed83dc75a3f4434fc22" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::construct::construct_action_read"] semantic_source_closure = [ "formal/Auths.lean", @@ -15309,7 +15862,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every action-read plan and argument list: the encoded path and the version and account-scope headers." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the listed foundational axioms, and the theorem's explicit representation-validity premise (every buffer the leaf builds is shorter than u32::MAX bytes) are trusted.", @@ -15325,17 +15878,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-214" @@ -15343,7 +15896,7 @@ claim_text = "The mechanically translated credential-read construction returns e claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_construct_credential_read_refines_model" lean_statement_sha256 = "9e69f024fad8ed4a8f21ccaf9bab552a377296555f66063bed13270869dab59f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::construct::construct_credential_read"] semantic_source_closure = [ "formal/Auths.lean", @@ -15405,7 +15958,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every credential-read plan: the fixed path and the version headers." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the listed foundational axioms, and the theorem's explicit representation-validity premise (every buffer the leaf builds is shorter than u32::MAX bytes) are trusted.", @@ -15421,17 +15974,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-232" @@ -15439,7 +15992,7 @@ claim_text = "The mechanically translated admission-order step machine returns e claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_next_step_refines_model" lean_statement_sha256 = "4f6f78fb06ad5e6bdabeafe6530141df9d68a0fbedaa02213e7e830e6c491989" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_gateway_kernel::order::next_step", "auths_gateway_kernel::ratio::relative_ceiling_admits", @@ -15504,7 +16057,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every plan, phase, verified argument, and event, including the denied-read index arithmetic and the relative-ceiling comparison on the verified argument." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -15520,17 +16073,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-233" @@ -15538,7 +16091,7 @@ claim_text = "The mechanically translated attempt-record transition rule returns claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_valid_transition_refines_model" lean_statement_sha256 = "a112e2fa7fad786aa452f674aeca7331f57dc51d5d01c9023571e09b6c4f1833" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::transition::valid_transition"] semantic_source_closure = [ "formal/Auths.lean", @@ -15600,7 +16153,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of transition views: the unchangeable bytes, the plan summary, the closed stage table, the checkpoint, the pre-entry and response fields, and stage consistency." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -15616,17 +16169,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-234" @@ -15634,7 +16187,7 @@ claim_text = "The mechanically translated relative basis returns exactly the mod claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_relative_basis_refines_model" lean_statement_sha256 = "01d60aceb109109bfa03e8afc89b12399bf3ff7435df7643a695c05f4a3eb0db" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::ratio::relative_basis"] semantic_source_closure = [ "formal/Auths.lean", @@ -15696,7 +16249,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 value and optional u64 subtrahend." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -15712,17 +16265,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-235" @@ -15730,7 +16283,7 @@ claim_text = "The mechanically translated relative-ceiling check returns exactly claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Gateway.translated_relative_ceiling_admits_refines_model" lean_statement_sha256 = "b74b4a9484b06e370376182e5eb9d0160797fbd60246ee5d54bb4d02d935841b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_gateway_kernel::ratio::relative_ceiling_admits"] semantic_source_closure = [ "formal/Auths.lean", @@ -15792,7 +16345,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 argument and basis and u16 basis points; neither u128 product overflows." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -15808,17 +16361,17 @@ axioms = [ [[claims.evidence]] kind = "lean-refinement" artifact = "formal/Auths/Product/Refinement/Gateway.lean" -sha256 = "59a2ad78eca15d40e4ca249d653cdbb870131ee2f24446bbff2f5f6144c72e13" +sha256 = "25a1770ec00c4ddcdaaa6cd6995d4c1e47afad17bc7e3164bf1bc4b0babafed6" [[claims.evidence]] kind = "mechanical-translation" artifact = "formal/qualification/aeneas/generated/gateway/Funs.lean" -sha256 = "c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636" +sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-249" @@ -15826,7 +16379,7 @@ claim_text = "Lean proves the connection credential-generation property: retaine claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.retained_generation_exact" lean_statement_sha256 = "5a5fe438f56954d871f9657a5a3d382ded930c94ba4e4ff14d8786624db91d65" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -15888,7 +16441,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -15908,7 +16461,7 @@ claim_text = "Lean proves the connection credential-generation property: lease g claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.lease_generation_exact" lean_statement_sha256 = "00f5f2fe7894d82e1bd31d1008f7d6c616bb2fdc44df3d770efd72cb3328b8cc" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -15970,7 +16523,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -15990,7 +16543,7 @@ claim_text = "Lean proves the connection credential-generation property: credent claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.credential_generation_le_generation" lean_statement_sha256 = "9238e8945c3c2eefb361bdb5948e24e74aff8c8d75bdc993f254fae718423f21" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16052,7 +16605,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16072,7 +16625,7 @@ claim_text = "Lean proves the connection credential-generation property: state c claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.state_change_preserves_credential_generation" lean_statement_sha256 = "21d808e879ca61e1b963ee47434d437f62a4fddfd931e9bddb526fd64fc60d2d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16134,7 +16687,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16154,7 +16707,7 @@ claim_text = "Lean proves the connection credential-generation property: lease s claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.lease_selects_credential_generation" lean_statement_sha256 = "fcd8e4b1f6cc2d26b557d112ddd23e106297ded39fd605786a19c571a77a566f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16216,7 +16769,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16236,7 +16789,7 @@ claim_text = "Lean proves the connection credential-generation property: join af claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.join_after_state_changes" lean_statement_sha256 = "cb7c333deb7e0a658e774caa74b3ea3f815fe51dcaf51a2df9577a0d1cb5a8a7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16298,7 +16851,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16318,7 +16871,7 @@ claim_text = "Lean proves the connection credential-generation property: revoked claim_status = "proved" lean_declaration = "Auths.Product.ConnectionGenerations.revoked_never_leases" lean_statement_sha256 = "cd6bed579be40bdfdc14ebdefd4b7f46fbe2499409a8d791466649e46331f49d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16380,7 +16933,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure connection-record generation semantics over every sequence of install, join, rotate, disable, enable, and revoke across any number of processes sharing one record: the credential generation, the retained-entry lease rule, and revocation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16397,7 +16950,7 @@ claim_text = "The mechanically translated next generation returns exactly the mo claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Connections.translated_next_generation_refines_model" lean_statement_sha256 = "50f902a37ddd5aa8eb769d37c32b135d114611b85d83dffd4241faa4527575fc" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_connections::kernel::next_generation"] semantic_source_closure = [ "formal/Auths.lean", @@ -16459,7 +17012,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 generation." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -16485,7 +17038,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-257" @@ -16493,7 +17046,7 @@ claim_text = "The mechanically translated state change returns exactly the model claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Connections.translated_state_change_refines_model" lean_statement_sha256 = "ec42028ad8f3b27ddda3a7529c79097a496ad20d6bfa4b529ebbaa27c97b1b5c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_connections::kernel::state_change", "auths_connections::kernel::next_generation", @@ -16558,7 +17111,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of u64 generations." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -16584,7 +17137,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-258" @@ -16592,7 +17145,7 @@ claim_text = "The mechanically translated rotation returns exactly the model's g claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Connections.translated_rotation_refines_model" lean_statement_sha256 = "ae9b8de24e57ae7e8116c3d3a5fe6e35be3cbe350807822b1a42bb0f2cb5c250" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_connections::kernel::rotation", "auths_connections::kernel::next_generation", @@ -16657,7 +17210,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every pair of u64 generations." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -16683,7 +17236,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-259" @@ -16691,7 +17244,7 @@ claim_text = "The mechanically translated retained-entry search returns exactly claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Connections.translated_retained_generation_refines_model" lean_statement_sha256 = "0f34a598bce76fd894dbb859b226616c03433fa08660f8179f7a08b77d815fd3" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_connections::kernel::retained_generation"] semantic_source_closure = [ "formal/Auths.lean", @@ -16753,7 +17306,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 record generation and every slice of stored generations, in any order." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -16779,7 +17332,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-260" @@ -16787,7 +17340,7 @@ claim_text = "The mechanically translated lease leaf returns exactly the model's claim_status = "qualified" lean_declaration = "Auths.Product.Refinement.Connections.translated_lease_generation_refines_model" lean_statement_sha256 = "0b055274a8b03d3b97de987af664c1ea51b66bfc09e0edc61606483c4c826911" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_connections::kernel::lease_generation", "auths_connections::kernel::retained_generation", @@ -16852,7 +17405,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every u64 record and credential generation and every slice of stored generations." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, and the listed foundational axioms are trusted; the theorem has no premise.", @@ -16878,7 +17431,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-070" @@ -16886,7 +17439,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: additive claim_status = "proved" lean_declaration = "Auths.Lifecycle.additive_capacity_success_positive" lean_statement_sha256 = "dcd8c19f436246f345583eb79fa8f56ca0d79801619ec832bb1965cfa4ef7505" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -16948,7 +17501,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -16969,7 +17522,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: additive claim_status = "proved" lean_declaration = "Auths.Lifecycle.additive_capacity_success_conserves" lean_statement_sha256 = "4c9f497e6dde81872f4262a4d1ef41176e7fed5cbbfdf5ddef76cd6d2f8720a3" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17031,7 +17584,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17051,7 +17604,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: additive claim_status = "proved" lean_declaration = "Auths.Lifecycle.additive_capacity_success_never_overflows_u64" lean_statement_sha256 = "1505323a6e0d5ea769a5f3ce908b2e63df64a61ee675bf46ad235e4934158e55" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17113,7 +17666,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17133,7 +17686,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: reserve claim_status = "proved" lean_declaration = "Auths.Lifecycle.reserve_preserves_capacity" lean_statement_sha256 = "0215021eae68f54b9d07f77d465d2d5d0f574d82c956050d6a42d65f76360f1e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17195,7 +17748,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17215,7 +17768,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: commit p claim_status = "proved" lean_declaration = "Auths.Lifecycle.commit_preserves_capacity" lean_statement_sha256 = "6e340919635140c32e62bbb5eaae23126fd0f53586c46407c7e16b970f4fd4ca" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17277,7 +17830,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17298,7 +17851,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: release claim_status = "proved" lean_declaration = "Auths.Lifecycle.release_preserves_capacity" lean_statement_sha256 = "a554833f3a765873264be9c667d0293f8b5a7cf6f3a79d9b1fa03131b6414b94" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17360,7 +17913,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17381,7 +17934,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: exact re claim_status = "proved" lean_declaration = "Auths.Lifecycle.exact_replay_is_stable" lean_statement_sha256 = "ddbb29e971f6f0c416d4ae2bbac689cc221c305745d7a2d90b0b36224f63320c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17443,7 +17996,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17460,7 +18013,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: conflict claim_status = "proved" lean_declaration = "Auths.Lifecycle.conflicting_replay_is_not_exact" lean_statement_sha256 = "16040fad2ac968a316520f6e522063d1e6aeeb5000305573e650296cec80290f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17522,7 +18075,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17539,7 +18092,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: absent r claim_status = "proved" lean_declaration = "Auths.Lifecycle.absent_replay_never_claims_effect" lean_statement_sha256 = "52a298bd35ffa236d8370ab74d78a674e9e9243a686c52e611f92be3c5cfcf64" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17601,7 +18154,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17618,7 +18171,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: start at claim_status = "proved" lean_declaration = "Auths.Lifecycle.start_attempt_requires_credential" lean_statement_sha256 = "4dcfb31b2e2662aef2c336d0c4f55f922b3c6ac226776bed4daacca4424d1904" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17680,7 +18233,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17697,7 +18250,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: provider claim_status = "proved" lean_declaration = "Auths.Lifecycle.provider_call_requires_attempt" lean_statement_sha256 = "215e750dce32f2f49fa22b96b5c44699bb15604760223b9f26ace3becbac3bdb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17759,7 +18312,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17776,7 +18329,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: commit r claim_status = "proved" lean_declaration = "Auths.Lifecycle.commit_requires_provider_entry_and_effect" lean_statement_sha256 = "de9baa696f2dbc23d1dfe965a72bc95f211cda0525f3a212af4197864aab36f2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17838,7 +18391,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17855,7 +18408,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: outcome claim_status = "proved" lean_declaration = "Auths.Lifecycle.outcome_unknown_cannot_release" lean_statement_sha256 = "3d3102111fb51a188aeffe93d7dc6ad13b25a4db54b871f8d4a4b27f98e88c9b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17917,7 +18470,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -17934,7 +18487,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: outcome claim_status = "proved" lean_declaration = "Auths.Lifecycle.outcome_unknown_only_reconciliation_can_terminate" lean_statement_sha256 = "98af24c5f5fa0f00c4cbc0ef76b168f8fbc0811d3a3069e587d844a9406c5def" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -17996,7 +18549,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18013,7 +18566,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: configur claim_status = "proved" lean_declaration = "Auths.Lifecycle.configuration_mismatch_stops_reservation" lean_statement_sha256 = "9eb20bb520a94f7bfd23c41793df96630035b109d3bd77ae5520e384d80f87a7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18075,7 +18628,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18092,7 +18645,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: configur claim_status = "proved" lean_declaration = "Auths.Lifecycle.configuration_mismatch_stops_credential" lean_statement_sha256 = "6f4e8f2d72115f41f5d9881ece6c3d8bff1fcca74bf34415a14475b316085abb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18154,7 +18707,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18171,7 +18724,7 @@ claim_text = "Lean proves the reservation/execution lifecycle property: terminal claim_status = "proved" lean_declaration = "Auths.Lifecycle.terminal_states_never_transition" lean_statement_sha256 = "ac59e2c5beb8dcaf74cafc08c46f48d6d2345ab773dcf2dae55a337bd1c30acc" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18233,7 +18786,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Pure V1 lifecycle transitions, capacity conservation, replay, configuration gates, credential ordering, provider entry, and reconciliation." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18250,7 +18803,7 @@ claim_text = "Lean proves the mechanically translated shipping Rust lifecycle ke claim_status = "proved" lean_declaration = "Auths.Lifecycle.Refinement.translated_terminal_refines_rich" lean_statement_sha256 = "8963dd672ee5d30584b6a8a131ca2e28a824c51ce5126805eea83ebbe55d71c9" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_lifecycle::model::LifecycleState::is_terminal"] semantic_source_closure = [ "formal/Auths.lean", @@ -18312,7 +18865,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The pinned Charon/Aeneas translation of `auths_lifecycle::model::LifecycleState::is_terminal` is extensionally equivalent to the corresponding rich Lean V1 lifecycle semantics." residual_assumptions = ["Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the qualified translation boundary, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18329,7 +18882,7 @@ claim_text = "Lean proves the mechanically translated shipping Rust lifecycle ke claim_status = "proved" lean_declaration = "Auths.Lifecycle.Refinement.translated_transition_refines_rich" lean_statement_sha256 = "ed38f14b22ae254a97a391b4a7ea4064665d323a26e4ec556769f1451731c6cf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_lifecycle::kernel::transition_code"] semantic_source_closure = [ "formal/Auths.lean", @@ -18391,7 +18944,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The pinned Charon/Aeneas translation of `auths_lifecycle::kernel::transition_code` is extensionally equivalent to the corresponding rich Lean V1 lifecycle semantics." residual_assumptions = ["Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the qualified translation boundary, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18411,7 +18964,7 @@ claim_text = "Lean proves the mechanically translated shipping Rust lifecycle ke claim_status = "proved" lean_declaration = "Auths.Lifecycle.Refinement.translated_exclusive_capacity_refines_rich" lean_statement_sha256 = "76c468b3a6a2c9a0231675e987fabf48df92073dc24aadce05f6552165c9e8cf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_lifecycle::kernel::exclusive_capacity_available"] semantic_source_closure = [ "formal/Auths.lean", @@ -18473,7 +19026,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The pinned Charon/Aeneas translation of `auths_lifecycle::kernel::exclusive_capacity_available` is extensionally equivalent to the corresponding rich Lean V1 lifecycle semantics." residual_assumptions = ["Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the qualified translation boundary, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18490,7 +19043,7 @@ claim_text = "Lean proves the mechanically translated shipping Rust lifecycle ke claim_status = "proved" lean_declaration = "Auths.Lifecycle.Refinement.translated_additive_capacity_refines_rich" lean_statement_sha256 = "530d89045350d0aa6be9ad09121e16e2a91d8ed3652b8e9508e5ef2a655e9ada" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_lifecycle::kernel::additive_capacity_available"] semantic_source_closure = [ "formal/Auths.lean", @@ -18552,7 +19105,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The pinned Charon/Aeneas translation of `auths_lifecycle::kernel::additive_capacity_available` is extensionally equivalent to the corresponding rich Lean V1 lifecycle semantics." residual_assumptions = ["Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the qualified translation boundary, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18573,7 +19126,7 @@ claim_text = "Lean proves the mechanically translated shipping Rust lifecycle ke claim_status = "proved" lean_declaration = "Auths.Lifecycle.Refinement.translated_replay_refines_rich" lean_statement_sha256 = "ede2a75a3447bb934a2454580f45e9610dcf521b669bca3fbe697f567764d7f4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_lifecycle::kernel::replay_code"] semantic_source_closure = [ "formal/Auths.lean", @@ -18635,7 +19188,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The pinned Charon/Aeneas translation of `auths_lifecycle::kernel::replay_code` is extensionally equivalent to the corresponding rich Lean V1 lifecycle semantics." residual_assumptions = ["Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the qualified translation boundary, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18652,7 +19205,7 @@ claim_text = "Binary all composition is commutative." claim_status = "proved" lean_declaration = "Auths.all_commutative" lean_statement_sha256 = "fd3226a3df5fb4730eeaeb50b3190d9f0ae29aeb961d395825787945fdcdd445" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18714,7 +19267,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary all operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18731,7 +19284,7 @@ claim_text = "Binary all composition is associative." claim_status = "proved" lean_declaration = "Auths.all_associative" lean_statement_sha256 = "5749607a3f2752bdd73ae4559af264763d8a36ec3d1258ed4f60b11467d7e12d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18793,7 +19346,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary all operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18810,7 +19363,7 @@ claim_text = "Binary all composition is idempotent." claim_status = "proved" lean_declaration = "Auths.all_idempotent" lean_statement_sha256 = "99993635cb0eadeacab1d64ee7f674245481d4160a770deaed82022c0851a3f6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18872,7 +19425,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary all operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18889,7 +19442,7 @@ claim_text = "Binary any composition is commutative." claim_status = "proved" lean_declaration = "Auths.any_commutative" lean_statement_sha256 = "a2680b963a19fb4f377fefaad4102a4469895954bbea2b7541894902e979115d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -18951,7 +19504,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary any operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -18968,7 +19521,7 @@ claim_text = "Binary any composition is associative." claim_status = "proved" lean_declaration = "Auths.any_associative" lean_statement_sha256 = "3ceaf22f6776423ee96cbdf5fa9bc5c13fca94bdbb3355b016d6b8e4c275afa8" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -19030,7 +19583,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary any operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19047,7 +19600,7 @@ claim_text = "Binary any composition is idempotent." claim_status = "proved" lean_declaration = "Auths.any_idempotent" lean_statement_sha256 = "8f1cb9d3d130a67d026a96f278678b9070badc44f40f7c538ee68a3f9af90d82" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -19109,7 +19662,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The closed three-valued binary any operator." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19126,7 +19679,7 @@ claim_text = "A threshold of one over two truth values equals binary any." claim_status = "proved" lean_declaration = "Auths.threshold_one_eq_any" lean_statement_sha256 = "639a98d2dcab0db13ec9b221b75605fa48ec169a263f76feb2034f912d7a69c7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19188,7 +19741,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, linked to the generated threshold-count function by thresholdTwo_eq_thresholdCounts." residual_assumptions = ["Lean's kernel, the pinned toolchain, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19210,7 +19763,7 @@ claim_text = "A threshold of two over two truth values equals binary all." claim_status = "proved" lean_declaration = "Auths.threshold_n_eq_all" lean_statement_sha256 = "7bfb0c0d44d1f31949d7039be3c2052cab9112fcb12d2abef005e6c52979b815" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19272,7 +19825,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, linked to the generated threshold-count function by thresholdTwo_eq_thresholdCounts." residual_assumptions = ["Lean's kernel, the pinned toolchain, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19294,7 +19847,7 @@ claim_text = "Raising the two-input threshold from one to two cannot raise its a claim_status = "proved" lean_declaration = "Auths.threshold_monotone_k" lean_statement_sha256 = "34c77c69b14f1b08db8fba8da86a0a9eb65b95147b85d8d3f48811b47cabcb79" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19356,7 +19909,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Exactly the two-input threshold helper and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, listed foundational axioms, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19381,7 +19934,7 @@ claim_text = "A threshold of zero over two truth values is authorized, the thres claim_status = "proved" lean_declaration = "Auths.threshold_zero_authorized" lean_statement_sha256 = "bc42184fb1f441c5e5ee699d44e0a80c38161401ae018e678d5b7a7300463cbf" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19443,7 +19996,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, the generated threshold-count function, and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19460,7 +20013,7 @@ claim_text = "A threshold of three or more over two truth values is denied, the claim_status = "proved" lean_declaration = "Auths.threshold_above_inputs_denied" lean_statement_sha256 = "d080b789affedcde693adeadcd36a21e772e0c5d21f40002ccc521f48a1c3748" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19522,7 +20075,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, the generated threshold-count function, and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19539,7 +20092,7 @@ claim_text = "For every k, raising the two-input threshold cannot raise its auth claim_status = "proved" lean_declaration = "Auths.threshold_antitone_k" lean_statement_sha256 = "efa1ab70eaceb5322dd690f37fd6372ab1092f49da878f391158840b4afed292" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19601,7 +20154,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, the generated threshold-count function, and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19622,7 +20175,7 @@ claim_text = "For every count of authorized and indeterminate members, raising t claim_status = "proved" lean_declaration = "Auths.thresholdCounts_antitone_required" lean_statement_sha256 = "5f1fda6eb247d5ed916296eccfef581d05ed4ecbed69455445bc8ce5ff12fcd6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19684,7 +20237,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The generated threshold-count function, whose Rust twin the verifier runs, and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19704,7 +20257,7 @@ claim_text = "For every k, the two-input threshold helper equals the generated t claim_status = "proved" lean_declaration = "Auths.thresholdTwo_eq_thresholdCounts" lean_statement_sha256 = "e36ef8702dd4af7d133609adacf0b481ac3302e59f9b0d64563976531f8a017e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -19766,7 +20319,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The hand-written two-input threshold helper, the generated threshold-count function, and the declared three-valued truth order." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19786,7 +20339,7 @@ claim_text = "Swapping the two inputs preserves binary all and binary any result claim_status = "proved" lean_declaration = "Auths.binary_composition_swap_invariant" lean_statement_sha256 = "5a2f18a8b889fca7e2d4f239a97a12490193b19c6d3e8703164e04cc556986c7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -19848,7 +20401,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "A two-value swap only; arbitrary authorization-plan permutations are not claimed." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19865,7 +20418,7 @@ claim_text = "The two-value minimum diagnostic code is invariant under swapping claim_status = "proved" lean_declaration = "Auths.canonical_diagnostic_permutation_invariant" lean_statement_sha256 = "c0eae1c5c0004d836da0c28c5d5395ecb7e534d05e9816a573d27b7c0f912806" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -19927,7 +20480,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The two-value canonicalCode helper; arbitrary plan diagnostic permutations are not claimed." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -19944,7 +20497,7 @@ claim_text = "The current plan visit helper is definitionally the plan leaf enum claim_status = "proved" lean_declaration = "Auths.plan_visit_is_leaf_enumeration" lean_statement_sha256 = "a9d2d3fd6140d7535c9cf3567cf92a5891e8e77fda5924a34a032bb1d9cab0cb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20006,7 +20559,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "A definitional model equality; it does not prove that the shipping evaluator visits leaves once." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20026,7 +20579,7 @@ claim_text = "The current plan cost helper is definitionally the recursive node claim_status = "proved" lean_declaration = "Auths.plan_cost_is_node_count" lean_statement_sha256 = "d0e9f71500f5da6108662057f11150fa61188b6b5059562b6db0079bd4e5820e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20088,7 +20641,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "A definitional model equality; no asymptotic or shipping evaluator cost bound is claimed." residual_assumptions = ["Lean's kernel, the pinned toolchain, and the listed foundational axioms are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20108,7 +20661,7 @@ claim_text = "An authorized generated threshold result implies the authorized co claim_status = "proved" lean_declaration = "Auths.authorized_implies_threshold_met" lean_statement_sha256 = "367522026ebf77cc4e8ee694920ff72384ab58cb573bb7cefb8406117955d2d1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -20170,7 +20723,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The generated count classifier and its exhaustive target-V1 bounded Rust vectors." residual_assumptions = ["Lean's kernel, the pinned toolchain, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20192,7 +20745,7 @@ claim_text = "A denied generated threshold result implies authorized plus indete claim_status = "proved" lean_declaration = "Auths.denied_implies_threshold_impossible" lean_statement_sha256 = "50005cbb684ef7566e1b6f71fc766e9960de178f0a86f03e37f4eb63cf7e46d5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -20254,7 +20807,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The generated count classifier and its exhaustive target-V1 bounded Rust vectors." residual_assumptions = ["Lean's kernel, the pinned toolchain, listed foundational axioms, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20279,7 +20832,7 @@ claim_text = "An indeterminate generated threshold result means authorization is claim_status = "proved" lean_declaration = "Auths.indeterminate_implies_threshold_reachable" lean_statement_sha256 = "dd970bbab7dd61f7b1274f9e829358d9627b3c822d4119628191018722f31039" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_algebra_kernel::threshold_counts"] semantic_source_closure = [ "formal/Auths.lean", @@ -20341,7 +20894,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The generated count classifier and its exhaustive target-V1 bounded Rust vectors." residual_assumptions = ["Lean's kernel, the pinned toolchain, listed foundational axioms, generator correctness, and the Rust vector harness are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20367,7 +20920,7 @@ claim_text = "Lean proves adding an observation requirement never enlarges the s claim_status = "proved" lean_declaration = "Auths.Observation.requirements_monotone" lean_statement_sha256 = "148ccf94301235d93a8436967797e60faca90b144df545bd381377b4a50a6a6a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20429,7 +20982,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20449,7 +21002,7 @@ claim_text = "Lean proves adding a condition to an observation requirement never claim_status = "proved" lean_declaration = "Auths.Observation.conditions_monotone" lean_statement_sha256 = "580cb89f54be773f8f5b9477dcfa105314d26628e415c3d9e43bc0abbaf13f07" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20511,7 +21064,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20531,7 +21084,7 @@ claim_text = "Lean proves a child grant whose base authority attenuates and whos claim_status = "proved" lean_declaration = "Auths.Observation.child_requirements_superset_attenuates" lean_statement_sha256 = "569899c6f3632631a784c25e616bcf272690422a491a5f6227f51270e442fbe5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20593,7 +21146,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20613,7 +21166,7 @@ claim_text = "Lean proves attaching more observations never turns a satisfied ob claim_status = "proved" lean_declaration = "Auths.Observation.satisfied_monotone_observations" lean_statement_sha256 = "ba0d15b96cedec283e46c0829abd94525ab9d378848e5f17d737b529e786aff5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20675,7 +21228,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20695,7 +21248,7 @@ claim_text = "Lean proves an empty observation set satisfies no observation requ claim_status = "proved" lean_declaration = "Auths.Observation.no_observation_satisfies_nothing" lean_statement_sha256 = "2de8b8b35b722baed67f9208a44ed87aad1918842eac9d30b1a0af9248cf6b91" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20757,7 +21310,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20774,7 +21327,7 @@ claim_text = "Lean proves an observation dated after the evaluation time is neve claim_status = "proved" lean_declaration = "Auths.Observation.future_observation_never_fresh" lean_statement_sha256 = "25e1df429190fb5954c738d846264281c1f699bf5f3b2dd09e153458f8f7d3da" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20836,7 +21389,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20857,7 +21410,7 @@ claim_text = "Lean proves an observation older than the requirement's maximum ag claim_status = "proved" lean_declaration = "Auths.Observation.stale_observation_never_fresh" lean_statement_sha256 = "bc723fae1eda0ccab4ab50fe9439378198157d48db4c7cb20c50b99501d4a705" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -20919,7 +21472,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -20940,7 +21493,7 @@ claim_text = "Lean proves a satisfied observation requirement had every action f claim_status = "proved" lean_declaration = "Auths.Observation.satisfied_requires_action_facts" lean_statement_sha256 = "868823975fffe7737c3f778322256228fee15e6e7aaa6d4ec7f6141da0b11ea1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21002,7 +21555,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21022,7 +21575,7 @@ claim_text = "Lean proves the three-valued observation verdict is satisfied exac claim_status = "proved" lean_declaration = "Auths.Observation.decision_satisfied_iff" lean_statement_sha256 = "e7e42f0b73ac6aaacf07a646de0481da0942a790607af2896777f242e450da61" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21084,7 +21637,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21104,7 +21657,7 @@ claim_text = "Lean proves a denied observation verdict has an eligible observati claim_status = "proved" lean_declaration = "Auths.Observation.decision_denied_has_falsifying_observation" lean_statement_sha256 = "220d9a14270b12a16d4c386a08706c81032a17990421d6712ca365f94bcacde6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21166,7 +21719,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21186,7 +21739,7 @@ claim_text = "Lean proves an observation fresh under a smaller maximum age is fr claim_status = "proved" lean_declaration = "Auths.Observation.fresh_monotone_max_age" lean_statement_sha256 = "54093bcffc875104caccb21819e59c367362132d9d2446952efd7a408f65f059" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21248,7 +21801,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21269,7 +21822,7 @@ claim_text = "Lean proves a strictly narrowed observation requirement is satisfi claim_status = "proved" lean_declaration = "Auths.Observation.narrows_monotone" lean_statement_sha256 = "9fba78f0577d3888e9f544a917fe1a44fa53cfbaeb9b600a27cab1a56859cb05" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21331,7 +21884,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21352,7 +21905,7 @@ claim_text = "Lean proves a covering observation requirement is satisfied only w claim_status = "proved" lean_declaration = "Auths.Observation.covers_monotone" lean_statement_sha256 = "aafa19c473cfc60aa626d058fcb1285f5b515a435dbbf9d2d250c9935fd65bbb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21414,7 +21967,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21435,7 +21988,7 @@ claim_text = "Lean proves observation-requirement covering is transitive." claim_status = "proved" lean_declaration = "Auths.Observation.covers_trans" lean_statement_sha256 = "8be67281de157aa1ce9f37e536382462d33cebfc8b6ad06ebacc950b100cb241" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21497,7 +22050,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21517,7 +22070,7 @@ claim_text = "Lean proves observation-requirement list attenuation is reflexive. claim_status = "proved" lean_declaration = "Auths.Observation.requirements_attenuate_refl" lean_statement_sha256 = "3ddf75aca2a28b5c1f927d5adc747a45ab309a933646b17f963484e5d5128c98" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21579,7 +22132,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21596,7 +22149,7 @@ claim_text = "Lean proves observation-requirement list attenuation is transitive claim_status = "proved" lean_declaration = "Auths.Observation.requirements_attenuate_trans" lean_statement_sha256 = "3d3f4d07e0abf3bb05962c8d2dd052613dcb5be878594ae858290c2d0fa620d3" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21658,7 +22211,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21678,7 +22231,7 @@ claim_text = "Lean proves a child requirement list that attenuates its parent's claim_status = "proved" lean_declaration = "Auths.Observation.requirements_attenuate_monotone" lean_statement_sha256 = "ee97dc30d382ed4737017fb8325d2ed3777d80c69ad989231e81b02b64686073" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21740,7 +22293,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract evidence-conditioned authority: closed conjunctive observation conditions, freshness, observer and subject binding, over already verified observations and an abstract subject namespace matcher." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21761,7 +22314,7 @@ claim_text = "Lean proves the observation-requirement-v1 attenuation law is a pr claim_status = "proved" lean_declaration = "Auths.Observation.observation_requirement_law_lawful" lean_statement_sha256 = "617d5169222466363d1b356846ca50e92b48c170f114cd7cfec4bebbbbb64f7d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21823,7 +22376,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Critical-extension attenuation laws over decoded payloads: each registered handler law is a preorder that narrows the worlds its payload admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21844,7 +22397,7 @@ claim_text = "Lean proves the observation-requirement-v1 law accepts adding the claim_status = "proved" lean_declaration = "Auths.Observation.observation_requirement_law_accepts_addition" lean_statement_sha256 = "e20a8c08c602235bc1aabfeff4bf5e9eebd473a410cd568b26c88c497b8f4ef0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21906,7 +22459,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Critical-extension attenuation laws over decoded payloads: each registered handler law is a preorder that narrows the worlds its payload admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -21923,7 +22476,7 @@ claim_text = "Lean proves the K-of-N approval property: approval decide eq thres claim_status = "proved" lean_declaration = "Auths.Approval.approval_decide_eq_threshold_counts" lean_statement_sha256 = "edf74a0cb0c581e211fb2e53b7042562c38c18635c33161d238967b8be2f247e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -21985,7 +22538,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22002,7 +22555,7 @@ claim_text = "Lean proves the K-of-N approval property: approval authorized iff claim_status = "proved" lean_declaration = "Auths.Approval.approval_authorized_iff_distinct_quorum" lean_statement_sha256 = "ed8b9c7105938a6c41ee1321aaea4472efc6d75b6a9ee2a6791ed2fa139f316c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22064,7 +22617,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22084,7 +22637,7 @@ claim_text = "Lean proves the K-of-N approval property: approval duplicate irrel claim_status = "proved" lean_declaration = "Auths.Approval.approval_duplicate_irrelevant" lean_statement_sha256 = "091b7dc31c1282d496858bae18b2a24238427aa9e44822bf0b87e902f969f83e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22146,7 +22699,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22166,7 +22719,7 @@ claim_text = "Lean proves the K-of-N approval property: approval outsider irrele claim_status = "proved" lean_declaration = "Auths.Approval.approval_outsider_irrelevant" lean_statement_sha256 = "7919b2b9e3f9af2cc09100de0d401b6481c08132ddc5cce127a4e4bc64ae0e77" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22228,7 +22781,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22248,7 +22801,7 @@ claim_text = "Lean proves the K-of-N approval property: approval other action ir claim_status = "proved" lean_declaration = "Auths.Approval.approval_other_action_irrelevant" lean_statement_sha256 = "ab11d19f7f7a07159511b63cf269779db785763da037cfdaac4a6504ac844df4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22310,7 +22863,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22330,7 +22883,7 @@ claim_text = "Lean proves the K-of-N approval property: approval other requireme claim_status = "proved" lean_declaration = "Auths.Approval.approval_other_requirement_irrelevant" lean_statement_sha256 = "6ae502a88055c3daca41ca03e8146337bb020150395d6f05f185e209320c9e78" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22392,7 +22945,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22412,7 +22965,7 @@ claim_text = "Lean proves the K-of-N approval property: approval self approval i claim_status = "proved" lean_declaration = "Auths.Approval.approval_self_approval_irrelevant" lean_statement_sha256 = "83b91c2de34c32a06176d103c17b455d7e5c1977f18c3b7d9fb7e758f99a6da4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22474,7 +23027,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22494,7 +23047,7 @@ claim_text = "Lean proves the K-of-N approval property: approval permutation inv claim_status = "proved" lean_declaration = "Auths.Approval.approval_permutation_invariant" lean_statement_sha256 = "e5167218ec0c197a06f1eae05406ec507b75f3b2272a409c3f431f236070be33" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22556,7 +23109,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22576,7 +23129,7 @@ claim_text = "Lean proves the K-of-N approval property: approval monotone in app claim_status = "proved" lean_declaration = "Auths.Approval.approval_monotone_in_approvals" lean_statement_sha256 = "eb3583553f5f013a3a8f76bc84808f167a852b199d4528faf1beaa6f9aa4b98e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22638,7 +23191,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22659,7 +23212,7 @@ claim_text = "Lean proves the K-of-N approval property: approval antitone in thr claim_status = "proved" lean_declaration = "Auths.Approval.approval_antitone_in_threshold" lean_statement_sha256 = "b1e0b00684d659884ad65523e4f4b42ceec355686cebdc950ddd6f70c57b67a1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22721,7 +23274,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22741,7 +23294,7 @@ claim_text = "Lean proves the K-of-N approval property: approval antitone in app claim_status = "proved" lean_declaration = "Auths.Approval.approval_antitone_in_approvers" lean_statement_sha256 = "91f04d22b450064899e426f5a02c45536f8e0a550cfd2209f3032c8a9cd0bc9d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22803,7 +23356,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22824,7 +23377,7 @@ claim_text = "Lean proves the K-of-N approval property: approval authorized meet claim_status = "proved" lean_declaration = "Auths.Approval.approval_authorized_meets" lean_statement_sha256 = "7543f43fad4398cf6f5514a0f628581d569ddb1b0190d4d341ed4ad762cb0174" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22886,7 +23439,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract K-of-N approval model: per-approval verdicts over the approver, bound action, bound requirement identifier, validity window, and verification truth; distinct counting per listed approver; and the generated thresholdCounts decision." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22907,7 +23460,7 @@ claim_text = "Lean proves the K-of-N approval property: covers monotone." claim_status = "proved" lean_declaration = "Auths.Approval.covers_monotone" lean_statement_sha256 = "af566b39841cd9fb7769ebeb7004d3b64edfbcb35a7d779a72d9c017459a7d35" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -22969,7 +23522,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -22990,7 +23543,7 @@ claim_text = "Lean proves the K-of-N approval property: covers trans." claim_status = "proved" lean_declaration = "Auths.Approval.covers_trans" lean_statement_sha256 = "71bb145d77cd3db75a110f32d90269a90ada8f43a25e5569a379a87ec68a2d9f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23052,7 +23605,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23069,7 +23622,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirements at claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirements_attenuate_refl" lean_statement_sha256 = "5001fe3083c023f9cc8260ff9d89ca869fbdf3b85cdf4bfc267ce78e9bae9358" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23131,7 +23684,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23148,7 +23701,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirements at claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirements_attenuate_trans" lean_statement_sha256 = "e3cdeabbbb19bff2db617206edf53cbbc5758f6276b7144cb9174aa52dd430ad" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23210,7 +23763,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23227,7 +23780,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirements at claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirements_attenuate_monotone" lean_statement_sha256 = "bbfc53b74d226bc67466f477529aa6cdbf67df24408ff3eeae10773d92e5728d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23289,7 +23842,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23310,7 +23863,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirement law claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirement_law_lawful" lean_statement_sha256 = "53044016738fba16175dea47ebacba4ada4e9286616ea79a8cac69f94cad5b03" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23372,7 +23925,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23393,7 +23946,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirement law claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirement_law_accepts_addition" lean_statement_sha256 = "f8224b7c2a7f5b10c9fe3d1b368b240888e88c62ace4db0ef100ce24faea3661" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23455,7 +24008,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23472,7 +24025,7 @@ claim_text = "Lean proves the K-of-N approval property: approval requirement law claim_status = "proved" lean_declaration = "Auths.Approval.approval_requirement_law_refuses_drop" lean_statement_sha256 = "fe7f7ba5f0892d4b6f9077950bbc333541a83d79fafe5d8ceee3dbed044e242e" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23534,7 +24087,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Abstract approval-requirement-v1 attenuation law over decoded requirement lists (approver sets and thresholds) and the sets of approving principals each admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23551,7 +24104,7 @@ claim_text = "Lean proves the exact-marker-v1 attenuation law is a preorder that claim_status = "proved" lean_declaration = "Auths.exact_marker_law_lawful" lean_statement_sha256 = "6f9ff0b2e1f580f8cfc27dcaeaefeee2a19b7cda02879335bf9763287a89eb05" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23613,7 +24166,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Critical-extension attenuation laws over decoded payloads: each registered handler law is a preorder that narrows the worlds its payload admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23630,7 +24183,7 @@ claim_text = "Lean proves the exact-marker-v1 law refuses adding the marker." claim_status = "proved" lean_declaration = "Auths.exact_marker_law_refuses_addition" lean_statement_sha256 = "1019a69a34a92a24de8ebdb88a1a5b5ee4707f044a355fbb62a097b913a9c7f5" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23692,7 +24245,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Critical-extension attenuation laws over decoded payloads: each registered handler law is a preorder that narrows the worlds its payload admits." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23709,7 +24262,7 @@ claim_text = "Lean proves the narrowing premise holds when each registered ident claim_status = "proved" lean_declaration = "Auths.Rich.ExtensionLawsNarrow.of_lawful" lean_statement_sha256 = "131876b8431f7e185e96f5249b6329b058bd7a3ad1feac47caa1d72c5921c8a4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [] semantic_source_closure = [ "formal/Auths.lean", @@ -23771,7 +24324,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Rich target-V1 authority semantics over opaque identity carriers and extensional finite sets." residual_assumptions = ["Lean's kernel, the pinned toolchain, the listed foundational axioms, and the theorem premises are trusted."] toolchain_lock_sha256 = "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" @@ -23788,7 +24341,7 @@ claim_text = "The mechanically translated fact-name comparison returns exactly t claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_fact_name_equal_refines_model" lean_statement_sha256 = "6b15e1125bd960ce5bf8c3447e0587ceebd672e592a891b26bc2d5e68a9add5c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::fact_name_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -23850,7 +24403,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "UTF-8 byte comparison of two fact names, bridged to String equality by UTF-8 injectivity." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -23876,7 +24429,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-189" @@ -23884,7 +24437,7 @@ claim_text = "The mechanically translated freshness predicate returns exactly th claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_fresh_refines_model" lean_statement_sha256 = "3db4557c386de7ea8812abdf9a330bc6a96432ce30daf16df94c060958d2673a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::observation_fresh"] semantic_source_closure = [ "formal/Auths.lean", @@ -23946,7 +24499,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The guarded u64 age subtraction, maximum age, and anchor validity window, for every u64 input." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -23972,7 +24525,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-190" @@ -23980,7 +24533,7 @@ claim_text = "The mechanically translated exact-subject comparison returns exact claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_subject_equal_refines_model" lean_statement_sha256 = "9b0aec23b54259d75ed186dbc7ef48d9e63bd0552e0a669478e2c95434501da4" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::observation_subject_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -24042,7 +24595,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "UTF-8 byte comparison of the expected and observed resource, bridged to String equality." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24068,7 +24621,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-191" @@ -24076,7 +24629,7 @@ claim_text = "The mechanically translated fact-value comparison returns exactly claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_fact_value_equal_refines_model" lean_statement_sha256 = "c2e5d55a276fda45f44996688fa2ce37eba6a02c4af677e93f0438495cee4112" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::fact_value_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -24138,7 +24691,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Unsigned, byte-string, and text fact values, including every cross-type pair." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24164,7 +24717,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-192" @@ -24172,7 +24725,7 @@ claim_text = "The mechanically translated inclusive range test returns exactly t claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_uint_range_contains_refines_model" lean_statement_sha256 = "a62d865cc0aed16965c3f48786e28f4eb056e75a8af68ea1b68a97d40dfcd81a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::uint_range_contains"] semantic_source_closure = [ "formal/Auths.lean", @@ -24234,7 +24787,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The inclusive u64 range test on an observed unsigned value." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24259,7 +24812,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-193" @@ -24267,7 +24820,7 @@ claim_text = "The mechanically translated membership loop returns exactly the mo claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_member_values_contain_refines_model" lean_statement_sha256 = "1a823612cdb0ab8b1dfa2561f4563a452c907691b7412a258ffee9c2538693e6" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::member_values_contain", "auths_model::observation::fact_value_equal", @@ -24332,7 +24885,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of a finite literal list for an observed fact value." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24358,7 +24911,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-194" @@ -24366,7 +24919,7 @@ claim_text = "The mechanically translated fact lookup returns a value whose abst claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_fact_refines_model" lean_statement_sha256 = "5f566de2f5bf7018c2f9a683d466d8bcc99d1bc88bd19f0467efb34fe40b1bfa" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_fact", "auths_model::observation::fact_name_equal", @@ -24431,7 +24984,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating first-match scan of an observation's facts by name." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24457,7 +25010,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-195" @@ -24465,7 +25018,7 @@ claim_text = "The mechanically translated condition-atom evaluator returns exact claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_condition_value_holds_refines_model" lean_statement_sha256 = "87c518e6cd6ddd3ab66a1acf9cb01dd6a8ed729895310f6dd6b0f36c871be3ed" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::condition_value_holds", "auths_model::observation::fact_value_equal", @@ -24532,7 +25085,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "All four condition atoms against a present or absent observed value and a present or absent action value." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24558,7 +25111,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-196" @@ -24566,7 +25119,7 @@ claim_text = "The mechanically translated named-condition evaluator returns exac claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_condition_holds_refines_model" lean_statement_sha256 = "d5df152ab006c6eccea9e9e1d19a4b2bf4643f4a6629d2f0a89a5b9a3759ea72" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_condition_holds", "auths_model::observation::observation_fact", @@ -24636,7 +25189,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "One named condition over an observation's facts with its supplied action value." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24662,7 +25215,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-197" @@ -24670,7 +25223,7 @@ claim_text = "The mechanically translated condition conjunction returns exactly claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_hold_refines_model" lean_statement_sha256 = "1693b5b82975dde2606b046c58afddf01ef58c6c6c4f973a1b0528dc99132810" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_conditions_hold", "auths_model::observation::observation_condition_holds", @@ -24741,7 +25294,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating conjunction loop over a condition slice and a parallel action-value slice." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24767,7 +25320,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-198" @@ -24775,7 +25328,7 @@ claim_text = "The mechanically translated condition conjunction rejects a condit claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_length_mismatch_fails_closed" lean_statement_sha256 = "4ff3b4c45f16ea6a3db0d4e48e54202e20f11ce220a3fee37d426a5f55616eba" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::observation_conditions_hold"] semantic_source_closure = [ "formal/Auths.lean", @@ -24837,7 +25390,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The length guard that precedes every condition evaluation." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24863,7 +25416,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-199" @@ -24871,7 +25424,7 @@ claim_text = "With action values drawn from the environment, the mechanically tr claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_hold_refines_conditions_hold" lean_statement_sha256 = "4d030ad8523e9b4e7031109a2d67e482fbb681b9424036d53496178523be7493" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_conditions_hold", "auths_model::observation::observation_condition_holds", @@ -24942,7 +25495,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The conjunction loop when each eqAction condition's supplied action value is the environment's action fact for its reference." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -24968,7 +25521,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-200" @@ -24976,7 +25529,7 @@ claim_text = "The mechanically translated verdict combinator returns exactly the claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_requirement_verdict_refines_model" lean_statement_sha256 = "3ca419beb07857d75b92c8fb57b48431a8db672f27ec1ac81c8a112a920b40d0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::requirement_verdict"] semantic_source_closure = [ "formal/Auths.lean", @@ -25038,7 +25591,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Satisfied before denied before indeterminate, for every pair of eligibility and satisfaction inputs." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25063,7 +25616,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-201" @@ -25071,7 +25624,7 @@ claim_text = "When every referenced action fact is available, the mechanically t claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_requirement_verdict_refines_requirement_decision" lean_statement_sha256 = "52a0068811cc19be5605093531410d061f617ca4f3b9a5b1f056d6949077f118" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::requirement_verdict"] semantic_source_closure = [ "formal/Auths.lean", @@ -25133,7 +25686,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The per-requirement verdict when the requirement's action facts are available; unavailable action facts are indeterminate in the model." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25158,7 +25711,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-271" @@ -25166,7 +25719,7 @@ claim_text = "The mechanically translated observer-anchor comparison returns exa claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observer_anchor_id_equal_refines_model" lean_statement_sha256 = "564453fe589aab144b7c4696318d798cb9489197156d1ee8d88cc68ca4efca6d" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::observer_anchor_id_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -25228,7 +25781,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "UTF-8 byte comparison of two observer-anchor identifiers, bridged to String equality." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25254,7 +25807,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-272" @@ -25262,7 +25815,7 @@ claim_text = "The mechanically translated schema comparison returns exactly the claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_schema_equal_refines_model" lean_statement_sha256 = "4b027d678991524961d7103204315cda5f7af4cd88a06f875db770fbfc94bd83" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::observation::observation_schema_equal"] semantic_source_closure = [ "formal/Auths.lean", @@ -25324,7 +25877,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "UTF-8 byte comparison of two observation-schema identifiers, bridged to String equality." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25350,7 +25903,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-273" @@ -25358,7 +25911,7 @@ claim_text = "The mechanically translated subject comparison returns exactly the claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_requirement_subject_equal_refines_model" lean_statement_sha256 = "efbd6e09d1ed52b992044847b3a47c6f7f7bcea46410b284e140355071a4fb2a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::requirement_subject_equal", "auths_model::observation::fact_name_equal", @@ -25423,7 +25976,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Literal-resource and action-fact subjects, including every cross-kind pair." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25449,7 +26002,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-274" @@ -25457,7 +26010,7 @@ claim_text = "The mechanically translated membership-list comparison returns exa claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_member_values_equal_refines_model" lean_statement_sha256 = "5c5ad163115e51cbe1d70ccb962047e73e69ff7fa94111d0187ce2429a83d0bb" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::member_values_equal", "auths_model::observation::fact_value_equal", @@ -25522,7 +26075,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The length guard and the terminating positional loop over two finite literal lists." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25548,7 +26101,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-275" @@ -25556,7 +26109,7 @@ claim_text = "The mechanically translated condition-atom comparison returns exac claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_condition_test_equal_refines_model" lean_statement_sha256 = "e3c6bf03b6853dbedee9fb11e2a4c93c599b64f24f59ae7a13cf742af8c07df3" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::condition_test_equal", "auths_model::observation::fact_value_equal", @@ -25623,7 +26176,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "All four condition atoms, including every cross-atom pair." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25649,7 +26202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-276" @@ -25657,7 +26210,7 @@ claim_text = "The mechanically translated condition comparison returns exactly t claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_condition_equal_refines_model" lean_statement_sha256 = "44b638fa8228688cc4f4d77ad87bd9fbaf9a9b2eb037cb846e62d8caa6611447" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_condition_equal", "auths_model::observation::fact_name_equal", @@ -25723,7 +26276,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The fact name and the condition atom of two named conditions." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25749,7 +26302,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-277" @@ -25757,7 +26310,7 @@ claim_text = "The mechanically translated containment loop returns exactly the m claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_contain_refines_model" lean_statement_sha256 = "688fb6edaf3b5e37be4d7823f1fc273e24a61e7299d2ef3eb0ef9b877159c9b2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_conditions_contain", "auths_model::observation::observation_condition_equal", @@ -25822,7 +26375,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of a condition slice for one condition." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25848,7 +26401,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-278" @@ -25856,7 +26409,7 @@ claim_text = "The mechanically translated inclusion loop returns exactly the mod claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_include_refines_model" lean_statement_sha256 = "96280dce9a82d09c459e502cdd7dc12f413aedb86d6846eeee90627795910722" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_conditions_include", "auths_model::observation::observation_conditions_contain", @@ -25922,7 +26475,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every atom of the wider slice occurring in the narrower slice, compared as a set of canonical atoms." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -25948,7 +26501,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-279" @@ -25956,7 +26509,7 @@ claim_text = "The mechanically translated condition-list comparison returns exac claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_conditions_equal_refines_model" lean_statement_sha256 = "a235b885de3a11bd2db81a9b91c30f0a03082254b03dbb20cc561af3fb304eff" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_conditions_equal", "auths_model::observation::observation_condition_equal", @@ -26021,7 +26574,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The length guard and the terminating positional loop over two condition slices." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26047,7 +26600,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-280" @@ -26055,7 +26608,7 @@ claim_text = "The mechanically translated same-target check returns exactly the claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirement_same_target_refines_model" lean_statement_sha256 = "b79e3eaa4bb4270a1d44d9c62d457e4b3e396250ac36588a79068cd2d513e84b" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirement_same_target", "auths_model::observation::observer_anchor_id_equal", @@ -26122,7 +26675,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The observer anchor, schema, and subject of two requirements." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26148,7 +26701,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-281" @@ -26156,7 +26709,7 @@ claim_text = "The mechanically translated requirement comparison returns exactly claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirement_equal_refines_model" lean_statement_sha256 = "f78c2bb3bae9cdc9b1fb76d183c691737066bcc4ee4781fac6b82b335bba184c" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirement_equal", "auths_model::observation::observation_requirement_same_target", @@ -26222,7 +26775,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The target, the u64 maximum age, and the positional condition list of two requirements." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26248,7 +26801,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-282" @@ -26256,7 +26809,7 @@ claim_text = "The mechanically translated narrowing check returns exactly the mo claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirement_narrows_refines_model" lean_statement_sha256 = "46ad4c556c162406b17661c87f1e1d246d960a3be471a4441a81012ba12711c1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirement_narrows", "auths_model::observation::observation_requirement_same_target", @@ -26322,7 +26875,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The same target, a maximum age no larger, a superset of condition atoms, and a strictly narrower age or atom set." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26348,7 +26901,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-283" @@ -26356,7 +26909,7 @@ claim_text = "The mechanically translated cover check returns exactly the model' claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirement_covers_refines_model" lean_statement_sha256 = "9cbb882a6b66b35880cbb5fbb594262a8d665894b107bc8681332665bc3efc21" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirement_covers", "auths_model::observation::observation_requirement_equal", @@ -26422,7 +26975,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "An identical requirement or a strict narrowing." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26448,7 +27001,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-284" @@ -26456,7 +27009,7 @@ claim_text = "The mechanically translated retention loop returns exactly the mod claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirement_retained_refines_model" lean_statement_sha256 = "db23559560127b12376f178ce5a707aead02785eb5451e8aea0616a02d40e4a2" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirement_retained", "auths_model::observation::observation_requirement_covers", @@ -26521,7 +27074,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of a child requirement list for one parent requirement." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26547,7 +27100,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-285" @@ -26555,7 +27108,7 @@ claim_text = "The mechanically translated observation-requirement attenuation la claim_status = "qualified" lean_declaration = "Auths.Refinement.Observation.translated_observation_requirements_attenuate_refines_model" lean_statement_sha256 = "e1c90caefc8cea86b905fce1bdaaaf489a1f64bcb46e2d9645a41268a45dd683" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::observation::observation_requirements_attenuate", "auths_model::observation::observation_requirement_retained", @@ -26623,7 +27176,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every parent requirement covered by some child requirement, over requirement lists of any length." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared text fits the u32 UTF-8 byte bound) are trusted.", @@ -26649,7 +27202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-306" @@ -26657,7 +27210,7 @@ claim_text = "The mechanically translated approver verdict returns exactly the m claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_approver_verdict_refines_model" lean_statement_sha256 = "96a93cb521f7ceee6550abe06fd102d42204467d4c97e1c0b2d19a4175f035c9" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::approval::approver_verdict"] semantic_source_closure = [ "formal/Auths.lean", @@ -26719,7 +27272,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of per-approval outcomes for one approver: counted when some outcome is counted, pending when none is and some is pending, ignored otherwise." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -26745,7 +27298,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-307" @@ -26753,7 +27306,7 @@ claim_text = "The mechanically translated distinct counting returns exactly the claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_approval_counts_refines_model" lean_statement_sha256 = "36686ea58c4b0815ecfc6c85715c734d24d3273b4956ce66d58aaffa2abc5f54" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::approval::approval_counts", "auths_model::approval::approver_verdict", @@ -26818,7 +27371,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating loop over a requirement's listed approvers, each counted once, for every outcome list and every u16 threshold." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -26844,7 +27397,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-308" @@ -26852,7 +27405,7 @@ claim_text = "The mechanically translated principal-list membership returns exac claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_principal_ids_contain_refines_model" lean_statement_sha256 = "9c377995783f05529ff05f6655022584e0f6669d7acdf3ef1e57014e25ee1ec0" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = ["auths_model::approval::principal_ids_contain"] semantic_source_closure = [ "formal/Auths.lean", @@ -26914,7 +27467,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of a principal slice for one principal, compared by UTF-8 bytes bridged to String equality." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -26940,7 +27493,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-309" @@ -26948,7 +27501,7 @@ claim_text = "The mechanically translated principal-list inclusion returns exact claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_principal_ids_subset_refines_model" lean_statement_sha256 = "77c6b790409d4c2e7277d80217281bba70f67e6f21a3a23841c3110dd625f36f" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::approval::principal_ids_subset", "auths_model::approval::principal_ids_contain", @@ -27013,7 +27566,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every principal of the narrower slice occurring in the wider slice." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -27039,7 +27592,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-310" @@ -27047,7 +27600,7 @@ claim_text = "The mechanically translated cover check returns exactly the model' claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_approval_requirement_covers_refines_model" lean_statement_sha256 = "f36b9195ab1f24fad69a6deccc01d1f9895b7803fdf243dd948595f4744f73f7" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::approval::approval_requirement_covers", "auths_model::approval::principal_ids_subset", @@ -27113,7 +27666,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "One child and one parent approval requirement." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -27139,7 +27692,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-311" @@ -27147,7 +27700,7 @@ claim_text = "The mechanically translated retention loop returns exactly the mod claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_approval_requirement_retained_refines_model" lean_statement_sha256 = "3b4e9f2ae9beff66fef142c2ebefc11dd86bd65202950c55914458bff46d6c8a" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::approval::approval_requirement_retained", "auths_model::approval::approval_requirement_covers", @@ -27212,7 +27765,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "The terminating scan of a child requirement list for one parent requirement." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -27238,7 +27791,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" [[claims]] claim_id = "AP-FORMAL-RICH-312" @@ -27246,7 +27799,7 @@ claim_text = "The mechanically translated approval-requirement-v1 attenuation la claim_status = "qualified" lean_declaration = "Auths.Refinement.Approval.translated_approval_requirements_attenuate_refines_model" lean_statement_sha256 = "4eab09e98c4ff9d49768010b51dad1f0e7f5807c9899733a5ead580f7dc797c1" -formal_review = "native-k-of-n-approvals-2026-09-30" +formal_review = "ap074-durable-entry-and-late-evidence-2026-10-29" rust_symbols = [ "auths_model::approval::approval_requirements_attenuate", "auths_model::approval::approval_requirement_retained", @@ -27313,7 +27866,7 @@ semantic_source_closure = [ "formal/qualification/aeneas/generated/model/FunsExternal.lean", "formal/qualification/aeneas/generated/model/Types.lean", ] -semantic_source_closure_sha256 = "a3c4451de61c9b0e5a5e01b2db5e9e428150a5da66adcf2ee7a3e22abdefe986" +semantic_source_closure_sha256 = "d8398eb7a07ecb3faa82380718c7a20af70d26c96cbac7f229b16240fb7f3659" scope = "Every parent requirement covered by some child requirement, over requirement lists of any length." residual_assumptions = [ "Lean's kernel, the pinned Rust/Charon/Aeneas/Lean toolchain, the reviewed transparent external bridges, the listed foundational axioms, and the theorem's explicit representation-validity premises (every compared principal fits the u32 UTF-8 byte bound) are trusted.", @@ -27339,4 +27892,4 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "f2fdfa9bfe3a92173af2ac0da3a376f104c7d87398f9d1806dad13193e578362" +sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" diff --git a/formal/lean-assurance-audit-v1.json b/formal/lean-assurance-audit-v1.json index 0c14778c6..0fcbf11e6 100644 --- a/formal/lean-assurance-audit-v1.json +++ b/formal/lean-assurance-audit-v1.json @@ -1596,7 +1596,43 @@ "kind": "theorem", "module": "Auths.Product.Recovery", "name": "Auths.Product.Recovery.unknown_resolves_only_linked", - "statement": "(∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n old.stage = Auths.Product.Recovery.Stage.unknown →\n new.stage = Auths.Product.Recovery.Stage.observedByProvider ∧\n old.link = Auths.Product.Recovery.Link.verified ∧\n new.link = Auths.Product.Recovery.Link.verified ∧ new.evidence = true) ∧\n (∀ (views : List Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validChain views →\n ∀ (index : ℕ) (bound : index + 1 < views.length),\n views[index].stage = Auths.Product.Recovery.Stage.unknown →\n views[index + 1].stage = Auths.Product.Recovery.Stage.observedByProvider ∧\n views[index + 1].link = Auths.Product.Recovery.Link.verified ∧ views[index + 1].evidence = true) ∧\n ∀ (declarations : Auths.Product.Recovery.Declarations),\n Auths.Product.Recovery.linkOf (Auths.Product.Recovery.capability declarations).providerLink =\n Auths.Product.Recovery.Link.verified ↔\n (Auths.Product.Recovery.capability declarations).recoveryClass = Auths.Product.Recovery.RecoveryClass.linked" + "statement": "(∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n old.stage = Auths.Product.Recovery.Stage.unknown →\n new.stage = Auths.Product.Recovery.Stage.observedByProvider →\n old.link = Auths.Product.Recovery.Link.verified ∧\n new.link = Auths.Product.Recovery.Link.verified ∧ new.evidence = true) ∧\n (∀ (views : List Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validChain views →\n ∀ (index : ℕ) (bound : index + 1 < views.length),\n views[index].stage = Auths.Product.Recovery.Stage.unknown →\n views[index + 1].stage = Auths.Product.Recovery.Stage.observedByProvider →\n views[index + 1].link = Auths.Product.Recovery.Link.verified ∧ views[index + 1].evidence = true) ∧\n ∀ (declarations : Auths.Product.Recovery.Declarations),\n Auths.Product.Recovery.linkOf (Auths.Product.Recovery.capability declarations).providerLink =\n Auths.Product.Recovery.Link.verified ↔\n (Auths.Product.Recovery.capability declarations).recoveryClass = Auths.Product.Recovery.RecoveryClass.linked" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.Recovery", + "name": "Auths.Product.Recovery.unknown_exits_with_bound_evidence", + "statement": "∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n old.stage = Auths.Product.Recovery.Stage.unknown →\n new.stage = Auths.Product.Recovery.Stage.responseRecorded ∨\n new.stage = Auths.Product.Recovery.Stage.acknowledged ∨\n new.stage = Auths.Product.Recovery.Stage.observedByProvider ∧ old.link = Auths.Product.Recovery.Link.verified" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.Recovery", + "name": "Auths.Product.Recovery.transition_ownership", + "statement": "∀ {old new : Auths.Product.Recovery.AttemptView},\n Auths.Product.Recovery.validTransition old new = true →\n new.protocol = old.protocol ∧\n new.revision = old.revision + 1 ∧ new.revision ≤ 9007199254740991 ∧ (old.entry ≠ [] → new.entry = old.entry)" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.Recovery", + "name": "Auths.Product.Recovery.late_response_retains_source", + "statement": "∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n old.stage = Auths.Product.Recovery.Stage.unknown →\n new.stage = Auths.Product.Recovery.Stage.responseRecorded →\n new.protocol = old.protocol ∧\n new.revision = old.revision + 1 ∧\n new.entry = old.entry ∧ old.entry ≠ [] ∧ new.response ≠ [] ∧ new.evidence = false ∧ new.acknowledgement = []" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.Recovery", + "name": "Auths.Product.Recovery.late_acknowledgement_retains_source", + "statement": "∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n old.stage = Auths.Product.Recovery.Stage.unknown →\n new.stage = Auths.Product.Recovery.Stage.acknowledged →\n old.protocol = Auths.Product.Recovery.Protocol.disclosure ∧\n new.protocol = Auths.Product.Recovery.Protocol.disclosure ∧\n new.revision = old.revision + 1 ∧\n new.entry = old.entry ∧\n old.entry ≠ [] ∧ new.acknowledgement ≠ [] ∧ new.response = [] ∧ new.evidence = false" }, { "axioms": [ @@ -1607,7 +1643,7 @@ "kind": "theorem", "module": "Auths.Product.Recovery", "name": "Auths.Product.Recovery.provider_claim_requires_evidence", - "statement": "(∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n new.stage = Auths.Product.Recovery.Stage.observedByProvider →\n new.evidence = true ∧\n Auths.Product.Recovery.hasLink new.link = true ∧\n new.link = old.link ∧\n (old.stage = Auths.Product.Recovery.Stage.responseRecorded ∨\n (old.stage = Auths.Product.Recovery.Stage.attempting ∨\n old.stage = Auths.Product.Recovery.Stage.unknown) ∧\n old.link = Auths.Product.Recovery.Link.verified)) ∧\n ∀ (first : Auths.Product.Recovery.AttemptView) (rest : List Auths.Product.Recovery.AttemptView),\n first.stage = Auths.Product.Recovery.Stage.attempting →\n Auths.Product.Recovery.consistent first = true →\n Auths.Product.Recovery.validChain (first :: rest) →\n ∀ (index : ℕ) (bound : index < rest.length),\n rest[index].stage = Auths.Product.Recovery.Stage.observedByProvider →\n rest[index].evidence = true ∧\n rest[index].link = first.link ∧\n Auths.Product.Recovery.hasLink first.link = true ∧\n ((first :: rest)[index].stage = Auths.Product.Recovery.Stage.responseRecorded ∨\n ((first :: rest)[index].stage = Auths.Product.Recovery.Stage.attempting ∨\n (first :: rest)[index].stage = Auths.Product.Recovery.Stage.unknown) ∧\n first.link = Auths.Product.Recovery.Link.verified)" + "statement": "(∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validTransition old new = true →\n new.stage = Auths.Product.Recovery.Stage.observedByProvider →\n new.evidence = true ∧\n Auths.Product.Recovery.hasLink new.link = true ∧\n new.link = old.link ∧\n (old.stage = Auths.Product.Recovery.Stage.responseRecorded ∨\n (old.stage = Auths.Product.Recovery.Stage.entryGranted ∨\n old.stage = Auths.Product.Recovery.Stage.unknown) ∧\n old.link = Auths.Product.Recovery.Link.verified)) ∧\n ∀ (first : Auths.Product.Recovery.AttemptView) (rest : List Auths.Product.Recovery.AttemptView),\n first.stage = Auths.Product.Recovery.Stage.reserved →\n Auths.Product.Recovery.consistent first = true →\n Auths.Product.Recovery.validChain (first :: rest) →\n ∀ (index : ℕ) (bound : index < rest.length),\n rest[index].stage = Auths.Product.Recovery.Stage.observedByProvider →\n rest[index].evidence = true ∧\n rest[index].link = first.link ∧\n Auths.Product.Recovery.hasLink first.link = true ∧\n ((first :: rest)[index].stage = Auths.Product.Recovery.Stage.responseRecorded ∨\n ((first :: rest)[index].stage = Auths.Product.Recovery.Stage.entryGranted ∨\n (first :: rest)[index].stage = Auths.Product.Recovery.Stage.unknown) ∧\n first.link = Auths.Product.Recovery.Link.verified)" }, { "axioms": [ @@ -1617,7 +1653,7 @@ "kind": "theorem", "module": "Auths.Product.Recovery", "name": "Auths.Product.Recovery.terminal_stages_final", - "statement": "(∀ (stage : Auths.Product.Recovery.Stage),\n Auths.Product.Recovery.terminalStage stage = true ↔\n stage = Auths.Product.Recovery.Stage.notEntered ∨\n stage = Auths.Product.Recovery.Stage.observed ∨ stage = Auths.Product.Recovery.Stage.observedByProvider) ∧\n (∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.terminalStage old.stage = true → Auths.Product.Recovery.validTransition old new = false) ∧\n ∀ (views : List Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validChain views →\n ∀ (index : ℕ) (bound : index < views.length),\n Auths.Product.Recovery.terminalStage views[index].stage = true → index + 1 = views.length" + "statement": "(∀ (stage : Auths.Product.Recovery.Stage),\n Auths.Product.Recovery.terminalStage stage = true ↔\n stage = Auths.Product.Recovery.Stage.notEntered ∨\n stage = Auths.Product.Recovery.Stage.observed ∨\n stage = Auths.Product.Recovery.Stage.observedByProvider ∨ stage = Auths.Product.Recovery.Stage.acknowledged) ∧\n (∀ (old new : Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.terminalStage old.stage = true → Auths.Product.Recovery.validTransition old new = false) ∧\n ∀ (views : List Auths.Product.Recovery.AttemptView),\n Auths.Product.Recovery.validChain views →\n ∀ (index : ℕ) (bound : index < views.length),\n Auths.Product.Recovery.terminalStage views[index].stage = true → index + 1 = views.length" }, { "axioms": [ @@ -1638,7 +1674,7 @@ "kind": "theorem", "module": "Auths.Product.SubmitOrder", "name": "Auths.Product.SubmitOrder.lease_requires_verified_claim", - "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event) (mode : Auths.Product.SubmitOrder.Mode),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.lease mode →\n event = Auths.Product.SubmitOrder.Event.reload true ∧\n (Auths.Product.SubmitOrder.stateAfter plan pre).phase = Auths.Product.SubmitOrder.Phase.reload mode ∧\n (∃ argument, Auths.Product.SubmitOrder.Verified (Auths.Product.SubmitOrder.steps plan pre) argument) ∧\n (mode = Auths.Product.SubmitOrder.Mode.reobserve →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.replay)) ∧\n (mode ≠ Auths.Product.SubmitOrder.Mode.reobserve →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.inserted))" + "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.lease →\n event = Auths.Product.SubmitOrder.Event.reload true ∧\n (Auths.Product.SubmitOrder.stateAfter plan pre).phase = Auths.Product.SubmitOrder.Phase.reload ∧\n (∃ argument, Auths.Product.SubmitOrder.Verified (Auths.Product.SubmitOrder.steps plan pre) argument) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.reserved)" }, { "axioms": [ @@ -1648,7 +1684,7 @@ "kind": "theorem", "module": "Auths.Product.SubmitOrder", "name": "Auths.Product.SubmitOrder.send_requires_lease_and_deadline", - "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.send →\n event = Auths.Product.SubmitOrder.Event.deadline true ∧\n (Auths.Product.SubmitOrder.stateAfter plan pre).phase = Auths.Product.SubmitOrder.Phase.deadline ∧\n (∃ argument, Auths.Product.SubmitOrder.Verified (Auths.Product.SubmitOrder.steps plan pre) argument) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.inserted) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n (Auths.Product.SubmitOrder.Phase.lease Auths.Product.SubmitOrder.Mode.entry)\n (Auths.Product.SubmitOrder.Event.lease true) ∧\n (plan.preEntry = true →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.preEntry\n (Auths.Product.SubmitOrder.Event.preEntry Auths.Product.SubmitOrder.PreEntryResult.satisfied)) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.entryReload (Auths.Product.SubmitOrder.Event.reload true)" + "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.send →\n event = Auths.Product.SubmitOrder.Event.granted true ∧\n (Auths.Product.SubmitOrder.stateAfter plan pre).phase = Auths.Product.SubmitOrder.Phase.grant ∧\n (∃ argument, Auths.Product.SubmitOrder.Verified (Auths.Product.SubmitOrder.steps plan pre) argument) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.reserved) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.lease (Auths.Product.SubmitOrder.Event.lease true) ∧\n (plan.preEntry = true →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.preEntry\n (Auths.Product.SubmitOrder.Event.preEntry Auths.Product.SubmitOrder.PreEntryResult.satisfied)) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.entryReload (Auths.Product.SubmitOrder.Event.reload true) ∧\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.deadline (Auths.Product.SubmitOrder.Event.deadline true)" }, { "axioms": [ @@ -1658,7 +1694,7 @@ "kind": "theorem", "module": "Auths.Product.SubmitOrder", "name": "Auths.Product.SubmitOrder.send_requires_credential_checks", - "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.send →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n (Auths.Product.SubmitOrder.Phase.prefixGuard Auths.Product.SubmitOrder.Mode.entry)\n (Auths.Product.SubmitOrder.Event.prefixGuard true) ∧\n (plan.accountRead = true →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n (Auths.Product.SubmitOrder.Phase.account Auths.Product.SubmitOrder.Mode.entry)\n (Auths.Product.SubmitOrder.Event.account Auths.Product.SubmitOrder.AccountResult.equal)) ∧\n ∀ index < plan.deniedReads,\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n (Auths.Product.SubmitOrder.Phase.denied Auths.Product.SubmitOrder.Mode.entry index)\n (Auths.Product.SubmitOrder.Event.denied Auths.Product.SubmitOrder.DeniedResult.refused)" + "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event),\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.send →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.prefixGuard (Auths.Product.SubmitOrder.Event.prefixGuard true) ∧\n (plan.accountRead = true →\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.account\n (Auths.Product.SubmitOrder.Event.account Auths.Product.SubmitOrder.AccountResult.equal)) ∧\n ∀ index < plan.deniedReads,\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n (Auths.Product.SubmitOrder.Phase.denied index)\n (Auths.Product.SubmitOrder.Event.denied Auths.Product.SubmitOrder.DeniedResult.refused)" }, { "axioms": [ @@ -1690,6 +1726,33 @@ "name": "Auths.Product.SubmitOrder.at_most_one_send", "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (events : List Auths.Product.SubmitOrder.Event),\n List.count Auths.Product.SubmitOrder.Action.send\n (List.map Auths.Product.SubmitOrder.Step.action (Auths.Product.SubmitOrder.steps plan events)) ≤\n 1 ∧\n (Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan events)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.replay) →\n ¬Auths.Product.SubmitOrder.Emitted (Auths.Product.SubmitOrder.steps plan events)\n Auths.Product.SubmitOrder.Action.send)" }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.SubmitOrder", + "name": "Auths.Product.SubmitOrder.response_stops_without_read", + "statement": "∀ (state : Auths.Product.SubmitOrder.State),\n state.phase = Auths.Product.SubmitOrder.Phase.recordResponse →\n Auths.Product.SubmitOrder.nextStep state\n (Auths.Product.SubmitOrder.Event.response Auths.Product.SubmitOrder.ResponseRecord.recorded) =\n Auths.Product.SubmitOrder.stop state Auths.Product.SubmitOrder.Stop.response" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.SubmitOrder", + "name": "Auths.Product.SubmitOrder.replay_returns_stored", + "statement": "∀ (state : Auths.Product.SubmitOrder.State),\n state.phase = Auths.Product.SubmitOrder.Phase.claim →\n Auths.Product.SubmitOrder.nextStep state\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.replay) =\n Auths.Product.SubmitOrder.stop state Auths.Product.SubmitOrder.Stop.stored" + }, + { + "axioms": [ + "propext" + ], + "kind": "theorem", + "module": "Auths.Product.SubmitOrder", + "name": "Auths.Product.SubmitOrder.refused_grant_stops_without_send", + "statement": "∀ (state : Auths.Product.SubmitOrder.State),\n state.phase = Auths.Product.SubmitOrder.Phase.grant →\n Auths.Product.SubmitOrder.nextStep state (Auths.Product.SubmitOrder.Event.granted false) =\n Auths.Product.SubmitOrder.stop state Auths.Product.SubmitOrder.Stop.grantUnavailable" + }, { "axioms": [ "propext", @@ -1718,7 +1781,7 @@ "kind": "theorem", "module": "Auths.Product.SubmitOrder", "name": "Auths.Product.SubmitOrder.post_claim_refusal_records_not_entered", - "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event) (refusal : Auths.Product.SubmitOrder.Refusal),\n ((Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.recordNotEntered refusal ↔\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.inserted) ∧\n Auths.Product.SubmitOrder.refusalOf (Auths.Product.SubmitOrder.stateAfter plan pre) event = some refusal) ∧\n ((Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.recordNotEntered refusal →\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).state.phase =\n Auths.Product.SubmitOrder.Phase.recordNotEntered ∧\n (Auths.Product.SubmitOrder.Emitted (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Action.send →\n refusal = Auths.Product.SubmitOrder.Refusal.transportNotEntered))" + "statement": "∀ (plan : Auths.Product.SubmitOrder.Plan) (pre : List Auths.Product.SubmitOrder.Event)\n (event : Auths.Product.SubmitOrder.Event) (refusal : Auths.Product.SubmitOrder.Refusal),\n ((Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.recordNotEntered refusal ↔\n Auths.Product.SubmitOrder.Answered (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Phase.claim\n (Auths.Product.SubmitOrder.Event.claim Auths.Product.SubmitOrder.ClaimResult.reserved) ∧\n Auths.Product.SubmitOrder.refusalOf (Auths.Product.SubmitOrder.stateAfter plan pre) event = some refusal) ∧\n ((Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).action =\n Auths.Product.SubmitOrder.Action.recordNotEntered refusal →\n (Auths.Product.SubmitOrder.nextStep (Auths.Product.SubmitOrder.stateAfter plan pre) event).state.phase =\n Auths.Product.SubmitOrder.Phase.recordNotEntered ∧\n ¬Auths.Product.SubmitOrder.Emitted (Auths.Product.SubmitOrder.steps plan pre)\n Auths.Product.SubmitOrder.Action.send)" }, { "axioms": [ diff --git a/formal/proof-coverage-functions-v1.tsv b/formal/proof-coverage-functions-v1.tsv index 9e3656230..b91ad42c2 100644 --- a/formal/proof-coverage-functions-v1.tsv +++ b/formal/proof-coverage-functions-v1.tsv @@ -1205,49 +1205,53 @@ product/runtime/auths-connections/src/credential.rs 145 147 3 StoredSecretLease: product/runtime/auths-connections/src/credential.rs 182 187 6 CredentialStoreKind::parse product/runtime/auths-connections decision 0 0 0 0 0 0 product/runtime/auths-connections/src/credential.rs 191 196 6 CredentialStoreKind::as_str product/runtime/auths-connections decision 0 0 0 0 0 0 product/runtime/auths-connections/src/credential.rs 201 206 6 CredentialStoreKind::is_production product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 320 325 6 StoredSecret::holds product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 334 343 10 InMemoryCredentialStore::new product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 345 347 3 InMemoryCredentialStore::total_bytes product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 352 382 31 InMemoryCredentialStore::install product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 384 398 15 InMemoryCredentialStore::lease_secret product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 400 441 42 InMemoryCredentialStore::replace product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 443 455 13 InMemoryCredentialStore::revoke product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 457 463 7 InMemoryCredentialStore::holds product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 465 503 39 InMemoryCredentialStore::confirm product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 505 520 16 InMemoryCredentialStore::retire_superseded product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 522 534 13 InMemoryCredentialStore::delete_connection product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 560 566 7 PersistentCredentialStore::open product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 574 603 30 PersistentCredentialStore::open_with_limits product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 605 620 16 PersistentCredentialStore::mutate product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 622 624 3 PersistentCredentialStore::total_bytes product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 639 651 13 PersistentCredentialStore::retained_commitment product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 660 671 12 PersistentCredentialStore::stored_generations product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 687 701 15 PersistentCredentialStore::lease_for_record product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 709 718 10 PersistentCredentialStore::holds_record_credential product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 738 774 37 PersistentCredentialStore::store_confirmed product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 790 795 6 PersistentCredentialStore::revoke_connection product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 812 837 26 PersistentCredentialStore::retain_generations product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 839 860 22 PersistentCredentialStore::delete_generations product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 865 875 11 retained_entry product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 883 903 21 binding_entry product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 907 930 24 record_entry product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 932 940 9 connection_generations product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 944 972 29 PersistentCredentialStore::install product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 974 988 15 PersistentCredentialStore::lease_secret product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 990 1034 45 PersistentCredentialStore::replace product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1036 1047 11 PersistentCredentialStore::revoke product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1049 1055 7 PersistentCredentialStore::holds product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1057 1069 13 PersistentCredentialStore::confirm product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1071 1084 14 PersistentCredentialStore::retire_superseded product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1086 1092 7 PersistentCredentialStore::delete_connection product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1095 1108 14 validate_parent product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1110 1125 16 validate_secret_file product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1127 1158 32 persist_entries product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1163 1174 12 encode_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1176 1198 23 write_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1206 1209 4 EncodedLength::write_all product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1212 1306 95 decode_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 -product/runtime/auths-connections/src/credential.rs 1337 1348 12 credential_commitment product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 322 327 6 StoredSecret::holds product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 336 345 10 InMemoryCredentialStore::new product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 347 349 3 InMemoryCredentialStore::total_bytes product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 354 384 31 InMemoryCredentialStore::install product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 386 400 15 InMemoryCredentialStore::lease_secret product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 402 443 42 InMemoryCredentialStore::replace product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 445 457 13 InMemoryCredentialStore::revoke product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 459 465 7 InMemoryCredentialStore::holds product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 467 505 39 InMemoryCredentialStore::confirm product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 507 522 16 InMemoryCredentialStore::retire_superseded product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 524 536 13 InMemoryCredentialStore::delete_connection product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 565 571 7 PersistentCredentialStore::open product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 579 605 27 PersistentCredentialStore::open_with_limits product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 607 624 18 PersistentCredentialStore::mutate product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 629 673 45 PersistentCredentialStore::writer_lock product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 675 688 14 PersistentCredentialStore::refresh product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 690 698 9 PersistentCredentialStore::current_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 700 702 3 PersistentCredentialStore::total_bytes product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 717 726 10 PersistentCredentialStore::retained_commitment product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 735 743 9 PersistentCredentialStore::stored_generations product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 759 770 12 PersistentCredentialStore::lease_for_record product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 778 784 7 PersistentCredentialStore::holds_record_credential product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 804 840 37 PersistentCredentialStore::store_confirmed product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 856 861 6 PersistentCredentialStore::revoke_connection product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 878 903 26 PersistentCredentialStore::retain_generations product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 905 926 22 PersistentCredentialStore::delete_generations product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 931 941 11 retained_entry product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 949 969 21 binding_entry product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 973 996 24 record_entry product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 998 1006 9 connection_generations product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1010 1038 29 PersistentCredentialStore::install product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1040 1051 12 PersistentCredentialStore::lease_secret product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1053 1097 45 PersistentCredentialStore::replace product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1099 1110 11 PersistentCredentialStore::revoke product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1112 1115 4 PersistentCredentialStore::holds product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1117 1129 13 PersistentCredentialStore::confirm product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1131 1144 14 PersistentCredentialStore::retire_superseded product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1146 1152 7 PersistentCredentialStore::delete_connection product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1155 1168 14 validate_parent product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1170 1185 16 validate_secret_file product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1187 1216 29 read_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1218 1249 32 persist_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1254 1265 12 encode_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1267 1289 23 write_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1297 1300 4 EncodedLength::write_all product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1303 1397 95 decode_persistent_entries product/runtime/auths-connections decision 0 0 0 0 0 0 +product/runtime/auths-connections/src/credential.rs 1428 1439 12 credential_commitment product/runtime/auths-connections decision 0 0 0 0 0 0 product/runtime/auths-connections/src/kernel.rs 29 31 3 next_generation product/runtime/auths-connections decision 0 0 1 1 1 1 product/runtime/auths-connections/src/kernel.rs 36 44 9 state_change product/runtime/auths-connections decision 0 0 1 1 1 1 product/runtime/auths-connections/src/kernel.rs 49 57 9 rotation product/runtime/auths-connections decision 0 0 1 1 1 1 @@ -1385,62 +1389,66 @@ product/runtime/auths-gateway-kernel/src/construct.rs 780 804 25 build_body prod product/runtime/auths-gateway-kernel/src/construct.rs 812 833 22 construct_write product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 product/runtime/auths-gateway-kernel/src/construct.rs 840 852 13 construct_action_read product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 product/runtime/auths-gateway-kernel/src/construct.rs 858 865 8 construct_credential_read product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 -product/runtime/auths-gateway-kernel/src/order.rs 387 393 7 start product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 -product/runtime/auths-gateway-kernel/src/order.rs 397 406 10 go product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 410 412 3 stop product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 416 418 3 halt product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 422 428 7 not_entered product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 433 439 7 lease_failed product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 445 451 7 after_reads product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 455 461 7 ceiling_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 465 471 7 pre_entry_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 476 483 8 after_credentials product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 487 497 11 denied_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 501 507 7 after_prefix product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 511 517 7 after_admission product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 521 527 7 pre_claim product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 531 542 12 after_claim product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 546 556 11 after_account product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 560 577 18 after_denied product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 581 587 7 after_pre_entry product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 592 605 14 after_ceiling product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 609 615 7 after_write product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 619 634 16 after_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 638 648 11 after_read_back product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 653 705 53 pre_claim_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 710 766 57 lease_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 772 840 69 entry_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/order.rs 846 873 28 next_step product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 -product/runtime/auths-gateway-kernel/src/outcome.rs 48 57 10 outcome_stage product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 -product/runtime/auths-gateway-kernel/src/outcome.rs 67 76 10 outcome_facts_present product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 +product/runtime/auths-gateway-kernel/src/order.rs 367 373 7 start product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 +product/runtime/auths-gateway-kernel/src/order.rs 377 386 10 go product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 390 392 3 stop product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 396 398 3 halt product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 402 408 7 not_entered product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 414 420 7 after_reads product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 424 430 7 ceiling_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 434 440 7 pre_entry_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 444 450 7 denied_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 454 460 7 after_prefix product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 464 470 7 after_admission product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 474 480 7 pre_claim product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 484 491 8 after_claim product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 495 501 7 after_account product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 505 517 13 after_denied product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 521 527 7 after_pre_entry product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 532 545 14 after_ceiling product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 549 554 6 after_write product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 558 563 6 after_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 568 620 53 pre_claim_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 625 667 43 lease_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 673 742 70 entry_step product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/order.rs 748 772 25 next_step product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 +product/runtime/auths-gateway-kernel/src/outcome.rs 48 58 11 outcome_stage product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 +product/runtime/auths-gateway-kernel/src/outcome.rs 68 77 10 outcome_facts_present product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 product/runtime/auths-gateway-kernel/src/ratio.rs 16 27 12 relative_basis product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 product/runtime/auths-gateway-kernel/src/ratio.rs 35 39 5 relative_ceiling_admits product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 product/runtime/auths-gateway-kernel/src/recovery.rs 98 104 7 provider_link product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 product/runtime/auths-gateway-kernel/src/recovery.rs 108 122 15 recovery_class product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 product/runtime/auths-gateway-kernel/src/recovery.rs 126 133 8 unknown_resolution product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 product/runtime/auths-gateway-kernel/src/recovery.rs 139 151 13 recovery_capability product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 -product/runtime/auths-gateway-kernel/src/transition.rs 89 91 3 absent product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 95 104 10 same_bytes_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 108 114 7 same_bytes product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 119 124 6 resolves_unknown product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 128 133 6 has_link product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 137 146 10 refusal_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 150 155 6 requires_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 159 164 6 permits_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 168 177 10 observed_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 181 190 10 provider_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 194 199 6 terminal_stage product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 -product/runtime/auths-gateway-kernel/src/transition.rs 203 208 6 has_reading product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 217 228 12 consistent product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 235 260 26 stage_transition_allowed product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 265 280 16 adds_pre_entry product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 284 300 17 adds_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 305 321 17 checkpoint_valid product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 326 332 7 pre_entry_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 337 340 4 response_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 344 346 3 plan_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 350 365 16 link_equal product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 -product/runtime/auths-gateway-kernel/src/transition.rs 373 381 9 valid_transition product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 +product/runtime/auths-gateway-kernel/src/transition.rs 113 115 3 absent product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 119 128 10 same_bytes_from product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 132 138 7 same_bytes product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 143 148 6 resolves_unknown product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 152 157 6 has_link product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 161 172 12 refusal_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 176 186 11 requires_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 190 199 10 permits_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 203 214 12 observed_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 218 229 12 provider_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 233 240 8 terminal_stage product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 +product/runtime/auths-gateway-kernel/src/transition.rs 244 249 6 has_reading product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 258 274 17 consistent product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 278 280 3 acknowledgement_stage product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 285 321 37 protocol_consistent product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 325 332 8 same_protocol product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 336 346 11 requires_entry product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 352 373 22 stage_transition_allowed product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 377 379 3 adds_pre_entry product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 383 385 3 adds_response product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 389 395 7 checkpoint_valid product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 399 405 7 entry_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 410 416 7 pre_entry_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 421 424 4 response_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 429 436 8 acknowledgement_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 444 449 6 exact_acknowledgement_replay product/runtime/auths-gateway-kernel decision 0 0 0 0 0 0 +product/runtime/auths-gateway-kernel/src/transition.rs 453 455 3 plan_kept product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 459 474 16 link_equal product/runtime/auths-gateway-kernel decision 0 0 1 0 1 0 +product/runtime/auths-gateway-kernel/src/transition.rs 482 496 15 valid_transition product/runtime/auths-gateway-kernel decision 0 0 1 1 1 1 product/runtime/auths-lifecycle/src/codec.rs 53 63 11 encode_record product/runtime/auths-lifecycle decoding 0 0 0 0 0 0 product/runtime/auths-lifecycle/src/codec.rs 71 83 13 decode_record product/runtime/auths-lifecycle decoding 0 0 0 0 0 0 product/runtime/auths-lifecycle/src/codec.rs 85 95 11 encode_unchecked product/runtime/auths-lifecycle decoding 0 0 0 0 0 0 diff --git a/formal/proof-coverage-v1.json b/formal/proof-coverage-v1.json index 49af70735..6c6ddb669 100644 --- a/formal/proof-coverage-v1.json +++ b/formal/proof-coverage-v1.json @@ -16,9 +16,9 @@ "translation_toolchain_lock_sha256": "0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53" }, "scope_definition_sha256": "053f0be216b0003768d422d9ccc92a692726488874284fa80615657b30a495b5", - "inputs_sha256": "56f5f8df74c31a2554725ec967451d36bfa6e7c4a49004b3c83bb5cd32c35f52", + "inputs_sha256": "ac052be07bf5d42e8b136ee8c1e0cf94f0cc3253f24c787165acc5b8607e3781", "inputs": { - "Cargo.toml": "sha256:6e0240aa432bcdb5b4f855618994582d2e428afe5ee4e4f6a3f8d21a518f8d24", + "Cargo.toml": "sha256:ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3", "core/crates/auths-algebra-kernel/Cargo.toml": "sha256:0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba", "core/crates/auths-algebra-kernel/src/generated.rs": "sha256:ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960", "core/crates/auths-algebra-kernel/src/lib.rs": "sha256:6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6", @@ -59,7 +59,7 @@ "core/crates/auths-verifier/src/trace.rs": "sha256:2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8", "formal/check-site-functions-v1.toml": "sha256:a4eebcb806f2be41aa39fb18700c70170cfe5792162feca0501d6e3fb69325ea", "formal/coverage-scope-v1.toml": "sha256:053f0be216b0003768d422d9ccc92a692726488874284fa80615657b30a495b5", - "formal/lean-assurance-audit-v1.json": "sha256:adbc3882efd275e821ae5fb5da68107d44915cb9205dbdc57681d4493e8b85ee", + "formal/lean-assurance-audit-v1.json": "sha256:9f975367344d2d1d9e84ba115a9115540b822e84218bab0eaed90024bd3a64b9", "formal/qualification/aeneas/generated/algebra/Funs.lean": "sha256:f78659289b73410828dceb4557cd4fbf2fa801b06ca083e8268be33074f68960", "formal/qualification/aeneas/generated/algebra/translation.json": "sha256:7b486aa626850f509f6c1038dbc5c74c753d53707d0085260e30321e570fab9d", "formal/qualification/aeneas/generated/authority/Funs.lean": "sha256:2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7", @@ -68,13 +68,13 @@ "formal/qualification/aeneas/generated/bounded_policy/translation.json": "sha256:3be48bd557146aef4d7452b17af0793fd61ed1e390c2274d7c75908a80fd79f5", "formal/qualification/aeneas/generated/connections/Funs.lean": "sha256:dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912", "formal/qualification/aeneas/generated/connections/translation.json": "sha256:c43f8a044ad0c19c676d43e3a6f7e24a492864c94f50b8fa4afbd08dd01f82ba", - "formal/qualification/aeneas/generated/gateway/Funs.lean": "sha256:c8c86db058f313ab46ee86370d79ee70130c1ead3860dd7dabd49f2a89af1636", - "formal/qualification/aeneas/generated/gateway/translation.json": "sha256:4b9e3e1158b6751a458ae6581e7e2230a1b242913d9a4842710d3bea3e08ee45", + "formal/qualification/aeneas/generated/gateway/Funs.lean": "sha256:8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601", + "formal/qualification/aeneas/generated/gateway/translation.json": "sha256:8b6b36d15312382cbed785d6a196056bad9da515e0c21a9b28ca5eee495a1ade", "formal/qualification/aeneas/generated/lifecycle/Funs.lean": "sha256:817dcbb854a599fb14c89854d8023809a390f7a00e1cc70dbc7151d7b254649f", "formal/qualification/aeneas/generated/lifecycle/translation.json": "sha256:b729089853215acf4d019aae5f04da6d902b75ac4910feeeb8d801e9991cdb4a", "formal/qualification/aeneas/generated/model/Funs.lean": "sha256:d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc", "formal/qualification/aeneas/generated/model/translation.json": "sha256:66e62345ea87b3150722b2d8b37473269c1cbfdaa09c875a3546ae381b7f5cd0", - "formal/qualification/aeneas/qualification.toml": "sha256:38aa0babb5be3ac958c7e91f0640ad0ae3b6e4f265257642976dfe8bd3330850", + "formal/qualification/aeneas/qualification.toml": "sha256:1da6c96a8d64598ff8a6999d6834e4f78fc0dee69d8c56ab3f69c37ecf436d58", "formal/theorem-kinds-v1.toml": "sha256:9714b276af0a45cadb7582e39beaa57dcb3494d6af23ca1b6a8702cc78e59728", "product/policy/auths-bounded-policy/src/arithmetic.rs": "sha256:75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627", "product/policy/auths-bounded-policy/src/commitment.rs": "sha256:c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f", @@ -84,18 +84,18 @@ "product/policy/auths-bounded-policy/src/lib.rs": "sha256:76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c", "product/policy/auths-bounded-policy/src/receipt.rs": "sha256:3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad", "product/policy/auths-bounded-policy/src/registry.rs": "sha256:4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0", - "product/runtime/auths-connections/src/credential.rs": "sha256:82921413bb053f0f6c7931fbd4e6a86c8cc1d8c6b51debd9c2cef33a8d5b1c51", + "product/runtime/auths-connections/src/credential.rs": "sha256:7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad", "product/runtime/auths-connections/src/kernel.rs": "sha256:a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8", "product/runtime/auths-connections/src/lib.rs": "sha256:79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22", "product/runtime/auths-connections/src/model.rs": "sha256:de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77", "product/runtime/auths-connections/src/registry.rs": "sha256:e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946", "product/runtime/auths-gateway-kernel/src/construct.rs": "sha256:e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c", "product/runtime/auths-gateway-kernel/src/lib.rs": "sha256:cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632", - "product/runtime/auths-gateway-kernel/src/order.rs": "sha256:e0045f877c4b7fe3860c291039853885064ddcdebba7c9b345ab65e81e646dda", - "product/runtime/auths-gateway-kernel/src/outcome.rs": "sha256:e9785b1afe70788c89b51b18655bcd5acff7b0c8e3d12fb79c6f05a202e67e6b", + "product/runtime/auths-gateway-kernel/src/order.rs": "sha256:efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8", + "product/runtime/auths-gateway-kernel/src/outcome.rs": "sha256:ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa", "product/runtime/auths-gateway-kernel/src/ratio.rs": "sha256:7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb", "product/runtime/auths-gateway-kernel/src/recovery.rs": "sha256:9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6", - "product/runtime/auths-gateway-kernel/src/transition.rs": "sha256:cefb8f01d915880f6921f2501ff881ad94b9de61072c34d9cd19220992f97374", + "product/runtime/auths-gateway-kernel/src/transition.rs": "sha256:9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c", "product/runtime/auths-lifecycle/src/codec.rs": "sha256:51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0", "product/runtime/auths-lifecycle/src/digest.rs": "sha256:55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7", "product/runtime/auths-lifecycle/src/identifier.rs": "sha256:31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1", @@ -245,33 +245,33 @@ "translated-crates": { "scope": "translated-crates", "minimum_code_lines": 0, - "functions": 1138, - "span_lines": 10681, - "code_lines": 10662, + "functions": 1146, + "span_lines": 10758, + "code_lines": 10738, "by_level": { "translated": { - "functions": 210, - "function_share": 0.1845, - "span_lines": 2519, - "span_line_share": 0.2358, - "code_lines": 2508, - "code_line_share": 0.2352 + "functions": 213, + "function_share": 0.1859, + "span_lines": 2508, + "span_line_share": 0.2331, + "code_lines": 2497, + "code_line_share": 0.2325 }, "direct": { "functions": 70, - "function_share": 0.0615, - "span_lines": 1035, - "span_line_share": 0.0969, - "code_lines": 1024, - "code_line_share": 0.096 + "function_share": 0.0611, + "span_lines": 1038, + "span_line_share": 0.0965, + "code_lines": 1027, + "code_line_share": 0.0956 }, "closure": { - "functions": 210, - "function_share": 0.1845, - "span_lines": 2519, - "span_line_share": 0.2358, - "code_lines": 2508, - "code_line_share": 0.2352 + "functions": 213, + "function_share": 0.1859, + "span_lines": 2508, + "span_line_share": 0.2331, + "code_lines": 2497, + "code_line_share": 0.2325 } } }, @@ -548,18 +548,18 @@ "refined_closure_code_lines": 182 }, "product/runtime/auths-connections": { - "decision_functions": 153, - "decision_code_lines": 1887, + "decision_functions": 157, + "decision_code_lines": 1965, "translated": 5, "refined_closure": 5, "refined_closure_code_lines": 51 }, "product/runtime/auths-gateway-kernel": { - "decision_functions": 98, - "decision_code_lines": 1194, - "translated": 95, - "refined_closure": 95, - "refined_closure_code_lines": 1168 + "decision_functions": 102, + "decision_code_lines": 1192, + "translated": 98, + "refined_closure": 98, + "refined_closure_code_lines": 1157 }, "product/runtime/auths-lifecycle": { "decision_functions": 138, @@ -2986,19 +2986,19 @@ } }, "translation_inventory": { - "aeneas_local_definitions": 318, + "aeneas_local_definitions": 321, "by_kind": { - "function": 210, + "function": 213, "loop": 92, "derived": 16 }, "refined_direct": 70, - "refined_closure": 215, + "refined_closure": 218, "theorems_naming_translated_functions": 75 }, "mutation_adequacy": { "results": "formal/model-mutations-v1.json", - "current_formal_inputs_sha256": "f250c011aa84a978f1f65e91ead3ed8aee7e3b6502e7d80868a583381df305db", + "current_formal_inputs_sha256": "9f655722b5ba3e4322f25ffd60c37fa9149373099562a28a8faa08f3a9848169", "fresh": false, "campaigns": { "s1": { diff --git a/formal/qualification/aeneas/cases/Gateway.lean b/formal/qualification/aeneas/cases/Gateway.lean index e197bf179..2e70a0ccd 100644 --- a/formal/qualification/aeneas/cases/Gateway.lean +++ b/formal/qualification/aeneas/cases/Gateway.lean @@ -1,4 +1,5 @@ import qualification.aeneas.generated.gateway.Funs +import Auths.Product.Refinement.Gateway open Aeneas Aeneas.Std Result @@ -94,4 +95,90 @@ example : action := order.SubmitAction.Stop order.Stop.Halted } := by rfl +-- AP074: the deadline names durable grant creation; only its successful +-- result names the send. Failure stops and replay returns stored state. +example : + order.next_step { plan, phase := .Deadline, argument := 1#u64 } (.Deadline true) = + ok { state := { plan, phase := .Grant, argument := 1#u64 }, action := .GrantEntry } := by + rfl +example : + order.next_step { plan, phase := .Grant, argument := 1#u64 } (.Granted true) = + ok { state := { plan, phase := .Send, argument := 1#u64 }, action := .Send } := by + rfl +example : + order.next_step { plan, phase := .Grant, argument := 1#u64 } (.Granted false) = + ok { state := { plan, phase := .Done, argument := 1#u64 }, + action := .Stop .GrantUnavailable } := by + rfl +example : + order.next_step { plan, phase := .Claim, argument := 1#u64 } (.Claim .Replay) = + ok { state := { plan, phase := .Done, argument := 1#u64 }, action := .Stop .Stored } := by + rfl +example : + order.next_step { plan, phase := .RecordResponse, argument := 1#u64 } (.Response .Recorded) = + ok { state := { plan, phase := .Done, argument := 1#u64 }, action := .Stop .Response } := by + rfl + +-- Late source response and recipient ACK are allowed evidence routes, but +-- an unknown cannot gain a second grant or become refundable not-entered. +example : transition.stage_transition_allowed .Unknown .ResponseRecorded .None = ok true := by + rfl +example : transition.stage_transition_allowed .Unknown .Acknowledged .None = ok true := by + rfl +example : transition.stage_transition_allowed .Unknown .EntryGranted .Verified = ok false := by + rfl +example : transition.stage_transition_allowed .Unknown .NotEntered .Verified = ok false := by + rfl +example : transition.stage_transition_allowed .Acknowledged .Unknown .None = ok false := by + rfl + +-- Full projected records demonstrate inhabited evidence routes and reject +-- changed source grants, protocol substitution, and non-successor revisions. +private def byteVec (byte : Std.U8) : alloc.vec.Vec Std.U8 := + ⟨[byte], by simp; scalar_tac⟩ + +private def unknownView (protocol : transition.Protocol) : transition.AttemptView := + { protocol, revision := 2#u64, fixed := byteVec 1#u8, entry := byteVec 2#u8, + stage := .Unknown, refusal := false, pre_entry := ⟨[], by simp⟩, + response := ⟨[], by simp⟩, acknowledgement := ⟨[], by simp⟩, + locator := ⟨[], by simp⟩, reading := .None, evidence := false, + observation := false, link := .None } + +private def lateResponse : transition.AttemptView := + { unknownView .Mutation with revision := 3#u64, stage := .ResponseRecorded, response := byteVec 3#u8 } + +private def lateAcknowledgement : transition.AttemptView := + { unknownView .Disclosure with revision := 3#u64, stage := .Acknowledged, acknowledgement := byteVec 4#u8 } + +private theorem projected_transition (old new : transition.AttemptView) : + transition.valid_transition old new = + ok (Auths.Product.Recovery.validTransition + (Auths.Product.Refinement.Gateway.viewOf old) + (Auths.Product.Refinement.Gateway.viewOf new)) := by + obtain ⟨result, resultEq, refined⟩ := Aeneas.Std.WP.spec_imp_exists + (Auths.Product.Refinement.Gateway.translated_valid_transition_refines_model old new) + rw [resultEq, refined] + +example : transition.valid_transition (unknownView .Mutation) lateResponse = ok true := by + rw [projected_transition] + rfl +example : transition.valid_transition (unknownView .Disclosure) lateAcknowledgement = ok true := by + rw [projected_transition] + rfl +example : transition.valid_transition (unknownView .Mutation) + { lateResponse with entry := byteVec 5#u8 } = ok false := by + rw [projected_transition] + rfl +example : transition.valid_transition (unknownView .Mutation) + { lateResponse with revision := 4#u64 } = ok false := by + rw [projected_transition] + rfl +example : transition.valid_transition (unknownView .Mutation) + { lateAcknowledgement with protocol := .Mutation } = ok false := by + rw [projected_transition] + rfl +example : transition.valid_transition (unknownView .Mutation) lateAcknowledgement = ok false := by + rw [projected_transition] + rfl + end qualification.aeneas.cases diff --git a/formal/qualification/aeneas/generated/gateway/Funs.lean b/formal/qualification/aeneas/generated/gateway/Funs.lean index 7cd1ea322..af1c9c6c6 100644 --- a/formal/qualification/aeneas/generated/gateway/Funs.lean +++ b/formal/qualification/aeneas/generated/gateway/Funs.lean @@ -1287,13 +1287,13 @@ def construct.construct_credential_read } /-- [auths_gateway_kernel::order::start]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 387:0-393:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 367:0-373:1 Visibility: public -/ def order.start (plan : order.SubmitPlan) : Result order.SubmitState := do ok { plan, phase := order.Phase.Start, argument := 0#u64 } /-- [auths_gateway_kernel::order::go]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 397:0-406:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 377:0-386:1 Visibility: public -/ def order.go (state : order.SubmitState) (phase : order.Phase) @@ -1303,7 +1303,7 @@ def order.go ok { state := { state with phase }, action } /-- [auths_gateway_kernel::order::stop]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 410:0-412:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 390:0-392:1 Visibility: public -/ def order.stop (state : order.SubmitState) (stop : order.Stop) : @@ -1312,13 +1312,13 @@ def order.stop order.go state order.Phase.Done (order.SubmitAction.Stop stop) /-- [auths_gateway_kernel::order::halt]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 416:0-418:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 396:0-398:1 Visibility: public -/ def order.halt (state : order.SubmitState) : Result order.SubmitDecision := do order.stop state order.Stop.Halted /-- [auths_gateway_kernel::order::not_entered]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 422:0-428:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 402:0-408:1 Visibility: public -/ def order.not_entered (state : order.SubmitState) (refusal : order.Refusal) : @@ -1327,20 +1327,8 @@ def order.not_entered order.go state order.Phase.RecordNotEntered (order.SubmitAction.RecordNotEntered refusal) -/-- [auths_gateway_kernel::order::lease_failed]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 433:0-439:1 - Visibility: public -/ -def order.lease_failed - (state : order.SubmitState) (mode : order.Mode) (refusal : order.Refusal) : - Result order.SubmitDecision - := do - match mode with - | order.Mode.Entry => order.not_entered state refusal - | order.Mode.ReadBack => order.stop state order.Stop.Response - | order.Mode.Reobserve => order.stop state order.Stop.ReplayRefused - /-- [auths_gateway_kernel::order::after_reads]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 445:0-451:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 414:0-420:1 Visibility: public -/ def order.after_reads (state : order.SubmitState) : Result order.SubmitDecision := do @@ -1356,7 +1344,7 @@ def order.after_reads order.SubmitAction.ReloadBeforeEntry /-- [auths_gateway_kernel::order::ceiling_from]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 455:0-461:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 424:0-430:1 Visibility: public -/ def order.ceiling_from (state : order.SubmitState) : Result order.SubmitDecision := do @@ -1365,7 +1353,7 @@ def order.ceiling_from else order.after_reads state /-- [auths_gateway_kernel::order::pre_entry_from]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 465:0-471:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 434:0-440:1 Visibility: public -/ def order.pre_entry_from (state : order.SubmitState) : Result order.SubmitDecision := do @@ -1373,50 +1361,30 @@ def order.pre_entry_from then order.go state order.Phase.PreEntry order.SubmitAction.PreEntryRead else order.ceiling_from state -/-- [auths_gateway_kernel::order::after_credentials]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 476:0-483:1 - Visibility: public -/ -def order.after_credentials - (state : order.SubmitState) (mode : order.Mode) : - Result order.SubmitDecision - := do - match mode with - | order.Mode.Entry => order.pre_entry_from state - | order.Mode.ReadBack => - order.go state (order.Phase.ReadBack order.Mode.ReadBack) - (order.SubmitAction.ReadBack order.Mode.ReadBack) - | order.Mode.Reobserve => - order.go state (order.Phase.ReadBack order.Mode.Reobserve) - (order.SubmitAction.ReadBack order.Mode.Reobserve) - /-- [auths_gateway_kernel::order::denied_from]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 487:0-497:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 444:0-450:1 Visibility: public -/ def order.denied_from - (state : order.SubmitState) (mode : order.Mode) (index : Std.U8) : + (state : order.SubmitState) (index : Std.U8) : Result order.SubmitDecision := do if index < state.plan.denied_reads then - order.go state (order.Phase.Denied mode index) - (order.SubmitAction.DeniedRead mode index) - else order.after_credentials state mode + order.go state (order.Phase.Denied index) (order.SubmitAction.DeniedRead + index) + else order.pre_entry_from state /-- [auths_gateway_kernel::order::after_prefix]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 501:0-507:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 454:0-460:1 Visibility: public -/ def order.after_prefix - (state : order.SubmitState) (mode : order.Mode) : - Result order.SubmitDecision - := do + (state : order.SubmitState) : Result order.SubmitDecision := do if state.plan.account_read - then - order.go state (order.Phase.Account mode) (order.SubmitAction.ReadAccount - mode) - else order.denied_from state mode 0#u8 + then order.go state order.Phase.Account order.SubmitAction.ReadAccount + else order.denied_from state 0#u8 /-- [auths_gateway_kernel::order::after_admission]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 511:0-517:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 464:0-470:1 Visibility: public -/ def order.after_admission (state : order.SubmitState) : Result order.SubmitDecision := do @@ -1425,7 +1393,7 @@ def order.after_admission else order.go state order.Phase.Prepare order.SubmitAction.Prepare /-- [auths_gateway_kernel::order::pre_claim]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 521:0-527:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 474:0-480:1 Visibility: public -/ def order.pre_claim (state : order.SubmitState) (passed : Bool) (next : order.SubmitDecision) : @@ -1436,58 +1404,54 @@ def order.pre_claim else order.stop state order.Stop.Refused /-- [auths_gateway_kernel::order::after_claim]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 531:0-542:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 484:0-491:1 Visibility: public -/ def order.after_claim (state : order.SubmitState) (result : order.ClaimResult) : Result order.SubmitDecision := do match result with - | order.ClaimResult.Inserted => - order.go state (order.Phase.Reload order.Mode.Entry) - (order.SubmitAction.Reload order.Mode.Entry) + | order.ClaimResult.Reserved => + order.go state order.Phase.Reload order.SubmitAction.Reload | order.ClaimResult.Refused => order.stop state order.Stop.ClaimRefused - | order.ClaimResult.Replay => - order.go state order.Phase.Resume order.SubmitAction.Resume + | order.ClaimResult.Replay => order.stop state order.Stop.Stored | order.ClaimResult.Unavailable => order.stop state order.Stop.StoreUnavailable /-- [auths_gateway_kernel::order::after_account]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 546:0-556:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 495:0-501:1 Visibility: public -/ def order.after_account - (state : order.SubmitState) (mode : order.Mode) - (result : order.AccountResult) : + (state : order.SubmitState) (result : order.AccountResult) : Result order.SubmitDecision := do match result with - | order.AccountResult.Equal => order.denied_from state mode 0#u8 + | order.AccountResult.Equal => order.denied_from state 0#u8 | order.AccountResult.Mismatch => - order.lease_failed state mode order.Refusal.AccountMismatch + order.not_entered state order.Refusal.AccountMismatch | order.AccountResult.Unavailable => - order.lease_failed state mode order.Refusal.AccountUnavailable + order.not_entered state order.Refusal.AccountUnavailable /-- [auths_gateway_kernel::order::after_denied]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 560:0-577:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 505:0-517:1 Visibility: public -/ def order.after_denied - (state : order.SubmitState) (mode : order.Mode) (index : Std.U8) - (result : order.DeniedResult) : + (state : order.SubmitState) (index : Std.U8) (result : order.DeniedResult) : Result order.SubmitDecision := do match result with | order.DeniedResult.Refused => if index < state.plan.denied_reads then let i ← index + 1#u8 - order.denied_from state mode i + order.denied_from state i else order.halt state | order.DeniedResult.Answered => - order.lease_failed state mode order.Refusal.CapabilityExcess + order.not_entered state order.Refusal.CapabilityExcess | order.DeniedResult.Unavailable => - order.lease_failed state mode order.Refusal.CapabilityUnavailable + order.not_entered state order.Refusal.CapabilityUnavailable /-- [auths_gateway_kernel::order::after_pre_entry]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 581:0-587:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 521:0-527:1 Visibility: public -/ def order.after_pre_entry (state : order.SubmitState) (result : order.PreEntryResult) : @@ -1521,7 +1485,7 @@ def ratio.relative_ceiling_admits ok (scaled_argument <= scaled_basis) /-- [auths_gateway_kernel::order::after_ceiling]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 592:0-605:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 532:0-545:1 Visibility: public -/ def order.after_ceiling (state : order.SubmitState) (read : order.CeilingRead) : @@ -1542,22 +1506,20 @@ def order.after_ceiling else order.not_entered state order.Refusal.CeilingBindingMismatch /-- [auths_gateway_kernel::order::after_write]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 609:0-615:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 549:0-554:1 Visibility: public -/ def order.after_write (state : order.SubmitState) (result : order.WriteResult) : Result order.SubmitDecision := do match result with - | order.WriteResult.NotEntered => - order.not_entered state order.Refusal.TransportNotEntered | order.WriteResult.Unknown => order.go state order.Phase.RecordUnknown order.SubmitAction.RecordUnknown | order.WriteResult.Response => order.go state order.Phase.RecordResponse order.SubmitAction.RecordResponse /-- [auths_gateway_kernel::order::after_response]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 619:0-634:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 558:0-563:1 Visibility: public -/ def order.after_response (state : order.SubmitState) (record1 : order.ResponseRecord) : @@ -1565,30 +1527,10 @@ def order.after_response := do match record1 with | order.ResponseRecord.Failed => order.stop state order.Stop.Unknown - | order.ResponseRecord.Recorded observable => - if observable - then - order.go state (order.Phase.Reload order.Mode.ReadBack) - (order.SubmitAction.Reload order.Mode.ReadBack) - else order.stop state order.Stop.Response - -/-- [auths_gateway_kernel::order::after_read_back]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 638:0-648:1 - Visibility: public -/ -def order.after_read_back - (state : order.SubmitState) (mode : order.Mode) (recorded : Bool) : - Result order.SubmitDecision - := do - if recorded - then order.stop state order.Stop.Observed - else - match mode with - | order.Mode.Entry => order.halt state - | order.Mode.ReadBack => order.stop state order.Stop.Response - | order.Mode.Reobserve => order.stop state order.Stop.ReplayRefused + | order.ResponseRecord.Recorded => order.stop state order.Stop.Response /-- [auths_gateway_kernel::order::pre_claim_step]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 653:0-705:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 568:0-620:1 Visibility: public -/ def order.pre_claim_step (state : order.SubmitState) (event : order.SubmitEvent) : @@ -1605,7 +1547,6 @@ def order.pre_claim_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1615,6 +1556,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Clock => @@ -1628,7 +1570,6 @@ def order.pre_claim_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1638,6 +1579,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Verify => @@ -1657,7 +1599,6 @@ def order.pre_claim_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1667,6 +1608,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Admit => @@ -1680,7 +1622,6 @@ def order.pre_claim_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1690,6 +1631,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Scope => @@ -1703,7 +1645,6 @@ def order.pre_claim_step order.pre_claim state bound sd | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1713,6 +1654,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Prepare => @@ -1726,7 +1668,6 @@ def order.pre_claim_step let sd ← order.go state order.Phase.Claim order.SubmitAction.Claim order.pre_claim state prepared sd | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1736,6 +1677,7 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Claim => @@ -1747,7 +1689,6 @@ def order.pre_claim_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim result => order.after_claim state result - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1757,28 +1698,28 @@ def order.pre_claim_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Resume => order.halt state - | order.Phase.Reload _ => order.halt state - | order.Phase.Lease _ => order.halt state - | order.Phase.Prefix _ => order.halt state - | order.Phase.Account _ => order.halt state - | order.Phase.Denied _ _ => order.halt state + | order.Phase.Reload => order.halt state + | order.Phase.Lease => order.halt state + | order.Phase.Prefix => order.halt state + | order.Phase.Account => order.halt state + | order.Phase.Denied _ => order.halt state | order.Phase.PreEntry => order.halt state | order.Phase.Ceiling => order.halt state | order.Phase.Checkpoint => order.halt state | order.Phase.EntryReload => order.halt state | order.Phase.Deadline => order.halt state + | order.Phase.Grant => order.halt state | order.Phase.Send => order.halt state | order.Phase.RecordResponse => order.halt state | order.Phase.RecordUnknown => order.halt state | order.Phase.RecordNotEntered => order.halt state - | order.Phase.ReadBack _ => order.halt state | order.Phase.Done => order.halt state /-- [auths_gateway_kernel::order::lease_step]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 710:0-766:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 625:0-667:1 Visibility: public -/ def order.lease_step (state : order.SubmitState) (event : order.SubmitEvent) : @@ -1792,33 +1733,7 @@ def order.lease_step | order.Phase.Scope => order.halt state | order.Phase.Prepare => order.halt state | order.Phase.Claim => order.halt state - | order.Phase.Resume => - match event with - | order.SubmitEvent.Start => order.halt state - | order.SubmitEvent.Clock _ => order.halt state - | order.SubmitEvent.Verification _ => order.halt state - | order.SubmitEvent.Admission _ => order.halt state - | order.SubmitEvent.Scope _ => order.halt state - | order.SubmitEvent.Preparation _ => order.halt state - | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume resumable => - if resumable - then - order.go state (order.Phase.Reload order.Mode.Reobserve) - (order.SubmitAction.Reload order.Mode.Reobserve) - else order.stop state order.Stop.ReplayRefused - | order.SubmitEvent.Reload _ => order.halt state - | order.SubmitEvent.Lease _ => order.halt state - | order.SubmitEvent.Prefix _ => order.halt state - | order.SubmitEvent.Account _ => order.halt state - | order.SubmitEvent.Denied _ => order.halt state - | order.SubmitEvent.PreEntry _ => order.halt state - | order.SubmitEvent.Ceiling _ => order.halt state - | order.SubmitEvent.Recorded _ => order.halt state - | order.SubmitEvent.Deadline _ => order.halt state - | order.SubmitEvent.Write _ => order.halt state - | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Reload mode => + | order.Phase.Reload => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -1827,12 +1742,10 @@ def order.lease_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload unchanged => if unchanged - then - order.go state (order.Phase.Lease mode) (order.SubmitAction.Lease mode) - else order.lease_failed state mode order.Refusal.ConnectionChanged + then order.go state order.Phase.Lease order.SubmitAction.Lease + else order.not_entered state order.Refusal.ConnectionChanged | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state | order.SubmitEvent.Account _ => order.halt state @@ -1841,9 +1754,10 @@ def order.lease_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Lease mode => + | order.Phase.Lease => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -1852,14 +1766,11 @@ def order.lease_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease leased => if leased - then - order.go state (order.Phase.Prefix mode) - (order.SubmitAction.CheckPrefix mode) - else order.lease_failed state mode order.Refusal.CredentialUnavailable + then order.go state order.Phase.Prefix order.SubmitAction.CheckPrefix + else order.not_entered state order.Refusal.CredentialUnavailable | order.SubmitEvent.Prefix _ => order.halt state | order.SubmitEvent.Account _ => order.halt state | order.SubmitEvent.Denied _ => order.halt state @@ -1867,9 +1778,10 @@ def order.lease_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Prefix mode => + | order.Phase.Prefix => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -1878,22 +1790,22 @@ def order.lease_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix allowed => if allowed - then order.after_prefix state mode - else order.lease_failed state mode order.Refusal.ModeGuard + then order.after_prefix state + else order.not_entered state order.Refusal.ModeGuard | order.SubmitEvent.Account _ => order.halt state | order.SubmitEvent.Denied _ => order.halt state | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Account mode => + | order.Phase.Account => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -1902,19 +1814,19 @@ def order.lease_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state - | order.SubmitEvent.Account result => order.after_account state mode result + | order.SubmitEvent.Account result => order.after_account state result | order.SubmitEvent.Denied _ => order.halt state | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Denied mode index => + | order.Phase.Denied index => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -1923,17 +1835,16 @@ def order.lease_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state | order.SubmitEvent.Account _ => order.halt state - | order.SubmitEvent.Denied result => - order.after_denied state mode index result + | order.SubmitEvent.Denied result => order.after_denied state index result | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.PreEntry => order.halt state @@ -1941,15 +1852,15 @@ def order.lease_step | order.Phase.Checkpoint => order.halt state | order.Phase.EntryReload => order.halt state | order.Phase.Deadline => order.halt state + | order.Phase.Grant => order.halt state | order.Phase.Send => order.halt state | order.Phase.RecordResponse => order.halt state | order.Phase.RecordUnknown => order.halt state | order.Phase.RecordNotEntered => order.halt state - | order.Phase.ReadBack _ => order.halt state | order.Phase.Done => order.halt state /-- [auths_gateway_kernel::order::entry_step]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 772:0-840:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 673:0-742:1 Visibility: public -/ def order.entry_step (state : order.SubmitState) (event : order.SubmitEvent) : @@ -1963,12 +1874,11 @@ def order.entry_step | order.Phase.Scope => order.halt state | order.Phase.Prepare => order.halt state | order.Phase.Claim => order.halt state - | order.Phase.Resume => order.halt state - | order.Phase.Reload _ => order.halt state - | order.Phase.Lease _ => order.halt state - | order.Phase.Prefix _ => order.halt state - | order.Phase.Account _ => order.halt state - | order.Phase.Denied _ _ => order.halt state + | order.Phase.Reload => order.halt state + | order.Phase.Lease => order.halt state + | order.Phase.Prefix => order.halt state + | order.Phase.Account => order.halt state + | order.Phase.Denied _ => order.halt state | order.Phase.PreEntry => match event with | order.SubmitEvent.Start => order.halt state @@ -1978,7 +1888,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -1988,6 +1897,7 @@ def order.entry_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Ceiling => @@ -1999,7 +1909,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2009,6 +1918,7 @@ def order.entry_step | order.SubmitEvent.Ceiling read => order.after_ceiling state read | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Checkpoint => @@ -2020,7 +1930,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2035,6 +1944,7 @@ def order.entry_step order.SubmitAction.ReloadBeforeEntry else order.stop state order.Stop.Unknown | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.EntryReload => @@ -2046,7 +1956,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload unchanged => if unchanged then order.go state order.Phase.Deadline order.SubmitAction.CheckDeadline @@ -2059,6 +1968,7 @@ def order.entry_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Deadline => @@ -2070,7 +1980,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2081,11 +1990,12 @@ def order.entry_step | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline within => if within - then order.go state order.Phase.Send order.SubmitAction.Send + then order.go state order.Phase.Grant order.SubmitAction.GrantEntry else order.not_entered state order.Refusal.EntryDeadline + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.Send => + | order.Phase.Grant => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -2094,7 +2004,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2104,9 +2013,13 @@ def order.entry_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state - | order.SubmitEvent.Write result => order.after_write state result + | order.SubmitEvent.Granted b => + if b + then order.go state order.Phase.Send order.SubmitAction.Send + else order.stop state order.Stop.GrantUnavailable + | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.RecordResponse => + | order.Phase.Send => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -2115,7 +2028,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2125,9 +2037,10 @@ def order.entry_step | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state - | order.SubmitEvent.Write _ => order.halt state - | order.SubmitEvent.Response record1 => order.after_response state record1 - | order.Phase.RecordUnknown => + | order.SubmitEvent.Granted _ => order.halt state + | order.SubmitEvent.Write result => order.after_write state result + | order.SubmitEvent.Response _ => order.halt state + | order.Phase.RecordResponse => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -2136,7 +2049,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2144,11 +2056,12 @@ def order.entry_step | order.SubmitEvent.Denied _ => order.halt state | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state - | order.SubmitEvent.Recorded _ => order.stop state order.Stop.Unknown + | order.SubmitEvent.Recorded _ => order.halt state | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state - | order.SubmitEvent.Response _ => order.halt state - | order.Phase.RecordNotEntered => + | order.SubmitEvent.Response record1 => order.after_response state record1 + | order.Phase.RecordUnknown => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -2157,7 +2070,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2165,14 +2077,12 @@ def order.entry_step | order.SubmitEvent.Denied _ => order.halt state | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state - | order.SubmitEvent.Recorded recorded => - if recorded - then order.stop state order.Stop.NotEntered - else order.stop state order.Stop.Unknown + | order.SubmitEvent.Recorded _ => order.stop state order.Stop.Unknown | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state - | order.Phase.ReadBack mode => + | order.Phase.RecordNotEntered => match event with | order.SubmitEvent.Start => order.halt state | order.SubmitEvent.Clock _ => order.halt state @@ -2181,7 +2091,6 @@ def order.entry_step | order.SubmitEvent.Scope _ => order.halt state | order.SubmitEvent.Preparation _ => order.halt state | order.SubmitEvent.Claim _ => order.halt state - | order.SubmitEvent.Resume _ => order.halt state | order.SubmitEvent.Reload _ => order.halt state | order.SubmitEvent.Lease _ => order.halt state | order.SubmitEvent.Prefix _ => order.halt state @@ -2190,14 +2099,17 @@ def order.entry_step | order.SubmitEvent.PreEntry _ => order.halt state | order.SubmitEvent.Ceiling _ => order.halt state | order.SubmitEvent.Recorded recorded => - order.after_read_back state mode recorded + if recorded + then order.stop state order.Stop.NotEntered + else order.stop state order.Stop.Unknown | order.SubmitEvent.Deadline _ => order.halt state + | order.SubmitEvent.Granted _ => order.halt state | order.SubmitEvent.Write _ => order.halt state | order.SubmitEvent.Response _ => order.halt state | order.Phase.Done => order.halt state /-- [auths_gateway_kernel::order::next_step]: - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 846:0-873:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 748:0-772:1 Visibility: public -/ def order.next_step (state : order.SubmitState) (event : order.SubmitEvent) : @@ -2211,22 +2123,21 @@ def order.next_step | order.Phase.Scope => order.pre_claim_step state event | order.Phase.Prepare => order.pre_claim_step state event | order.Phase.Claim => order.pre_claim_step state event - | order.Phase.Resume => order.lease_step state event - | order.Phase.Reload _ => order.lease_step state event - | order.Phase.Lease _ => order.lease_step state event - | order.Phase.Prefix _ => order.lease_step state event - | order.Phase.Account _ => order.lease_step state event - | order.Phase.Denied _ _ => order.lease_step state event + | order.Phase.Reload => order.lease_step state event + | order.Phase.Lease => order.lease_step state event + | order.Phase.Prefix => order.lease_step state event + | order.Phase.Account => order.lease_step state event + | order.Phase.Denied _ => order.lease_step state event | order.Phase.PreEntry => order.entry_step state event | order.Phase.Ceiling => order.entry_step state event | order.Phase.Checkpoint => order.entry_step state event | order.Phase.EntryReload => order.entry_step state event | order.Phase.Deadline => order.entry_step state event + | order.Phase.Grant => order.entry_step state event | order.Phase.Send => order.entry_step state event | order.Phase.RecordResponse => order.entry_step state event | order.Phase.RecordUnknown => order.entry_step state event | order.Phase.RecordNotEntered => order.entry_step state event - | order.Phase.ReadBack _ => order.entry_step state event | order.Phase.Done => order.halt state /-- [auths_gateway_kernel::ratio::relative_basis]: @@ -2312,14 +2223,14 @@ def recovery.recovery_capability } /-- [auths_gateway_kernel::transition::absent]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 89:0-91:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 113:0-115:1 Visibility: public -/ def transition.absent (bytes : Slice Std.U8) : Result Bool := do let i := Slice.len bytes ok (i = 0#usize) /-- [auths_gateway_kernel::transition::same_bytes_from]: loop body 0: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 97:4-104:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 121:4-128:1 Visibility: public -/ @[rust_loop_body] def transition.same_bytes_from_loop.body @@ -2342,7 +2253,7 @@ def transition.same_bytes_from_loop.body else ok (done true) /-- [auths_gateway_kernel::transition::same_bytes_from]: loop 0: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 97:4-104:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 121:4-128:1 Visibility: public -/ @[rust_loop] def transition.same_bytes_from_loop @@ -2354,7 +2265,7 @@ def transition.same_bytes_from_loop index /-- [auths_gateway_kernel::transition::same_bytes_from]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 95:0-104:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 119:0-128:1 Visibility: public -/ @[reducible] def transition.same_bytes_from @@ -2362,7 +2273,7 @@ def transition.same_bytes_from transition.same_bytes_from_loop left right 0#usize /-- [auths_gateway_kernel::transition::same_bytes]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 108:0-114:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 132:0-138:1 Visibility: public -/ def transition.same_bytes (left : Slice Std.U8) (right : Slice Std.U8) : Result Bool := do @@ -2373,7 +2284,7 @@ def transition.same_bytes else ok false /-- [auths_gateway_kernel::transition::resolves_unknown]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 119:0-124:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 143:0-148:1 Visibility: public -/ def transition.resolves_unknown (link : transition.Link) : Result Bool := do match link with @@ -2382,7 +2293,7 @@ def transition.resolves_unknown (link : transition.Link) : Result Bool := do | transition.Link.AfterResponse => ok false /-- [auths_gateway_kernel::transition::has_link]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 128:0-133:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 152:0-157:1 Visibility: public -/ def transition.has_link (link : transition.Link) : Result Bool := do match link with @@ -2391,67 +2302,77 @@ def transition.has_link (link : transition.Link) : Result Bool := do | transition.Link.AfterResponse => ok true /-- [auths_gateway_kernel::transition::refusal_stage]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 137:0-146:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 161:0-172:1 Visibility: public -/ def transition.refusal_stage (stage : transition.Stage) : Result Bool := do match stage with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok true | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok false | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::requires_response]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 150:0-155:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 176:0-186:1 Visibility: public -/ def transition.requires_response (stage : transition.Stage) : Result Bool := do match stage with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok true | transition.Stage.Observed => ok true | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::permits_response]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 159:0-164:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 190:0-199:1 Visibility: public -/ def transition.permits_response (stage : transition.Stage) : Result Bool := do match stage with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok true | transition.Stage.Observed => ok true | transition.Stage.ObservedByProvider => ok true + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::observed_stage]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 168:0-177:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 203:0-214:1 Visibility: public -/ def transition.observed_stage (stage : transition.Stage) : Result Bool := do match stage with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok false | transition.Stage.Observed => ok true | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::provider_stage]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 181:0-190:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 218:0-229:1 Visibility: public -/ def transition.provider_stage (stage : transition.Stage) : Result Bool := do match stage with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok false | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => ok true + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::has_reading]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 203:0-208:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 244:0-249:1 Visibility: public -/ def transition.has_reading (reading : transition.Reading) : Result Bool := do match reading with @@ -2460,217 +2381,401 @@ def transition.has_reading (reading : transition.Reading) : Result Bool := do | transition.Reading.Mismatch => ok true | transition.Reading.EchoMismatch => ok true -/-- [auths_gateway_kernel::transition::consistent]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 217:0-228:1 +/-- [auths_gateway_kernel::transition::requires_entry]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 336:0-346:1 Visibility: public -/ -def transition.consistent (view : transition.AttemptView) : Result Bool := do - let s := alloc.vec.Vec.deref view.response - let b ← transition.absent s - let b1 ← transition.refusal_stage view.stage - if b1 = view.refusal - then - let b2 ← transition.requires_response view.stage - if b2 +def transition.requires_entry (stage : transition.Stage) : Result Bool := do + match stage with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok true + | transition.Stage.ResponseRecorded => ok true + | transition.Stage.Observed => ok true + | transition.Stage.ObservedByProvider => ok true + | transition.Stage.Acknowledged => ok true + +/-- [auths_gateway_kernel::transition::acknowledgement_stage]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 278:0-280:1 + Visibility: public -/ +def transition.acknowledgement_stage + (stage : transition.Stage) : Result Bool := do + match stage with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok true + +/-- [auths_gateway_kernel::transition::protocol_consistent]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 285:0-321:1 + Visibility: public -/ +def transition.protocol_consistent + (view : transition.AttemptView) : Result Bool := do + match view.protocol with + | transition.Protocol.Mutation => + let b ← transition.acknowledgement_stage view.stage + if b + then ok false + else let s := alloc.vec.Vec.deref view.acknowledgement + transition.absent s + | transition.Protocol.Acquisition => + let b ← + match view.stage with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok true + | transition.Stage.Unknown => ok true + | transition.Stage.ResponseRecorded => ok true + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b then - if ¬ b + let s := alloc.vec.Vec.deref view.acknowledgement + let b1 ← transition.absent s + if b1 then - let b3 ← transition.permits_response view.stage - if b3 + let s1 := alloc.vec.Vec.deref view.pre_entry + let b2 ← transition.absent s1 + if b2 then - let s1 := alloc.vec.Vec.deref view.locator - let b4 ← transition.absent s1 - if b4 + let s2 := alloc.vec.Vec.deref view.locator + let b3 ← transition.absent s2 + if b3 then - let b5 ← transition.observed_stage view.stage - let b6 ← transition.has_reading view.reading - if b5 = b6 - then - if b6 - then - if view.observation - then - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence - then - if view.evidence - then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true - else ok false - else ok false + if view.observation + then ok false + else + if view.evidence + then ok false else - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence - then - if view.evidence - then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true - else ok false - else ok false - else - let b5 ← transition.observed_stage view.stage - let b6 ← transition.has_reading view.reading - if b5 = b6 - then - if b6 - then - if view.observation + let b4 ← + match view.reading with + | transition.Reading.None => ok true + | transition.Reading.Match => ok false + | transition.Reading.Mismatch => ok false + | transition.Reading.EchoMismatch => ok false + if b4 then - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence - then - if view.evidence - then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true - else ok false + match view.link with + | transition.Link.None => ok true + | transition.Link.Verified => ok false + | transition.Link.AfterResponse => ok false else ok false + else ok false + else ok false + else ok false + else ok false + | transition.Protocol.Disclosure => + let b ← + match view.stage with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok true + | transition.Stage.Unknown => ok true + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok true + if b + then + let s := alloc.vec.Vec.deref view.response + let b1 ← transition.absent s + if b1 + then + let s1 := alloc.vec.Vec.deref view.pre_entry + let b2 ← transition.absent s1 + if b2 + then + let s2 := alloc.vec.Vec.deref view.locator + let b3 ← transition.absent s2 + if b3 + then + if view.observation + then ok false + else + if view.evidence + then ok false else - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence + let b4 ← + match view.reading with + | transition.Reading.None => ok true + | transition.Reading.Match => ok false + | transition.Reading.Mismatch => ok false + | transition.Reading.EchoMismatch => ok false + if b4 then - if view.evidence - then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true + match view.link with + | transition.Link.None => ok true + | transition.Link.Verified => ok false + | transition.Link.AfterResponse => ok false else ok false - else ok false + else ok false else ok false else ok false - else - if ¬ b + else ok false + +/-- [auths_gateway_kernel::transition::consistent]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 258:0-274:1 + Visibility: public -/ +def transition.consistent (view : transition.AttemptView) : Result Bool := do + let s := alloc.vec.Vec.deref view.response + let b ← transition.absent s + let b1 ← transition.protocol_consistent view + if b1 + then + if view.revision > 0#u64 + then + if view.revision <= 9007199254740991#u64 then - let b3 ← transition.permits_response view.stage - if b3 + let b2 ← transition.requires_entry view.stage + let s1 := alloc.vec.Vec.deref view.entry + let b3 ← transition.absent s1 + if b2 != b3 then - let s1 := alloc.vec.Vec.deref view.locator - let b4 ← transition.absent s1 - if b4 + let b4 ← transition.acknowledgement_stage view.stage + let s2 := alloc.vec.Vec.deref view.acknowledgement + let b5 ← transition.absent s2 + if b4 != b5 then - let b5 ← transition.observed_stage view.stage - let b6 ← transition.has_reading view.reading - if b5 = b6 + let b6 ← transition.refusal_stage view.stage + if b6 = view.refusal then - if b6 + let b7 ← transition.requires_response view.stage + if b7 then - if view.observation + if ¬ b then - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence + let b8 ← transition.permits_response view.stage + if b8 then - if view.evidence + let s3 := alloc.vec.Vec.deref view.locator + let b9 ← transition.absent s3 + if b9 then - let b8 ← transition.has_link view.link - if b8 - then ok true + let b10 ← transition.observed_stage view.stage + let b11 ← transition.has_reading view.reading + if b10 = b11 + then + if b11 + then + if view.observation + then + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b10 ← transition.observed_stage view.stage + let b11 ← transition.has_reading view.reading + if b10 = b11 + then + if b11 + then + if view.observation + then + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false else ok false - else ok true else ok false else ok false else - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence + if ¬ b then - if view.evidence + let b8 ← transition.permits_response view.stage + if b8 then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true - else ok false - else ok false - else - let b5 ← transition.observed_stage view.stage - let b6 ← transition.has_reading view.reading - if b5 = b6 - then - if b6 - then - if view.observation - then - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence - then - if view.evidence + let s3 := alloc.vec.Vec.deref view.locator + let b9 ← transition.absent s3 + if b9 then - let b8 ← transition.has_link view.link - if b8 - then ok true + let b10 ← transition.observed_stage view.stage + let b11 ← transition.has_reading view.reading + if b10 = b11 + then + if b11 + then + if view.observation + then + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b10 ← transition.observed_stage view.stage + let b11 ← transition.has_reading view.reading + if b10 = b11 + then + if b11 + then + if view.observation + then + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false + else ok false + else + let b12 ← transition.provider_stage view.stage + if b12 = view.evidence + then + if view.evidence + then + let b13 ← transition.has_link view.link + if b13 + then ok true + else ok false + else ok true + else ok false else ok false - else ok true else ok false - else ok false - else - let b7 ← transition.provider_stage view.stage - if b7 = view.evidence - then - if view.evidence - then - let b8 ← transition.has_link view.link - if b8 - then ok true - else ok false - else ok true - else ok false - else ok false - else ok false - else - let s1 := alloc.vec.Vec.deref view.locator - let b3 ← transition.absent s1 - if b3 - then - let b4 ← transition.observed_stage view.stage - let b5 ← transition.has_reading view.reading - if b4 = b5 - then - if b5 - then - if view.observation - then - let b6 ← transition.provider_stage view.stage - if b6 = view.evidence - then - if view.evidence + else + let s3 := alloc.vec.Vec.deref view.locator + let b8 ← transition.absent s3 + if b8 then - let b7 ← transition.has_link view.link - if b7 - then transition.resolves_unknown view.link + let b9 ← transition.observed_stage view.stage + let b10 ← transition.has_reading view.reading + if b9 = b10 + then + if b10 + then + if view.observation + then + let b11 ← transition.provider_stage view.stage + if b11 = view.evidence + then + if view.evidence + then + let b12 ← transition.has_link view.link + if b12 + then transition.resolves_unknown view.link + else ok false + else ok true + else ok false + else ok false + else + let b11 ← transition.provider_stage view.stage + if b11 = view.evidence + then + if view.evidence + then + let b12 ← transition.has_link view.link + if b12 + then transition.resolves_unknown view.link + else ok false + else ok true + else ok false else ok false - else ok true - else ok false - else ok false - else - let b6 ← transition.provider_stage view.stage - if b6 = view.evidence - then - if view.evidence - then - let b7 ← transition.has_link view.link - if b7 - then transition.resolves_unknown view.link else ok false - else ok true - else ok false + else ok false else ok false else ok false + else ok false + else ok false else ok false +/-- [auths_gateway_kernel::transition::same_protocol]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 325:0-332:1 + Visibility: public -/ +def transition.same_protocol + (left : transition.Protocol) (right : transition.Protocol) : + Result Bool + := do + match left with + | transition.Protocol.Mutation => + match right with + | transition.Protocol.Mutation => ok true + | transition.Protocol.Acquisition => ok false + | transition.Protocol.Disclosure => ok false + | transition.Protocol.Acquisition => + match right with + | transition.Protocol.Mutation => ok false + | transition.Protocol.Acquisition => ok true + | transition.Protocol.Disclosure => ok false + | transition.Protocol.Disclosure => + match right with + | transition.Protocol.Mutation => ok false + | transition.Protocol.Acquisition => ok false + | transition.Protocol.Disclosure => ok true + /-- [auths_gateway_kernel::transition::stage_transition_allowed]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 235:0-260:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 352:0-373:1 Visibility: public -/ def transition.stage_transition_allowed (from1 : transition.Stage) (to1 : transition.Stage) (link : transition.Link) @@ -2678,106 +2783,199 @@ def transition.stage_transition_allowed Result Bool := do match from1 with - | transition.Stage.Attempting => + | transition.Stage.Reserved => match to1 with - | transition.Stage.Attempting => ok true + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok true | transition.Stage.NotEntered => ok true + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + | transition.Stage.EntryGranted => + match to1 with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok true | transition.Stage.ResponseRecorded => ok true | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => transition.resolves_unknown link + | transition.Stage.Acknowledged => ok true | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => match to1 with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false - | transition.Stage.ResponseRecorded => ok false + | transition.Stage.ResponseRecorded => ok true | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => transition.resolves_unknown link + | transition.Stage.Acknowledged => ok true | transition.Stage.ResponseRecorded => match to1 with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok false | transition.Stage.Observed => ok true | transition.Stage.ObservedByProvider => ok true + | transition.Stage.Acknowledged => ok false | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false /-- [auths_gateway_kernel::transition::adds_pre_entry]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 265:0-280:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 377:0-379:1 Visibility: public -/ def transition.adds_pre_entry (from1 : transition.Stage) (to1 : transition.Stage) : Result Bool := do - match from1 with - | transition.Stage.Attempting => + let b ← + match from1 with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b + then match to1 with - | transition.Stage.Attempting => ok true + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok true | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok false | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => ok false - | transition.Stage.NotEntered => ok false - | transition.Stage.Unknown => ok false - | transition.Stage.ResponseRecorded => ok false - | transition.Stage.Observed => ok false - | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + else ok false /-- [auths_gateway_kernel::transition::adds_response]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 284:0-300:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 383:0-385:1 Visibility: public -/ def transition.adds_response (from1 : transition.Stage) (to1 : transition.Stage) : Result Bool := do - match from1 with - | transition.Stage.Attempting => + let b ← + match from1 with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok true + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b + then match to1 with - | transition.Stage.Attempting => ok false + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok false | transition.Stage.NotEntered => ok false | transition.Stage.Unknown => ok false | transition.Stage.ResponseRecorded => ok true | transition.Stage.Observed => ok false | transition.Stage.ObservedByProvider => ok false - | transition.Stage.NotEntered => ok false - | transition.Stage.Unknown => ok false - | transition.Stage.ResponseRecorded => ok false - | transition.Stage.Observed => ok false - | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + else ok false /-- [auths_gateway_kernel::transition::checkpoint_valid]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 305:0-321:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 389:0-395:1 Visibility: public -/ def transition.checkpoint_valid (old : transition.AttemptView) (new : transition.AttemptView) : Result Bool := do - match old.stage with - | transition.Stage.Attempting => - match new.stage with - | transition.Stage.Attempting => + let b ← + match old.stage with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b + then + let b1 ← + match new.stage with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b1 + then let s := alloc.vec.Vec.deref old.pre_entry - let b ← transition.absent s - if b + let b2 ← transition.absent s + if b2 then let s1 := alloc.vec.Vec.deref new.pre_entry - let b1 ← transition.absent s1 - ok (¬ b1) + let b3 ← transition.absent s1 + ok (¬ b3) else ok false - | transition.Stage.NotEntered => ok true - | transition.Stage.Unknown => ok true - | transition.Stage.ResponseRecorded => ok true - | transition.Stage.Observed => ok true - | transition.Stage.ObservedByProvider => ok true - | transition.Stage.NotEntered => ok true - | transition.Stage.Unknown => ok true - | transition.Stage.ResponseRecorded => ok true - | transition.Stage.Observed => ok true - | transition.Stage.ObservedByProvider => ok true + else ok true + else ok true + +/-- [auths_gateway_kernel::transition::entry_kept]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 399:0-405:1 + Visibility: public -/ +def transition.entry_kept + (old : transition.AttemptView) (new : transition.AttemptView) : + Result Bool + := do + let b ← + match old.stage with + | transition.Stage.Reserved => ok true + | transition.Stage.EntryGranted => ok false + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b + then + let b1 ← + match new.stage with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok false + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b1 + then + let s := alloc.vec.Vec.deref old.entry + let b2 ← transition.absent s + if b2 + then + let s1 := alloc.vec.Vec.deref new.entry + let b3 ← transition.absent s1 + ok (¬ b3) + else ok false + else + let s := alloc.vec.Vec.deref old.entry + let s1 := alloc.vec.Vec.deref new.entry + transition.same_bytes s s1 + else + let s := alloc.vec.Vec.deref old.entry + let s1 := alloc.vec.Vec.deref new.entry + transition.same_bytes s s1 /-- [auths_gateway_kernel::transition::pre_entry_kept]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 326:0-332:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 410:0-416:1 Visibility: public -/ def transition.pre_entry_kept (old : transition.AttemptView) (new : transition.AttemptView) : @@ -2798,7 +2996,7 @@ def transition.pre_entry_kept transition.same_bytes s1 s2 /-- [auths_gateway_kernel::transition::response_kept]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 337:0-340:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 421:0-424:1 Visibility: public -/ def transition.response_kept (old : transition.AttemptView) (new : transition.AttemptView) : @@ -2818,8 +3016,47 @@ def transition.response_kept transition.same_bytes s2 s3 else ok false +/-- [auths_gateway_kernel::transition::acknowledgement_kept]: + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 429:0-436:1 + Visibility: public -/ +def transition.acknowledgement_kept + (old : transition.AttemptView) (new : transition.AttemptView) : + Result Bool + := do + let b ← + match old.stage with + | transition.Stage.Reserved => ok false + | transition.Stage.EntryGranted => ok true + | transition.Stage.NotEntered => ok false + | transition.Stage.Unknown => ok true + | transition.Stage.ResponseRecorded => ok false + | transition.Stage.Observed => ok false + | transition.Stage.ObservedByProvider => ok false + | transition.Stage.Acknowledged => ok false + if b + then + let b1 ← transition.acknowledgement_stage new.stage + if b1 + then + let s := alloc.vec.Vec.deref old.acknowledgement + let b2 ← transition.absent s + if b2 + then + let s1 := alloc.vec.Vec.deref new.acknowledgement + let b3 ← transition.absent s1 + ok (¬ b3) + else ok false + else + let s := alloc.vec.Vec.deref old.acknowledgement + let s1 := alloc.vec.Vec.deref new.acknowledgement + transition.same_bytes s s1 + else + let s := alloc.vec.Vec.deref old.acknowledgement + let s1 := alloc.vec.Vec.deref new.acknowledgement + transition.same_bytes s s1 + /-- [auths_gateway_kernel::transition::link_equal]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 350:0-365:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 459:0-474:1 Visibility: public -/ def transition.link_equal (left : transition.Link) (right : transition.Link) : Result Bool := do @@ -2841,7 +3078,7 @@ def transition.link_equal | transition.Link.AfterResponse => ok true /-- [auths_gateway_kernel::transition::plan_kept]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 344:0-346:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 453:0-455:1 Visibility: public -/ def transition.plan_kept (old : transition.AttemptView) (new : transition.AttemptView) : @@ -2852,33 +3089,57 @@ def transition.plan_kept else ok false /-- [auths_gateway_kernel::transition::valid_transition]: - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 373:0-381:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 482:0-496:1 Visibility: public -/ def transition.valid_transition (old : transition.AttemptView) (new : transition.AttemptView) : Result Bool := do - let s := alloc.vec.Vec.deref old.fixed - let s1 := alloc.vec.Vec.deref new.fixed - let b ← transition.same_bytes s s1 + let b ← transition.same_protocol old.protocol new.protocol if b then - let b1 ← transition.plan_kept old new - if b1 + if old.revision < 9007199254740991#u64 then - let b2 ← - transition.stage_transition_allowed old.stage new.stage old.link - if b2 + let i ← old.revision + 1#u64 + if new.revision = i then - let b3 ← transition.checkpoint_valid old new - if b3 + let b1 ← transition.consistent old + if b1 then - let b4 ← transition.pre_entry_kept old new - if b4 + let b2 ← transition.entry_kept old new + if b2 then - let b5 ← transition.response_kept old new - if b5 - then transition.consistent new + let s := alloc.vec.Vec.deref old.fixed + let s1 := alloc.vec.Vec.deref new.fixed + let b3 ← transition.same_bytes s s1 + if b3 + then + let b4 ← transition.plan_kept old new + if b4 + then + let b5 ← + transition.stage_transition_allowed old.stage new.stage + old.link + if b5 + then + let b6 ← transition.checkpoint_valid old new + if b6 + then + let b7 ← transition.pre_entry_kept old new + if b7 + then + let b8 ← transition.response_kept old new + if b8 + then + let b9 ← transition.acknowledgement_kept old new + if b9 + then transition.consistent new + else ok false + else ok false + else ok false + else ok false + else ok false + else ok false else ok false else ok false else ok false diff --git a/formal/qualification/aeneas/generated/gateway/Types.lean b/formal/qualification/aeneas/generated/gateway/Types.lean index 2782c58c8..38767b75d 100644 --- a/formal/qualification/aeneas/generated/gateway/Types.lean +++ b/formal/qualification/aeneas/generated/gateway/Types.lean @@ -147,17 +147,8 @@ inductive construct.ConstructError where | HeaderValue : construct.ConstructError | BodySize : construct.ConstructError -/-- [auths_gateway_kernel::order::Mode] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 34:0-41:1 - Visibility: public -/ -@[discriminant isize] -inductive order.Mode where -| Entry : order.Mode -| ReadBack : order.Mode -| Reobserve : order.Mode - /-- [auths_gateway_kernel::order::SubmitPlan] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 50:0-63:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 39:0-52:1 Visibility: public -/ structure order.SubmitPlan where account_scope : Bool @@ -168,7 +159,7 @@ structure order.SubmitPlan where basis_points : Std.U16 /-- [auths_gateway_kernel::order::Phase] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 67:0-116:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 56:0-103:1 Visibility: public -/ @[discriminant isize] inductive order.Phase where @@ -179,26 +170,25 @@ inductive order.Phase where | Scope : order.Phase | Prepare : order.Phase | Claim : order.Phase -| Resume : order.Phase -| Reload : order.Mode → order.Phase -| Lease : order.Mode → order.Phase -| Prefix : order.Mode → order.Phase -| Account : order.Mode → order.Phase -| Denied : order.Mode → Std.U8 → order.Phase +| Reload : order.Phase +| Lease : order.Phase +| Prefix : order.Phase +| Account : order.Phase +| Denied : Std.U8 → order.Phase | PreEntry : order.Phase | Ceiling : order.Phase | Checkpoint : order.Phase | EntryReload : order.Phase | Deadline : order.Phase +| Grant : order.Phase | Send : order.Phase | RecordResponse : order.Phase | RecordUnknown : order.Phase | RecordNotEntered : order.Phase -| ReadBack : order.Mode → order.Phase | Done : order.Phase /-- [auths_gateway_kernel::order::SubmitState] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 120:0-128:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 107:0-115:1 Visibility: public -/ structure order.SubmitState where plan : order.SubmitPlan @@ -206,7 +196,7 @@ structure order.SubmitState where argument : Std.U64 /-- [auths_gateway_kernel::order::Verification] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 132:0-141:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 119:0-128:1 Visibility: public -/ @[discriminant isize] inductive order.Verification where @@ -214,17 +204,17 @@ inductive order.Verification where | Authorized : Std.U64 → order.Verification /-- [auths_gateway_kernel::order::ClaimResult] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 145:0-154:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 132:0-141:1 Visibility: public -/ @[discriminant isize] inductive order.ClaimResult where -| Inserted : order.ClaimResult +| Reserved : order.ClaimResult | Refused : order.ClaimResult | Replay : order.ClaimResult | Unavailable : order.ClaimResult /-- [auths_gateway_kernel::order::AccountResult] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 158:0-165:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 145:0-152:1 Visibility: public -/ @[discriminant isize] inductive order.AccountResult where @@ -233,7 +223,7 @@ inductive order.AccountResult where | Unavailable : order.AccountResult /-- [auths_gateway_kernel::order::DeniedResult] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 169:0-176:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 156:0-163:1 Visibility: public -/ @[discriminant isize] inductive order.DeniedResult where @@ -242,7 +232,7 @@ inductive order.DeniedResult where | Unavailable : order.DeniedResult /-- [auths_gateway_kernel::order::PreEntryResult] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 180:0-187:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 167:0-174:1 Visibility: public -/ @[discriminant isize] inductive order.PreEntryResult where @@ -251,7 +241,7 @@ inductive order.PreEntryResult where | Unavailable : order.PreEntryResult /-- [auths_gateway_kernel::order::CeilingRead] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 191:0-201:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 178:0-188:1 Visibility: public -/ @[discriminant isize] inductive order.CeilingRead where @@ -259,24 +249,23 @@ inductive order.CeilingRead where | Read : Std.U64 → Bool → order.CeilingRead /-- [auths_gateway_kernel::order::WriteResult] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 205:0-212:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 192:0-197:1 Visibility: public -/ @[discriminant isize] inductive order.WriteResult where -| NotEntered : order.WriteResult | Unknown : order.WriteResult | Response : order.WriteResult /-- [auths_gateway_kernel::order::ResponseRecord] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 216:0-224:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 201:0-206:1 Visibility: public -/ @[discriminant isize] inductive order.ResponseRecord where | Failed : order.ResponseRecord -| Recorded : Bool → order.ResponseRecord +| Recorded : order.ResponseRecord /-- [auths_gateway_kernel::order::SubmitEvent] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 228:0-267:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 210:0-249:1 Visibility: public -/ @[discriminant isize] inductive order.SubmitEvent where @@ -287,7 +276,6 @@ inductive order.SubmitEvent where | Scope : Bool → order.SubmitEvent | Preparation : Bool → order.SubmitEvent | Claim : order.ClaimResult → order.SubmitEvent -| Resume : Bool → order.SubmitEvent | Reload : Bool → order.SubmitEvent | Lease : Bool → order.SubmitEvent | Prefix : Bool → order.SubmitEvent @@ -297,11 +285,12 @@ inductive order.SubmitEvent where | Ceiling : order.CeilingRead → order.SubmitEvent | Recorded : Bool → order.SubmitEvent | Deadline : Bool → order.SubmitEvent +| Granted : Bool → order.SubmitEvent | Write : order.WriteResult → order.SubmitEvent | Response : order.ResponseRecord → order.SubmitEvent /-- [auths_gateway_kernel::order::Refusal] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 271:0-300:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 253:0-282:1 Visibility: public -/ @[discriminant isize] inductive order.Refusal where @@ -321,7 +310,7 @@ inductive order.Refusal where | TransportNotEntered : order.Refusal /-- [auths_gateway_kernel::order::Stop] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 304:0-323:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 286:0-305:1 Visibility: public -/ @[discriminant isize] inductive order.Stop where @@ -331,12 +320,12 @@ inductive order.Stop where | NotEntered : order.Stop | Unknown : order.Stop | Response : order.Stop -| Observed : order.Stop -| ReplayRefused : order.Stop +| Stored : order.Stop +| GrantUnavailable : order.Stop | Halted : order.Stop /-- [auths_gateway_kernel::order::SubmitAction] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 327:0-374:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 309:0-354:1 Visibility: public -/ @[discriminant isize] inductive order.SubmitAction where @@ -346,26 +335,25 @@ inductive order.SubmitAction where | BindScope : order.SubmitAction | Prepare : order.SubmitAction | Claim : order.SubmitAction -| Resume : order.SubmitAction -| Reload : order.Mode → order.SubmitAction -| Lease : order.Mode → order.SubmitAction -| CheckPrefix : order.Mode → order.SubmitAction -| ReadAccount : order.Mode → order.SubmitAction -| DeniedRead : order.Mode → Std.U8 → order.SubmitAction +| Reload : order.SubmitAction +| Lease : order.SubmitAction +| CheckPrefix : order.SubmitAction +| ReadAccount : order.SubmitAction +| DeniedRead : Std.U8 → order.SubmitAction | PreEntryRead : order.SubmitAction | CeilingRead : order.SubmitAction | RecordCheckpoint : order.SubmitAction | ReloadBeforeEntry : order.SubmitAction | CheckDeadline : order.SubmitAction +| GrantEntry : order.SubmitAction | Send : order.SubmitAction | RecordResponse : order.SubmitAction | RecordUnknown : order.SubmitAction | RecordNotEntered : order.Refusal → order.SubmitAction -| ReadBack : order.Mode → order.SubmitAction | Stop : order.Stop → order.SubmitAction /-- [auths_gateway_kernel::order::SubmitDecision] - Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 378:0-383:1 + Source: 'product/runtime/auths-gateway-kernel/src/order.rs', lines 358:0-363:1 Visibility: public -/ structure order.SubmitDecision where state : order.SubmitState @@ -435,20 +423,31 @@ structure recovery.RecoveryCapability where pre_entry_reread : Bool write_is_conditional : Bool +/-- [auths_gateway_kernel::transition::Protocol] + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 19:0-26:1 + Visibility: public -/ +@[discriminant isize] +inductive transition.Protocol where +| Mutation : transition.Protocol +| Acquisition : transition.Protocol +| Disclosure : transition.Protocol + /-- [auths_gateway_kernel::transition::Stage] - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 19:0-32:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 30:0-47:1 Visibility: public -/ @[discriminant isize] inductive transition.Stage where -| Attempting : transition.Stage +| Reserved : transition.Stage +| EntryGranted : transition.Stage | NotEntered : transition.Stage | Unknown : transition.Stage | ResponseRecorded : transition.Stage | Observed : transition.Stage | ObservedByProvider : transition.Stage +| Acknowledged : transition.Stage /-- [auths_gateway_kernel::transition::Reading] - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 36:0-45:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 51:0-60:1 Visibility: public -/ @[discriminant isize] inductive transition.Reading where @@ -458,7 +457,7 @@ inductive transition.Reading where | EchoMismatch : transition.Reading /-- [auths_gateway_kernel::transition::Link] - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 49:0-56:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 64:0-71:1 Visibility: public -/ @[discriminant isize] inductive transition.Link where @@ -467,14 +466,18 @@ inductive transition.Link where | AfterResponse : transition.Link /-- [auths_gateway_kernel::transition::AttemptView] - Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 60:0-81:1 + Source: 'product/runtime/auths-gateway-kernel/src/transition.rs', lines 75:0-105:1 Visibility: public -/ structure transition.AttemptView where + protocol : transition.Protocol + revision : Std.U64 fixed : alloc.vec.Vec Std.U8 + entry : alloc.vec.Vec Std.U8 stage : transition.Stage refusal : Bool pre_entry : alloc.vec.Vec Std.U8 response : alloc.vec.Vec Std.U8 + acknowledgement : alloc.vec.Vec Std.U8 locator : alloc.vec.Vec Std.U8 reading : transition.Reading evidence : Bool diff --git a/formal/qualification/aeneas/generated/gateway/translation.json b/formal/qualification/aeneas/generated/gateway/translation.json index fff14d276..2a69a139d 100644 --- a/formal/qualification/aeneas/generated/gateway/translation.json +++ b/formal/qualification/aeneas/generated/gateway/translation.json @@ -4,7 +4,7 @@ "crate": "auths_gateway_kernel", "functions": [ { - "def_id": 37, + "def_id": 40, "lean_name": "auths_gateway_kernel.construct.append_bytes_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_bytes", @@ -29,7 +29,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_bytes" }, { - "def_id": 37, + "def_id": 40, "lean_name": "auths_gateway_kernel.construct.append_bytes_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_bytes", @@ -54,7 +54,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_bytes" }, { - "def_id": 37, + "def_id": 40, "lean_name": "auths_gateway_kernel.construct.append_bytes", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_bytes", @@ -88,7 +88,7 @@ "reducible": false }, { - "def_id": 113, + "def_id": 116, "lean_name": "auths_gateway_kernel.construct.is_alphanumeric", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::is_alphanumeric", @@ -105,7 +105,7 @@ "reducible": false }, { - "def_id": 109, + "def_id": 112, "lean_name": "auths_gateway_kernel.construct.is_path_literal", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::is_path_literal", @@ -122,7 +122,7 @@ "reducible": false }, { - "def_id": 111, + "def_id": 114, "lean_name": "auths_gateway_kernel.construct.is_form_literal", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::is_form_literal", @@ -139,7 +139,7 @@ "reducible": false }, { - "def_id": 114, + "def_id": 117, "lean_name": "auths_gateway_kernel.construct.hex_upper", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::hex_upper", @@ -156,7 +156,7 @@ "reducible": false }, { - "def_id": 115, + "def_id": 118, "lean_name": "auths_gateway_kernel.construct.hex_lower", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::hex_lower", @@ -173,7 +173,7 @@ "reducible": false }, { - "def_id": 110, + "def_id": 113, "lean_name": "auths_gateway_kernel.construct.append_percent", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_percent", @@ -190,7 +190,7 @@ "reducible": false }, { - "def_id": 103, + "def_id": 107, "lean_name": "auths_gateway_kernel.construct.append_path_byte", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_path_byte", @@ -207,7 +207,7 @@ "reducible": false }, { - "def_id": 96, + "def_id": 100, "lean_name": "auths_gateway_kernel.construct.append_path_encoded_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_path_encoded", @@ -232,7 +232,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_path_encoded" }, { - "def_id": 96, + "def_id": 100, "lean_name": "auths_gateway_kernel.construct.append_path_encoded_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_path_encoded", @@ -257,7 +257,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_path_encoded" }, { - "def_id": 96, + "def_id": 100, "lean_name": "auths_gateway_kernel.construct.append_path_encoded", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_path_encoded", @@ -274,7 +274,7 @@ "reducible": true }, { - "def_id": 95, + "def_id": 99, "lean_name": "auths_gateway_kernel.construct.segment_value_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::segment_value_valid", @@ -291,7 +291,7 @@ "reducible": false }, { - "def_id": 82, + "def_id": 86, "lean_name": "auths_gateway_kernel.construct.segment_error", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::segment_error", @@ -308,7 +308,7 @@ "reducible": false }, { - "def_id": 34, + "def_id": 37, "lean_name": "auths_gateway_kernel.construct.path_error_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::path_error", @@ -333,7 +333,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.path_error" }, { - "def_id": 34, + "def_id": 37, "lean_name": "auths_gateway_kernel.construct.path_error_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::path_error", @@ -358,7 +358,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.path_error" }, { - "def_id": 34, + "def_id": 37, "lean_name": "auths_gateway_kernel.construct.path_error", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::path_error", @@ -375,7 +375,7 @@ "reducible": true }, { - "def_id": 84, + "def_id": 88, "lean_name": "auths_gateway_kernel.construct.append_segment", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_segment", @@ -392,7 +392,7 @@ "reducible": false }, { - "def_id": 35, + "def_id": 38, "lean_name": "auths_gateway_kernel.construct.append_segments_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_segments", @@ -417,7 +417,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_segments" }, { - "def_id": 35, + "def_id": 38, "lean_name": "auths_gateway_kernel.construct.append_segments_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_segments", @@ -442,7 +442,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_segments" }, { - "def_id": 35, + "def_id": 38, "lean_name": "auths_gateway_kernel.construct.append_segments", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_segments", @@ -543,7 +543,7 @@ "reducible": false }, { - "def_id": 52, + "def_id": 55, "lean_name": "auths_gateway_kernel.construct.copy_header", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::copy_header", @@ -627,7 +627,7 @@ "reducible": true }, { - "def_id": 106, + "def_id": 110, "lean_name": "auths_gateway_kernel.construct.is_account_byte", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::is_account_byte", @@ -644,7 +644,7 @@ "reducible": false }, { - "def_id": 100, + "def_id": 104, "lean_name": "auths_gateway_kernel.construct.account_bytes_valid_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::account_bytes_valid", @@ -669,7 +669,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.account_bytes_valid" }, { - "def_id": 100, + "def_id": 104, "lean_name": "auths_gateway_kernel.construct.account_bytes_valid_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::account_bytes_valid", @@ -694,7 +694,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.account_bytes_valid" }, { - "def_id": 100, + "def_id": 104, "lean_name": "auths_gateway_kernel.construct.account_bytes_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::account_bytes_valid", @@ -711,7 +711,7 @@ "reducible": true }, { - "def_id": 91, + "def_id": 95, "lean_name": "auths_gateway_kernel.construct.scope_value_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::scope_value_valid", @@ -728,7 +728,7 @@ "reducible": false }, { - "def_id": 47, + "def_id": 50, "lean_name": "auths_gateway_kernel.construct.account_scope_header", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::account_scope_header", @@ -762,7 +762,7 @@ "reducible": false }, { - "def_id": 112, + "def_id": 115, "lean_name": "auths_gateway_kernel.construct.append_json_byte", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_byte", @@ -779,7 +779,7 @@ "reducible": false }, { - "def_id": 105, + "def_id": 109, "lean_name": "auths_gateway_kernel.construct.append_json_escaped_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_escaped", @@ -804,7 +804,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_json_escaped" }, { - "def_id": 105, + "def_id": 109, "lean_name": "auths_gateway_kernel.construct.append_json_escaped_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_escaped", @@ -829,7 +829,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_json_escaped" }, { - "def_id": 105, + "def_id": 109, "lean_name": "auths_gateway_kernel.construct.append_json_escaped", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_escaped", @@ -846,7 +846,7 @@ "reducible": true }, { - "def_id": 98, + "def_id": 102, "lean_name": "auths_gateway_kernel.construct.append_json_string", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_string", @@ -863,7 +863,7 @@ "reducible": false }, { - "def_id": 99, + "def_id": 103, "lean_name": "auths_gateway_kernel.construct.append_json_argument", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_argument", @@ -880,7 +880,7 @@ "reducible": false }, { - "def_id": 87, + "def_id": 91, "lean_name": "auths_gateway_kernel.construct.json_piece_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::json_piece_valid", @@ -897,7 +897,7 @@ "reducible": false }, { - "def_id": 44, + "def_id": 47, "lean_name": "auths_gateway_kernel.construct.json_pieces_valid_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::json_pieces_valid", @@ -922,7 +922,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.json_pieces_valid" }, { - "def_id": 44, + "def_id": 47, "lean_name": "auths_gateway_kernel.construct.json_pieces_valid_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::json_pieces_valid", @@ -947,7 +947,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.json_pieces_valid" }, { - "def_id": 44, + "def_id": 47, "lean_name": "auths_gateway_kernel.construct.json_pieces_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::json_pieces_valid", @@ -964,7 +964,7 @@ "reducible": true }, { - "def_id": 89, + "def_id": 93, "lean_name": "auths_gateway_kernel.construct.append_json_piece", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_piece", @@ -981,7 +981,7 @@ "reducible": false }, { - "def_id": 46, + "def_id": 49, "lean_name": "auths_gateway_kernel.construct.append_json_pieces_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_pieces", @@ -1006,7 +1006,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_json_pieces" }, { - "def_id": 46, + "def_id": 49, "lean_name": "auths_gateway_kernel.construct.append_json_pieces_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_pieces", @@ -1031,7 +1031,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_json_pieces" }, { - "def_id": 46, + "def_id": 49, "lean_name": "auths_gateway_kernel.construct.append_json_pieces", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_json_pieces", @@ -1048,7 +1048,7 @@ "reducible": true }, { - "def_id": 104, + "def_id": 108, "lean_name": "auths_gateway_kernel.construct.append_form_byte", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_byte", @@ -1065,7 +1065,7 @@ "reducible": false }, { - "def_id": 97, + "def_id": 101, "lean_name": "auths_gateway_kernel.construct.append_form_encoded_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_encoded", @@ -1090,7 +1090,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_form_encoded" }, { - "def_id": 97, + "def_id": 101, "lean_name": "auths_gateway_kernel.construct.append_form_encoded_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_encoded", @@ -1115,7 +1115,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_form_encoded" }, { - "def_id": 97, + "def_id": 101, "lean_name": "auths_gateway_kernel.construct.append_form_encoded", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_encoded", @@ -1132,7 +1132,7 @@ "reducible": true }, { - "def_id": 86, + "def_id": 90, "lean_name": "auths_gateway_kernel.construct.form_piece_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::form_piece_valid", @@ -1149,7 +1149,7 @@ "reducible": false }, { - "def_id": 43, + "def_id": 46, "lean_name": "auths_gateway_kernel.construct.form_pieces_valid_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::form_pieces_valid", @@ -1174,7 +1174,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.form_pieces_valid" }, { - "def_id": 43, + "def_id": 46, "lean_name": "auths_gateway_kernel.construct.form_pieces_valid_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::form_pieces_valid", @@ -1199,7 +1199,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.form_pieces_valid" }, { - "def_id": 43, + "def_id": 46, "lean_name": "auths_gateway_kernel.construct.form_pieces_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::form_pieces_valid", @@ -1216,7 +1216,7 @@ "reducible": true }, { - "def_id": 88, + "def_id": 92, "lean_name": "auths_gateway_kernel.construct.append_form_piece", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_piece", @@ -1233,7 +1233,7 @@ "reducible": false }, { - "def_id": 45, + "def_id": 48, "lean_name": "auths_gateway_kernel.construct.append_form_pieces_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_pieces", @@ -1258,7 +1258,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_form_pieces" }, { - "def_id": 45, + "def_id": 48, "lean_name": "auths_gateway_kernel.construct.append_form_pieces_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_pieces", @@ -1283,7 +1283,7 @@ "parent_lean_name": "auths_gateway_kernel.construct.append_form_pieces" }, { - "def_id": 45, + "def_id": 48, "lean_name": "auths_gateway_kernel.construct.append_form_pieces", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::construct::append_form_pieces", @@ -1375,8 +1375,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 387, - "end_line": 393 + "begin_line": 367, + "end_line": 373 }, "is_opaque": false, "can_fail": true, @@ -1385,15 +1385,15 @@ "reducible": false }, { - "def_id": 54, + "def_id": 57, "lean_name": "auths_gateway_kernel.order.go", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::go", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 397, - "end_line": 406 + "begin_line": 377, + "end_line": 386 }, "is_opaque": false, "can_fail": true, @@ -1402,15 +1402,15 @@ "reducible": false }, { - "def_id": 53, + "def_id": 56, "lean_name": "auths_gateway_kernel.order.stop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::stop", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 410, - "end_line": 412 + "begin_line": 390, + "end_line": 392 }, "is_opaque": false, "can_fail": true, @@ -1426,8 +1426,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 416, - "end_line": 418 + "begin_line": 396, + "end_line": 398 }, "is_opaque": false, "can_fail": true, @@ -1436,32 +1436,15 @@ "reducible": false }, { - "def_id": 67, + "def_id": 63, "lean_name": "auths_gateway_kernel.order.not_entered", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::not_entered", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 422, - "end_line": 428 - }, - "is_opaque": false, - "can_fail": true, - "can_diverge": false, - "is_rec": false, - "reducible": false - }, - { - "def_id": 60, - "lean_name": "auths_gateway_kernel.order.lease_failed", - "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", - "rust_name": "auths_gateway_kernel::order::lease_failed", - "is_local": true, - "source": { - "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 433, - "end_line": 439 + "begin_line": 402, + "end_line": 408 }, "is_opaque": false, "can_fail": true, @@ -1470,15 +1453,15 @@ "reducible": false }, { - "def_id": 94, + "def_id": 98, "lean_name": "auths_gateway_kernel.order.after_reads", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_reads", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 445, - "end_line": 451 + "begin_line": 414, + "end_line": 420 }, "is_opaque": false, "can_fail": true, @@ -1487,15 +1470,15 @@ "reducible": false }, { - "def_id": 93, + "def_id": 97, "lean_name": "auths_gateway_kernel.order.ceiling_from", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::ceiling_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 455, - "end_line": 461 + "begin_line": 424, + "end_line": 430 }, "is_opaque": false, "can_fail": true, @@ -1504,32 +1487,15 @@ "reducible": false }, { - "def_id": 107, + "def_id": 105, "lean_name": "auths_gateway_kernel.order.pre_entry_from", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::pre_entry_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 465, - "end_line": 471 - }, - "is_opaque": false, - "can_fail": true, - "can_diverge": false, - "is_rec": false, - "reducible": false - }, - { - "def_id": 101, - "lean_name": "auths_gateway_kernel.order.after_credentials", - "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", - "rust_name": "auths_gateway_kernel::order::after_credentials", - "is_local": true, - "source": { - "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 476, - "end_line": 483 + "begin_line": 434, + "end_line": 440 }, "is_opaque": false, "can_fail": true, @@ -1538,15 +1504,15 @@ "reducible": false }, { - "def_id": 92, + "def_id": 96, "lean_name": "auths_gateway_kernel.order.denied_from", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::denied_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 487, - "end_line": 497 + "begin_line": 444, + "end_line": 450 }, "is_opaque": false, "can_fail": true, @@ -1555,15 +1521,15 @@ "reducible": false }, { - "def_id": 61, + "def_id": 64, "lean_name": "auths_gateway_kernel.order.after_prefix", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_prefix", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 501, - "end_line": 507 + "begin_line": 454, + "end_line": 460 }, "is_opaque": false, "can_fail": true, @@ -1572,15 +1538,15 @@ "reducible": false }, { - "def_id": 55, + "def_id": 58, "lean_name": "auths_gateway_kernel.order.after_admission", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_admission", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 511, - "end_line": 517 + "begin_line": 464, + "end_line": 470 }, "is_opaque": false, "can_fail": true, @@ -1589,15 +1555,15 @@ "reducible": false }, { - "def_id": 57, + "def_id": 60, "lean_name": "auths_gateway_kernel.order.pre_claim", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::pre_claim", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 521, - "end_line": 527 + "begin_line": 474, + "end_line": 480 }, "is_opaque": false, "can_fail": true, @@ -1606,15 +1572,15 @@ "reducible": false }, { - "def_id": 56, + "def_id": 59, "lean_name": "auths_gateway_kernel.order.after_claim", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_claim", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 531, - "end_line": 542 + "begin_line": 484, + "end_line": 491 }, "is_opaque": false, "can_fail": true, @@ -1623,15 +1589,15 @@ "reducible": false }, { - "def_id": 58, + "def_id": 61, "lean_name": "auths_gateway_kernel.order.after_account", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_account", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 546, - "end_line": 556 + "begin_line": 495, + "end_line": 501 }, "is_opaque": false, "can_fail": true, @@ -1640,15 +1606,15 @@ "reducible": false }, { - "def_id": 59, + "def_id": 62, "lean_name": "auths_gateway_kernel.order.after_denied", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_denied", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 560, - "end_line": 577 + "begin_line": 505, + "end_line": 517 }, "is_opaque": false, "can_fail": true, @@ -1657,15 +1623,15 @@ "reducible": false }, { - "def_id": 62, + "def_id": 65, "lean_name": "auths_gateway_kernel.order.after_pre_entry", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_pre_entry", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 581, - "end_line": 587 + "begin_line": 521, + "end_line": 527 }, "is_opaque": false, "can_fail": true, @@ -1691,15 +1657,15 @@ "reducible": false }, { - "def_id": 63, + "def_id": 66, "lean_name": "auths_gateway_kernel.order.after_ceiling", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_ceiling", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 592, - "end_line": 605 + "begin_line": 532, + "end_line": 545 }, "is_opaque": false, "can_fail": true, @@ -1708,15 +1674,15 @@ "reducible": false }, { - "def_id": 64, + "def_id": 67, "lean_name": "auths_gateway_kernel.order.after_write", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_write", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 609, - "end_line": 615 + "begin_line": 549, + "end_line": 554 }, "is_opaque": false, "can_fail": true, @@ -1725,32 +1691,15 @@ "reducible": false }, { - "def_id": 65, + "def_id": 68, "lean_name": "auths_gateway_kernel.order.after_response", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::order::after_response", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 619, - "end_line": 634 - }, - "is_opaque": false, - "can_fail": true, - "can_diverge": false, - "is_rec": false, - "reducible": false - }, - { - "def_id": 66, - "lean_name": "auths_gateway_kernel.order.after_read_back", - "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", - "rust_name": "auths_gateway_kernel::order::after_read_back", - "is_local": true, - "source": { - "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 638, - "end_line": 648 + "begin_line": 558, + "end_line": 563 }, "is_opaque": false, "can_fail": true, @@ -1766,8 +1715,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 653, - "end_line": 705 + "begin_line": 568, + "end_line": 620 }, "is_opaque": false, "can_fail": true, @@ -1783,8 +1732,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 710, - "end_line": 766 + "begin_line": 625, + "end_line": 667 }, "is_opaque": false, "can_fail": true, @@ -1800,8 +1749,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 772, - "end_line": 840 + "begin_line": 673, + "end_line": 742 }, "is_opaque": false, "can_fail": true, @@ -1817,8 +1766,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 846, - "end_line": 873 + "begin_line": 748, + "end_line": 772 }, "is_opaque": false, "can_fail": true, @@ -1912,15 +1861,15 @@ "reducible": false }, { - "def_id": 71, + "def_id": 69, "lean_name": "auths_gateway_kernel.transition.absent", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::absent", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 89, - "end_line": 91 + "begin_line": 113, + "end_line": 115 }, "is_opaque": false, "can_fail": true, @@ -1929,15 +1878,15 @@ "reducible": false }, { - "def_id": 68, + "def_id": 81, "lean_name": "auths_gateway_kernel.transition.same_bytes_from_loop.body", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::same_bytes_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 97, - "end_line": 104 + "begin_line": 121, + "end_line": 128 }, "is_opaque": false, "can_fail": true, @@ -1954,15 +1903,15 @@ "parent_lean_name": "auths_gateway_kernel.transition.same_bytes_from" }, { - "def_id": 68, + "def_id": 81, "lean_name": "auths_gateway_kernel.transition.same_bytes_from_loop", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::same_bytes_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 97, - "end_line": 104 + "begin_line": 121, + "end_line": 128 }, "is_opaque": false, "can_fail": true, @@ -1979,15 +1928,15 @@ "parent_lean_name": "auths_gateway_kernel.transition.same_bytes_from" }, { - "def_id": 68, + "def_id": 81, "lean_name": "auths_gateway_kernel.transition.same_bytes_from", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::same_bytes_from", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 95, - "end_line": 104 + "begin_line": 119, + "end_line": 128 }, "is_opaque": false, "can_fail": true, @@ -1996,15 +1945,15 @@ "reducible": true }, { - "def_id": 27, + "def_id": 30, "lean_name": "auths_gateway_kernel.transition.same_bytes", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::same_bytes", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 108, - "end_line": 114 + "begin_line": 132, + "end_line": 138 }, "is_opaque": false, "can_fail": true, @@ -2013,15 +1962,15 @@ "reducible": false }, { - "def_id": 70, + "def_id": 80, "lean_name": "auths_gateway_kernel.transition.resolves_unknown", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::resolves_unknown", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 119, - "end_line": 124 + "begin_line": 143, + "end_line": 148 }, "is_opaque": false, "can_fail": true, @@ -2030,15 +1979,15 @@ "reducible": false }, { - "def_id": 80, + "def_id": 79, "lean_name": "auths_gateway_kernel.transition.has_link", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::has_link", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 128, - "end_line": 133 + "begin_line": 152, + "end_line": 157 }, "is_opaque": false, "can_fail": true, @@ -2047,15 +1996,15 @@ "reducible": false }, { - "def_id": 74, + "def_id": 73, "lean_name": "auths_gateway_kernel.transition.refusal_stage", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::refusal_stage", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 137, - "end_line": 146 + "begin_line": 161, + "end_line": 172 }, "is_opaque": false, "can_fail": true, @@ -2064,15 +2013,15 @@ "reducible": false }, { - "def_id": 75, + "def_id": 74, "lean_name": "auths_gateway_kernel.transition.requires_response", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::requires_response", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 150, - "end_line": 155 + "begin_line": 176, + "end_line": 186 }, "is_opaque": false, "can_fail": true, @@ -2081,15 +2030,15 @@ "reducible": false }, { - "def_id": 76, + "def_id": 75, "lean_name": "auths_gateway_kernel.transition.permits_response", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::permits_response", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 159, - "end_line": 164 + "begin_line": 190, + "end_line": 199 }, "is_opaque": false, "can_fail": true, @@ -2098,15 +2047,15 @@ "reducible": false }, { - "def_id": 77, + "def_id": 76, "lean_name": "auths_gateway_kernel.transition.observed_stage", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::observed_stage", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 168, - "end_line": 177 + "begin_line": 203, + "end_line": 214 }, "is_opaque": false, "can_fail": true, @@ -2115,15 +2064,15 @@ "reducible": false }, { - "def_id": 79, + "def_id": 78, "lean_name": "auths_gateway_kernel.transition.provider_stage", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::provider_stage", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 181, - "end_line": 190 + "begin_line": 218, + "end_line": 229 }, "is_opaque": false, "can_fail": true, @@ -2132,15 +2081,15 @@ "reducible": false }, { - "def_id": 78, + "def_id": 77, "lean_name": "auths_gateway_kernel.transition.has_reading", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::has_reading", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 203, - "end_line": 208 + "begin_line": 244, + "end_line": 249 }, "is_opaque": false, "can_fail": true, @@ -2149,15 +2098,66 @@ "reducible": false }, { - "def_id": 33, + "def_id": 71, + "lean_name": "auths_gateway_kernel.transition.requires_entry", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::requires_entry", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 336, + "end_line": 346 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": false, + "is_rec": false, + "reducible": false + }, + { + "def_id": 72, + "lean_name": "auths_gateway_kernel.transition.acknowledgement_stage", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::acknowledgement_stage", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 278, + "end_line": 280 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": false, + "is_rec": false, + "reducible": false + }, + { + "def_id": 70, + "lean_name": "auths_gateway_kernel.transition.protocol_consistent", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::protocol_consistent", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 285, + "end_line": 321 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": false, + "is_rec": false, + "reducible": false + }, + { + "def_id": 28, "lean_name": "auths_gateway_kernel.transition.consistent", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::consistent", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 217, - "end_line": 228 + "begin_line": 258, + "end_line": 274 }, "is_opaque": false, "can_fail": true, @@ -2166,15 +2166,32 @@ "reducible": false }, { - "def_id": 29, + "def_id": 27, + "lean_name": "auths_gateway_kernel.transition.same_protocol", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::same_protocol", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 325, + "end_line": 332 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": false, + "is_rec": false, + "reducible": false + }, + { + "def_id": 32, "lean_name": "auths_gateway_kernel.transition.stage_transition_allowed", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::stage_transition_allowed", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 235, - "end_line": 260 + "begin_line": 352, + "end_line": 373 }, "is_opaque": false, "can_fail": true, @@ -2183,15 +2200,15 @@ "reducible": false }, { - "def_id": 72, + "def_id": 83, "lean_name": "auths_gateway_kernel.transition.adds_pre_entry", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::adds_pre_entry", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 265, - "end_line": 280 + "begin_line": 377, + "end_line": 379 }, "is_opaque": false, "can_fail": true, @@ -2200,15 +2217,15 @@ "reducible": false }, { - "def_id": 73, + "def_id": 84, "lean_name": "auths_gateway_kernel.transition.adds_response", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::adds_response", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 284, - "end_line": 300 + "begin_line": 383, + "end_line": 385 }, "is_opaque": false, "can_fail": true, @@ -2217,15 +2234,15 @@ "reducible": false }, { - "def_id": 30, + "def_id": 33, "lean_name": "auths_gateway_kernel.transition.checkpoint_valid", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::checkpoint_valid", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 305, - "end_line": 321 + "begin_line": 389, + "end_line": 395 }, "is_opaque": false, "can_fail": true, @@ -2234,15 +2251,32 @@ "reducible": false }, { - "def_id": 31, + "def_id": 29, + "lean_name": "auths_gateway_kernel.transition.entry_kept", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::entry_kept", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 399, + "end_line": 405 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": true, + "is_rec": false, + "reducible": false + }, + { + "def_id": 34, "lean_name": "auths_gateway_kernel.transition.pre_entry_kept", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::pre_entry_kept", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 326, - "end_line": 332 + "begin_line": 410, + "end_line": 416 }, "is_opaque": false, "can_fail": true, @@ -2251,15 +2285,15 @@ "reducible": false }, { - "def_id": 32, + "def_id": 35, "lean_name": "auths_gateway_kernel.transition.response_kept", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::response_kept", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 337, - "end_line": 340 + "begin_line": 421, + "end_line": 424 }, "is_opaque": false, "can_fail": true, @@ -2268,15 +2302,32 @@ "reducible": false }, { - "def_id": 69, + "def_id": 36, + "lean_name": "auths_gateway_kernel.transition.acknowledgement_kept", + "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", + "rust_name": "auths_gateway_kernel::transition::acknowledgement_kept", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 429, + "end_line": 436 + }, + "is_opaque": false, + "can_fail": true, + "can_diverge": true, + "is_rec": false, + "reducible": false + }, + { + "def_id": 82, "lean_name": "auths_gateway_kernel.transition.link_equal", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::link_equal", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 350, - "end_line": 365 + "begin_line": 459, + "end_line": 474 }, "is_opaque": false, "can_fail": true, @@ -2285,15 +2336,15 @@ "reducible": false }, { - "def_id": 28, + "def_id": 31, "lean_name": "auths_gateway_kernel.transition.plan_kept", "lean_file": "qualification/aeneas/generated/gateway/Funs.lean", "rust_name": "auths_gateway_kernel::transition::plan_kept", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 344, - "end_line": 346 + "begin_line": 453, + "end_line": 455 }, "is_opaque": false, "can_fail": true, @@ -2309,8 +2360,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 373, - "end_line": 381 + "begin_line": 482, + "end_line": 496 }, "is_opaque": false, "can_fail": true, @@ -2381,7 +2432,7 @@ } }, { - "def_id": 34, + "def_id": 35, "lean_name": "auths_gateway_kernel.construct.AccountScopePlan", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::construct::AccountScopePlan", @@ -2405,7 +2456,7 @@ } }, { - "def_id": 32, + "def_id": 33, "lean_name": "auths_gateway_kernel.construct.JsonPiece", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::construct::JsonPiece", @@ -2417,7 +2468,7 @@ } }, { - "def_id": 33, + "def_id": 34, "lean_name": "auths_gateway_kernel.construct.FormPiece", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::construct::FormPiece", @@ -2500,18 +2551,6 @@ "end_line": 207 } }, - { - "def_id": 35, - "lean_name": "auths_gateway_kernel.order.Mode", - "lean_file": "qualification/aeneas/generated/gateway/Types.lean", - "rust_name": "auths_gateway_kernel::order::Mode", - "is_local": true, - "source": { - "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 34, - "end_line": 41 - } - }, { "def_id": 23, "lean_name": "auths_gateway_kernel.order.SubmitPlan", @@ -2520,8 +2559,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 50, - "end_line": 63 + "begin_line": 39, + "end_line": 52 } }, { @@ -2532,8 +2571,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 67, - "end_line": 116 + "begin_line": 56, + "end_line": 103 } }, { @@ -2544,8 +2583,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 120, - "end_line": 128 + "begin_line": 107, + "end_line": 115 } }, { @@ -2556,8 +2595,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 132, - "end_line": 141 + "begin_line": 119, + "end_line": 128 } }, { @@ -2568,8 +2607,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 145, - "end_line": 154 + "begin_line": 132, + "end_line": 141 } }, { @@ -2580,8 +2619,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 158, - "end_line": 165 + "begin_line": 145, + "end_line": 152 } }, { @@ -2592,8 +2631,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 169, - "end_line": 176 + "begin_line": 156, + "end_line": 163 } }, { @@ -2604,8 +2643,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 180, - "end_line": 187 + "begin_line": 167, + "end_line": 174 } }, { @@ -2616,8 +2655,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 191, - "end_line": 201 + "begin_line": 178, + "end_line": 188 } }, { @@ -2628,8 +2667,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 205, - "end_line": 212 + "begin_line": 192, + "end_line": 197 } }, { @@ -2640,8 +2679,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 216, - "end_line": 224 + "begin_line": 201, + "end_line": 206 } }, { @@ -2652,8 +2691,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 228, - "end_line": 267 + "begin_line": 210, + "end_line": 249 } }, { @@ -2664,8 +2703,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 271, - "end_line": 300 + "begin_line": 253, + "end_line": 282 } }, { @@ -2676,8 +2715,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 304, - "end_line": 323 + "begin_line": 286, + "end_line": 305 } }, { @@ -2688,8 +2727,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 327, - "end_line": 374 + "begin_line": 309, + "end_line": 354 } }, { @@ -2700,8 +2739,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/order.rs", - "begin_line": 378, - "end_line": 383 + "begin_line": 358, + "end_line": 363 } }, { @@ -2717,7 +2756,7 @@ } }, { - "def_id": 31, + "def_id": 32, "lean_name": "auths_gateway_kernel.recovery.IdempotencyKind", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::recovery::IdempotencyKind", @@ -2790,14 +2829,26 @@ }, { "def_id": 29, + "lean_name": "auths_gateway_kernel.transition.Protocol", + "lean_file": "qualification/aeneas/generated/gateway/Types.lean", + "rust_name": "auths_gateway_kernel::transition::Protocol", + "is_local": true, + "source": { + "file": "product/runtime/auths-gateway-kernel/src/transition.rs", + "begin_line": 19, + "end_line": 26 + } + }, + { + "def_id": 30, "lean_name": "auths_gateway_kernel.transition.Stage", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::transition::Stage", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 19, - "end_line": 32 + "begin_line": 30, + "end_line": 47 } }, { @@ -2808,20 +2859,20 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 36, - "end_line": 45 + "begin_line": 51, + "end_line": 60 } }, { - "def_id": 30, + "def_id": 31, "lean_name": "auths_gateway_kernel.transition.Link", "lean_file": "qualification/aeneas/generated/gateway/Types.lean", "rust_name": "auths_gateway_kernel::transition::Link", "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 49, - "end_line": 56 + "begin_line": 64, + "end_line": 71 } }, { @@ -2832,8 +2883,8 @@ "is_local": true, "source": { "file": "product/runtime/auths-gateway-kernel/src/transition.rs", - "begin_line": 60, - "end_line": 81 + "begin_line": 75, + "end_line": 105 } } ], diff --git a/formal/qualification/aeneas/qualification.toml b/formal/qualification/aeneas/qualification.toml index 62cc62aad..e1ca72405 100644 --- a/formal/qualification/aeneas/qualification.toml +++ b/formal/qualification/aeneas/qualification.toml @@ -397,7 +397,7 @@ allowed_external_symbols = [] [[translations]] crate_name = "auths_gateway_kernel" translation_json = "formal/qualification/aeneas/generated/gateway/translation.json" -local_functions = 123 +local_functions = 126 external_functions = 0 opaque_local_functions = 0 required_symbols = [ @@ -414,6 +414,12 @@ required_symbols = [ "auths_gateway_kernel::order::after_ceiling", "auths_gateway_kernel::transition::valid_transition", "auths_gateway_kernel::transition::consistent", + "auths_gateway_kernel::transition::protocol_consistent", + "auths_gateway_kernel::transition::entry_kept", + "auths_gateway_kernel::transition::acknowledgement_kept", + "auths_gateway_kernel::transition::acknowledgement_stage", + "auths_gateway_kernel::transition::requires_entry", + "auths_gateway_kernel::transition::same_protocol", "auths_gateway_kernel::transition::stage_transition_allowed", "auths_gateway_kernel::ratio::relative_basis", "auths_gateway_kernel::ratio::relative_ceiling_admits", diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index a5d79474b..f8ef9159e 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "dee421e6130ea9cf33df179a6235d4ee1be66a91a382b1b260a733bf4128c33b", + "digest": "a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825", "files": [ { "path": ".cargo/config.toml", @@ -81,7 +81,7 @@ }, { "path": "formal/qualification/aeneas/cases/Gateway.lean", - "sha256": "a6d3148ab9ad313a0d00b92313d6fb2bc70a131759e5ccffb9d6f5e028738264" + "sha256": "094648470bdda3587c346a4c7ae1a29c115be613d589bd7a69dc2141d34303bc" }, { "path": "formal/qualification/aeneas/cases/Lifecycle.lean", @@ -93,7 +93,7 @@ }, { "path": "formal/qualification/aeneas/qualification.toml", - "sha256": "38aa0babb5be3ac958c7e91f0640ad0ae3b6e4f265257642976dfe8bd3330850" + "sha256": "1da6c96a8d64598ff8a6999d6834e4f78fc0dee69d8c56ab3f69c37ecf436d58" }, { "path": "formal/translation-toolchain.lock", @@ -337,7 +337,7 @@ }, { "path": "xtask/src/formal_qualification.rs", - "sha256": "1826078f21dbf946801413cb6cf1f66dfd7495c9de3853455fbf2eb151f899e6" + "sha256": "034db8c0080be9fa60eab6e445313ed5bc1371d27cbb448fa4f3b88d9e38c1fc" }, { "path": "xtask/src/fuzz.rs", diff --git a/xtask/src/formal_qualification.rs b/xtask/src/formal_qualification.rs index 4acb600b5..0512ee0b1 100644 --- a/xtask/src/formal_qualification.rs +++ b/xtask/src/formal_qualification.rs @@ -12,8 +12,10 @@ use std::{ const QUALIFICATION_PATH: &str = "formal/qualification/aeneas/qualification.toml"; const QUALIFICATION_SCHEMA: &str = "auths-proof-aeneas-qualification/v1"; +// AP074: 126 gateway locals, including all six durable-entry/protocol/ACK helpers. +// External models, opaque/external counts, warning and axiom inventories are unchanged. const QUALIFICATION_BOUNDARY_CONTRACT_SHA256: &str = - "bd588f183a80542bc1f6f1990e0cae4aefa149f304693d37e535208266bbb553"; + "5af27f70738b276ceb61d5994b054c12bd03b764f864335707e3d8d2987926da"; const AENEAS_OUTPUT_MAPPINGS: &[(&str, &str)] = &[ ( From ab36e4b76420a37912d00b2c5b1fac1ad6c556c5 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 11:44:12 +0000 Subject: [PATCH 078/136] chore(assurance): record integrated AP074 fault and formal evidence --- docs/plans/0074-implementation-status.md | 51 ++++++++++++++++++- ...ound-effects-and-recovery-state-machine.md | 1 + release/semantic-freeze-versions.toml | 12 ++--- release/semantic-freeze.json | 22 ++++---- 4 files changed, 68 insertions(+), 18 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index f4f9cba1a..15ab3e241 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2084,6 +2084,55 @@ closure regeneration passed after that correction (one artifact-generation test) contract142 and public surface399 subjects. Fresh hosted exact-head evidence remains required; source-identity counters are not formal acceptance evidence. +## Formal translation and recovery correspondence repair + +- Integrated isolated formal repair `ffa982fa` as `884b5bd9`. The hosted + translation failure on `af01d376` exposed an obsolete 123-function inventory + and a model still using Attempting/implicit read-back. The shipping kernel + already has the direct Reserved/EntryGranted cutover; the model, generated + translation, exact refinement and assurance inventory now describe that + implementation together. This repair changes no shipping runtime behavior. +- Reviewed inventory126 adds six closed protocol/grant/ACK checks and removes + three obsolete mode/implicit-read helpers. External and opaque local functions + remain zero. The reviewed qualification boundary digest was explicitly renewed + for that inventory change; tool pins, warnings, four existing external models, + axiom policy and CFG parity requirements remain intact. +- The natural attempt model includes three protocols, JSON-safe bounded revision, + immutable grant and ACK evidence. Exact translated refinement covers every pair + of views including revision overflow. Separate late-response and late-recipient- + ACK theorems retain source/grant lineage without asserting provider observation; + the complete unknown-exit theorem retains strict linked-evidence requirements + for ObservedByProvider. Submission ordering proves durable grant before send, + one send at most, no post-send NotEntered/refund, no implicit response read, + and stored replay without a new send. Runtime signature/challenge/provenance, + filesystem/database atomicity and physical I/O remain separate obligations. +- Isolated source reproduction passed both authored models, exact refinement, + full pinned Lean build (3,305 jobs), all eight qualification case modules, + two clean byte-identical translations, and a compiled transitive axiom audit + of329 statements: seven added, seven updated,315 unchanged, none removed. + Only the existing propext/Quot.sound/Classical.choice foundational axioms occur. + The boundary-pin unit test passed1/1 and the staged v8.28 secret scan passed. +- Final non-update `cargo xtask formal --skip-kani` passed existing qualification, + 329-claim audit, byte-stable semantic vectors,4/4 Rust refinement tests and the + 49/49 Kani harness inventory. Bounded Kani was deliberately not duplicated + locally; the prior published head's hosted Kani job passed, and the next exact + head still requires hosted verification. Mutation campaign snapshots remain + explicitly stale pre-release evidence rather than newly passed campaigns. +- The integration's sole generated source-closure conflict was resolved using + the source generator. Its output exactly equals the reviewed formal batch; + no digest was hand-edited. Main's independently generated gateway closure and + native fault/concurrency fixtures remain separate evidence. A20 and the full + AP074 acceptance/performance gates remain incomplete. + +- On the combined checkout, the required proof-coverage generator reproduced + study006 byte-for-byte and emitted unchanged current coverage artifacts + (110/1,031 decision-scope functions and1,289/11,353 code lines). The added native + test/fault scaffolding is not advertised as proved decision code. Release + freeze400 advances only the changed formal assurance-manifest61, generated + translations20, qualification17, formal source-closure105 and public-surface400 + subjects. Identity protocol145 and public SDK142 remain unchanged by this + formal-only integration. No full acceptance gate is declared closed. + ## Phase gates | Phase | State | Outstanding gate | @@ -2121,7 +2170,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / independent references retained / no complete differential corpus | Preserve AP070 reference independence; complete comparable native contracts without broker migration | -| A20 | Generated histories and shipping predicate refinement | Partial / 576 typed stage pairs, ACK histories and Kani source / pure corpus executed | Full generated concurrent histories and source-linked formal artifacts pending | +| A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 4f607bd11..9e7eadd09 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -803,6 +803,7 @@ stateDiagram-v2 EntryGranted --> Acknowledged: disclosure ACK ResponseRecorded --> Observed: separate supported observation Unknown --> Observed: sufficient reconciliation evidence + Unknown --> ResponseRecorded: late exact source response Unknown --> Acknowledged: late exact disclosure ACK ``` diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index dabbedf2f..8950b1fd0 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 399 +freeze_version = 400 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -16,10 +16,10 @@ freeze_version = 399 "auths.frozen-bytes/core/fixtures/v1/manifest.json" = 15 "auths.frozen-bytes/core/formal-vectors/v1/manifest.json" = 1 "auths.frozen-bytes/demos/benchmarks/profiles/release.toml" = 1 -"auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 60 -"auths.frozen-bytes/formal/qualification/aeneas/generated" = 19 -"auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 16 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 104 +"auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 61 +"auths.frozen-bytes/formal/qualification/aeneas/generated" = 20 +"auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 17 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 105 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -67,4 +67,4 @@ freeze_version = 399 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 399 +"auths.release.public-surface" = 400 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 42064cee3..b96efa407 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 399, + "freezeVersion": 400, "publicSurface": { "rustRoots": [ "auths", @@ -202,7 +202,7 @@ }, { "id": "auths.frozen-bytes/formal/assurance-manifest-v1.toml", - "version": 60, + "version": 61, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -210,11 +210,11 @@ "owners": [ "formal/assurance-manifest-v1.toml" ], - "sha256": "9c87a1e33590bb42f5648eee35bee7f03c388a366c39628643e944b0d934a0c1" + "sha256": "fb433d8499edfac344628efc44a87446383ab4e6094f9050e5481e869a5c703e" }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/generated", - "version": 19, + "version": 20, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -222,11 +222,11 @@ "owners": [ "formal/qualification/aeneas/generated" ], - "sha256": "37024149c5f4ad4a2587a8f0f2e636d1e332fdd379195dd2e24de03069be3ddc" + "sha256": "752dc9ca5c403c5b4e30f7b943cc467c9f61a44e611affba7896b1cbb559e6f0" }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml", - "version": 16, + "version": 17, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -234,11 +234,11 @@ "owners": [ "formal/qualification/aeneas/qualification.toml" ], - "sha256": "9938d4c91f7c7839d3e5363fb6536730b62981e545bc9867507324cb2c3c17d6" + "sha256": "e11d355e9c0429b234c3d9e64d720ac522847eb175c2a2f48b06f0f2a03f2109" }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 104, + "version": 105, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "68589b4fbdbe61823fc9ed8d77d38a8a3e1f0f00a66e197784d5fa1f9f0f732a" + "sha256": "a9a3872b798dce65bcb9e8517f3cc7016d2f0417a8d402a6affaa51c68a98160" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 399, + "version": 400, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "1d5d88c2647aaf515f218cea7a270b95f2df5b4913bfc2571fc0b74f5445b2e7" + "sha256": "426e8fed82bbda57ec7f4cfdb50c2b14403b06b2aab6619a3f14ad7e7c541dee" } ] } From b0d2ab41ed77f986e2b6593fac3a5214f560382b Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 12:13:39 +0000 Subject: [PATCH 079/136] test(gateway): exercise real PostgreSQL commit reply loss over TLS --- .github/workflows/postgres-lifecycle.yml | 1 + .../native-postgres-commit-reply-loss.json | 191 +++++ compliance.toml | 1 + docs/plans/0074-implementation-status.md | 81 +- ...ound-effects-and-recovery-state-machine.md | 11 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/lib.rs | 3 + .../src/native_postgres_commit_proxy.rs | 188 +++++ .../src/native_postgres_commit_tests.rs | 695 ++++++++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/src/store_testkit.rs | 7 + release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 13 files changed, 1190 insertions(+), 14 deletions(-) create mode 100644 bindings/fixtures/gateway/native-postgres-commit-reply-loss.json create mode 100644 product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs create mode 100644 product/runtime/auths-gateway/src/native_postgres_commit_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 6537bca49..401a4fd70 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -51,6 +51,7 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-postgres-commit-reply-loss.json b/bindings/fixtures/gateway/native-postgres-commit-reply-loss.json new file mode 100644 index 000000000..231498d44 --- /dev/null +++ b/bindings/fixtures/gateway/native-postgres-commit-reply-loss.json @@ -0,0 +1,191 @@ +{ + "schema": "auths.native-postgres-commit-reply-loss/1", + "scope": "full native acquisition engine in separate OS workers; actual TLS PostgreSQL COMMIT paused by a schema-local deferred trigger, opaque TCP reply suppression/disconnection and independent committed/aborted-state observation; real bounded authority/exact approvals, local custody and HTTP; fixed public test keys and maintained clock", + "excluded": [ + "TLS decryption or forged adapter error", + "PostgreSQL power failure or whole-store rollback", + "mutation/disclosure commit fault matrices", + "hostile OS containment or human review", + "live provider qualification" + ], + "cases": [ + { + "schedule": { + "phase": "admission", + "outcome": "committed" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": "reserved", + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 0, + "new_execution_allowed": true, + "actual_http_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "admission", + "outcome": "aborted" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": null, + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 0, + "new_execution_allowed": true, + "actual_http_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "entry", + "outcome": "committed" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": "entry-granted", + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 0, + "new_execution_allowed": false, + "actual_http_reads_after_reopen": 0, + "native_history": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "entry", + "outcome": "aborted" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": "reserved", + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 0, + "new_execution_allowed": true, + "actual_http_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "response", + "outcome": "committed" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": "content-response-recorded", + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 1, + "new_execution_allowed": false, + "actual_http_reads_after_reopen": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + }, + { + "schedule": { + "phase": "response", + "outcome": "aborted" + }, + "commit_observed_at_server_deferred_trigger": true, + "actual_adapter_commit_error": true, + "independently_observed_retained_phase": "entry-granted", + "end_to_end_tls_preserved": true, + "actual_http_reads_before_reopen": 1, + "new_execution_allowed": false, + "actual_http_reads_after_reopen": 1, + "native_history": { + "revision": 2, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "one_allocation_count_and_sum_slot": true, + "terminal_journal_and_execution_witness_unchanged": true, + "signed_inputs_unchanged": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 031c7b01d..001e45b1a 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1812,6 +1812,7 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", + "product/runtime/auths-gateway/src/native_postgres_commit_tests.rs#postgres_native_commit_reply_loss_fixture_is_current", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 15ab3e241..002c3fb62 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2133,6 +2133,85 @@ closure regeneration passed after that correction (one artifact-generation test) subjects. Identity protocol145 and public SDK142 remain unchanged by this formal-only integration. No full acceptance gate is declared closed. +## Native PostgreSQL COMMIT-reply loss checkpoint + +- `native_postgres_commit_tests.rs` and its private opaque TCP proxy author six + full native acquisition histories: actual commit success versus actual backend + abort during admission, entry-grant persistence and response persistence. + A schema-local deferred constraint trigger pauses the native COMMIT at a + separate advisory lock. An independent direct TLS client observes the waiting + backend through PostgreSQL locks and asserts that its pg_stat_ssl session is + encrypted. The test proxy never terminates TLS, parses SQL or fabricates a + store result; trust roots, server-name checks and native store deadlines remain + the maintained implementation's checks. +- For committed transactions, the independent observer releases the trigger, + reads the newly committed exact operation phase and confirms that server reply + bytes are withheld before disconnecting the worker's transport. For aborted + transactions, the observer terminates only the fixture backend identified by + that owned-schema barrier, verifies backend exit/rollback, then disconnects. + The real adapter returns an error at the selected native decision exactly once. + Proxy forwarding resumes for fresh pool connections; unavailable immediate + caller projection remains a typed indeterminate result rather than authority. +- Native error/custody/HTTP witnesses, unchanged signed inputs and independent + server counts verify all-or-none charges. An aborted admission leaves no claim + or allocation/counter rows. A committed admission or aborted grant retains a + charged reservation and can continue only through native fresh checks. A + committed grant with a lost acknowledgement stays charged Unknown even with + zero actual HTTP reads; it can never lease/fetch again. An aborted response + persistence retains charged Unknown after one read; a committed response + remains recorded despite reply loss. Native reopening/replay preserves every + inspected gateway-row byte and execution witness, with one permanent lifetime + allocation and one count/sum slot, no refund, no extra HTTP and no new permit. +- Initial required artifact generation passed all six real transaction/transport + histories in2.25 seconds. Strengthened independent TLS and pre-reopen row-count + assertions passed in2.36 seconds; strict gateway library/test lint passed with + no suppressions. After closure regeneration and rebuild, all seventeen + selected native artifact/helper/closure tests passed without update mode in + 6.92 seconds, including both adapters' previous capacity/crash/dependency + matrices. Their files stayed byte-identical. Dedicated fixture containers, + network and volume were stopped/removed after verification. + The explicit feature-gated PostgreSQL CI command and consumer anchor name this + matrix. No shipping adapter/kernel behavior or fault switch is introduced. +- These cases cover acquisition COMMIT reply delivery over an actual TLS + connection, with committed and aborted database outcomes. They do not claim + PostgreSQL power-loss/whole-store rollback protection, hostile OS containment, + live qualification or the full mutation/disclosure fault matrix. A06 remains + partial until those required protocol-specific schedules are complete. + +## Published ab36 hosted observation + +- The combined security/artifact, native fault/concurrency, formal correspondence + and release-identity changes were pushed non-force as + `ab36e4b76420a37912d00b2c5b1fac1ad6c556c5` to the open draft PR213. + At the first observed checkpoint all12 non-main/non-live workflows passed; + the main CI workflow is still running with76 successful checks,8 conditional + skips and no failures. Pending checks are not passes. Custody-live is skipped + and provides no qualification evidence. +- The [exact-head PostgreSQL job](https://github.com/auths-dev/auths-proof/actions/runs/40867724293/job/123426622975) passed with actual execution of all + eleven explicit feature-gated native cases (each1passed/0ignored), the thirty + ordinary ignored PostgreSQL cases and physical/WAL restore assertions. Fresh + installed Docker Stripe/Airtable demos passed23/36 cases respectively, each + explicitly production_qualification:false. Installed Python/TypeScript platform + harnesses, SDK recipes/scaffold and independent Google images passed. Distinct + UID isolation executed and passed2/2 cases. These are evidence on ab36, not + evidence for the newer unpublished COMMIT-loss source. +- Subsequently, [authoritative implementation](https://github.com/auths-dev/auths-proof/actions/runs/40867724155/job/123431724494) + failed a CLI frame fixture that still omitted required exact approval. The CI + agent found two stale fixtures, including vacuous commissioning-field negative + cases. Its isolated repair uses the current canonical native submission and + requires approval to decode before forbidden-field checks; binary tests passed + 9/9. The full failing workspace command is being reproduced with no-fail-fast + to collect downstream roots before one batch. Later compliance and Kani jobs + passed; translation and its downstream proof/evidence remain pending. These + local CLI repairs are not yet published-head passes. +- The existing CI agent continues holistic exact-head triage. No new agent, + AP070 migration, AP073 modification, live action, merge or deployment occurred. + +- Release freeze401 advances the reported identity protocol146, public SDK + contract143 and public surface401 subjects for the new fixture/consumer + inventory. The shipping store and translated kernel are unchanged. Fresh + exact-head hosted execution is required before acceptance claims. + ## Phase gates | Phase | State | Outstanding gate | @@ -2156,7 +2235,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures and server-rejected PostgreSQL batches / fifteen file I/O fault histories and four real PostgreSQL rejected-prefix transactions executed | Ambiguous commit delivery, complete mutation/disclosure schedules and remaining durability cases required | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 9e7eadd09..ed1409ef8 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -735,6 +735,17 @@ reauthorization of the unchanged operation, followed by no-I/O terminal replay. This is real PostgreSQL transaction-abort evidence, not commit-acknowledgement ambiguity, power loss or the complete mutation/disclosure fault matrix. +`native-postgres-commit-reply-loss.json` separately exercises real lost COMMIT +replies for admission, entry and response persistence. A deferred fixture trigger +pauses the actual COMMIT; a direct TLS observer verifies the selected backend's +TLS session and distinguishes committed state from an aborted transaction. An +opaque TCP proxy withholds replies and disconnects the native client without +terminating TLS or manufacturing an adapter error. Reopening must inspect the +retained native history, continue only absent/pre-grant work through fresh native +checks and never recreate a lost grant. Charges and exact terminal rows remain +unchanged through replay. These acquisition histories do not replace the full +mutation/disclosure commit-fault matrix or establish power-loss/rollback safety. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 003cb516d..db1a2634f 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"65afa33c4c06f5a68707c9ad639a38615406fd8def7ffb41d15d9f86d47b5c59"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"eb63307671525b21f1c2d19eb3acfd2c7079e194fa2a33b6bfe7213c51299ea3"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"448512dd483139f9e7e9a70c2cb66d00e8a9d0eaf4eb38db017a7a938dbb7af8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index a9cad8618..3a58a5d6c 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -172,3 +172,6 @@ mod native_file_fault_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_postgres_fault_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_postgres_commit_tests; diff --git a/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs b/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs new file mode 100644 index 000000000..f6f82b95d --- /dev/null +++ b/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs @@ -0,0 +1,188 @@ +//! Opaque test transport: TLS remains between the native client and `PostgreSQL`. +//! No credential, SQL statement or encrypted record is decoded or synthesized. +use std::{ + io::{Read as _, Write as _}, + net::{Ipv4Addr, Shutdown, SocketAddr, TcpListener, TcpStream}, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, AtomicU64, Ordering}, + }, + thread::{self, JoinHandle}, + time::{Duration, Instant}, +}; + +struct Shared { + stop: AtomicBool, + hold: AtomicBool, + withheld: AtomicU64, + sockets: Mutex>, +} +impl Shared { + fn disconnect(&self) { + // New connections cannot register until old sockets are closed. A + // partially withheld TLS record cannot become an acknowledged COMMIT. + let mut sockets = self.sockets.lock().expect("proxy sockets"); + for socket in sockets.drain(..) { + let _ = socket.shutdown(Shutdown::Both); + } + self.hold.store(false, Ordering::SeqCst); + } +} + +fn forward(mut source: TcpStream, mut target: TcpStream, server_to_client: bool, shared: &Shared) { + let mut bytes = [0; 8_192]; + while !shared.stop.load(Ordering::SeqCst) { + let size = match source.read(&mut bytes) { + Ok(0) => break, + Ok(size) => size, + Err(error) + if matches!( + error.kind(), + std::io::ErrorKind::WouldBlock + | std::io::ErrorKind::TimedOut + | std::io::ErrorKind::Interrupted + ) => + { + continue; + } + Err(_) => break, + }; + if server_to_client && shared.hold.load(Ordering::SeqCst) { + shared.withheld.fetch_add( + u64::try_from(size).expect("bounded packet"), + Ordering::SeqCst, + ); + continue; + } + if target.write_all(&bytes[..size]).is_err() { + break; + } + } + let _ = source.shutdown(Shutdown::Both); + let _ = target.shutdown(Shutdown::Both); +} + +fn attach( + client: TcpStream, + upstream: SocketAddr, + shared: &Arc, + threads: &mut Vec>, +) { + let server = + TcpStream::connect_timeout(&upstream, Duration::from_secs(1)).expect("fixture upstream"); + for stream in [&client, &server] { + stream + .set_read_timeout(Some(Duration::from_millis(100))) + .expect("proxy poll"); + stream + .set_write_timeout(Some(Duration::from_secs(2))) + .expect("proxy deadline"); + stream.set_nodelay(true).expect("proxy latency"); + } + { + let mut sockets = shared.sockets.lock().expect("proxy registry"); + sockets.push(client.try_clone().expect("client control")); + sockets.push(server.try_clone().expect("server control")); + } + let client_read = client.try_clone().expect("client reader"); + let server_read = server.try_clone().expect("server reader"); + let outbound = shared.clone(); + threads.push(thread::spawn(move || { + forward(client_read, server, false, &outbound); + })); + let inbound = shared.clone(); + threads.push(thread::spawn(move || { + forward(server_read, client, true, &inbound); + })); +} + +pub(super) struct Proxy { + port: u16, + shared: Arc, + service: Option>, +} +impl Proxy { + pub(super) fn start(upstream_port: u16) -> Self { + let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).expect("proxy listener"); + listener.set_nonblocking(true).expect("proxy polling"); + let port = listener.local_addr().expect("proxy address").port(); + let shared = Arc::new(Shared { + stop: AtomicBool::new(false), + hold: AtomicBool::new(false), + withheld: AtomicU64::new(0), + sockets: Mutex::new(Vec::new()), + }); + let run = shared.clone(); + let service = thread::spawn(move || { + let mut threads = Vec::new(); + while !run.stop.load(Ordering::SeqCst) { + match listener.accept() { + Ok((client, _)) => attach( + client, + SocketAddr::from((Ipv4Addr::LOCALHOST, upstream_port)), + &run, + &mut threads, + ), + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(1)); + } + Err(error) => panic!("proxy accept: {error}"), + } + } + run.disconnect(); + for thread in threads { + thread.join().expect("proxy forwarding"); + } + }); + Self { + port, + shared, + service: Some(service), + } + } + pub(super) fn url(&self, original: &str) -> String { + let mut replaced = 0; + let parts: Vec<_> = original + .split_ascii_whitespace() + .map(|part| { + if part.starts_with("port=") { + replaced += 1; + format!("port={}", self.port) + } else { + part.to_owned() + } + }) + .collect(); + assert_eq!( + replaced, 1, + "the canonical fixture URL has one explicit port" + ); + parts.join(" ") + } + pub(super) fn hold_replies(&self) { + assert!(!self.shared.hold.swap(true, Ordering::SeqCst)); + assert_eq!(self.shared.withheld.load(Ordering::SeqCst), 0); + } + pub(super) fn wait_for_withheld_reply(&self) { + let deadline = Instant::now() + Duration::from_secs(1); + while self.shared.withheld.load(Ordering::SeqCst) == 0 { + assert!( + Instant::now() < deadline, + "server commit reply was not observed" + ); + thread::sleep(Duration::from_millis(1)); + } + } + pub(super) fn disconnect_and_resume(&self) { + self.shared.disconnect(); + } +} +impl Drop for Proxy { + fn drop(&mut self) { + self.shared.stop.store(true, Ordering::SeqCst); + self.shared.disconnect(); + if let Some(service) = self.service.take() { + service.join().expect("proxy service"); + } + } +} diff --git a/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs b/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs new file mode 100644 index 000000000..60feaf92d --- /dev/null +++ b/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs @@ -0,0 +1,695 @@ +//! Real lost COMMIT replies over end-to-end TLS, with independent observation +//! of both possible transaction outcomes. No adapter result is fabricated. +use crate::native_process_tests::{ + NOW, Provider, Setup, acquire, authorize_policy, load_engine, private, recipe, runtime, +}; +use crate::store::GatewayFenceDecision; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + AcquisitionSnapshot, AcquisitionStage, ArgumentCeilingPolicy, ContentHistory, + GatewayAttemptError, GatewayAttemptKey, GatewayAttemptStore, GatewayAttempts, + GatewayExecutionWitness, GatewayInsert, GatewayRecordEntry, GatewayRecordKind, + GatewaySubmitResult, LogicalOperationId, SharedConnection, +}; +use postgres::{ + Client, Config, + config::{Host, SslMode}, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + collections::BTreeMap, + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::fs::PermissionsExt as _, + path::Path, + process::{Child, Command, Stdio}, + str::FromStr as _, + sync::{ + Arc, + atomic::{AtomicU64, Ordering}, + }, + thread, + time::{Duration, Instant}, +}; + +#[path = "native_postgres_commit_proxy.rs"] +mod proxy; +use proxy::Proxy; + +const OPERATION: &str = "commit-reply-loss"; +const LOCK_GROUP: i32 = 1_095_780_184; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Phase { + Admission, + Entry, + Response, +} +impl Phase { + const fn stage(self) -> &'static str { + match self { + Self::Admission => "reserved", + Self::Entry => "entry-granted", + Self::Response => "content-response-recorded", + } + } +} +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Outcome { + Committed, + Aborted, +} +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + outcome: Outcome, +} +impl Schedule { + const fn retained(self) -> Option<&'static str> { + match self.outcome { + Outcome::Committed => Some(self.phase.stage()), + Outcome::Aborted => match self.phase { + Phase::Admission => None, + Phase::Entry => Some("reserved"), + Phase::Response => Some("entry-granted"), + }, + } + } + fn resumable(self) -> bool { + matches!(self.retained(), None | Some("reserved")) + } + fn stage(self) -> AcquisitionStage { + match self.retained() { + Some("reserved") => AcquisitionStage::Reserved, + Some("content-response-recorded") => AcquisitionStage::ResponseRecorded, + _ => AcquisitionStage::Unknown, + } + } + fn reads(self) -> usize { + usize::from(matches!(self.phase, Phase::Response)) + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct CommitSetup { + installation: Setup, + schedule: Schedule, +} + +fn key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") +} + +/// Records only actual adapter errors after the unchanged native decision. +struct CommitWitness { + inner: Arc, + phase: Phase, + errors: AtomicU64, +} +impl CommitWitness { + fn selected(&self, kind: GatewayRecordKind, target: GatewayAttemptKey, bytes: &[u8]) -> bool { + if kind != GatewayRecordKind::Attempt || target != key() { + return false; + } + let record: Value = serde_json::from_slice(bytes).expect("native decision"); + record["state"]["facts"]["phase"]["stage"] == self.phase.stage() + } + fn observe( + &self, + selected: bool, + result: Result, + ) -> Result { + if selected && result.is_err() { + self.errors.fetch_add(1, Ordering::SeqCst); + } + result + } +} +impl GatewayAttemptStore for CommitWitness { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + let mut selected = false; + let result = self + .inner + .fenced_insert_all(entries, dependencies, &mut |snapshots| { + let next = decide(snapshots)?; + selected = self.selected(entries[0].kind, entries[0].key, &next); + Ok(next) + }); + self.observe(selected, result) + } + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + let mut selected = false; + let result = self.inner.fenced_replace(keys, &mut |snapshots| { + let next = decide(snapshots)?; + selected = self.selected(keys[0].0, keys[0].1, &next); + Ok(next) + }); + self.observe(selected, result) + } + fn replace( + &self, + kind: GatewayRecordKind, + target: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + let selected = self.selected(kind, *target, next); + self.observe(selected, self.inner.replace(kind, target, current, next)) + } + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.inner.insert_all(entries) + } + fn load( + &self, + kind: GatewayRecordKind, + target: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + self.inner.load(kind, target) + } + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.inner.sweep_expired(now, limit) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.inner.attempt_keys(limit) + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + errors: u64, + witness: GatewayExecutionWitness, + result: Result, +} + +#[test] +fn native_postgres_commit_peer() { + let Some(input) = std::env::var_os("AUTHS_AP074_POSTGRES_COMMIT_PEER") else { + return; + }; + let setup: CommitSetup = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach(Backend::Postgres, &setup.installation.location); + let witness = Arc::new(CommitWitness { + inner: store.raw(), + phase: setup.schedule.phase, + errors: AtomicU64::new(0), + }); + let attempts = GatewayAttempts::new( + witness.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine(&setup.installation, "worker", attempts)); + let mut signal = + TcpStream::connect(("127.0.0.1", setup.installation.barrier_port)).expect("control"); + signal + .set_read_timeout(Some(Duration::from_secs(10))) + .expect("deadline"); + signal.write_all(b"R").expect("ready"); + let mut start = [0]; + signal.read_exact(&mut start).expect("release"); + assert_eq!(start, *b"G"); + let result = runtime.block_on(acquire(&engine, &setup.installation.root, OPERATION)); + let result = WorkerResult { + errors: witness.errors.load(Ordering::SeqCst), + witness: engine.execution_witness(), + result, + }; + private( + &setup.installation.root.join("worker-result"), + &serde_json::to_vec(&result).expect("result"), + ); +} + +struct Barrier { + client: Client, + schema: String, + lock: i32, +} +impl Barrier { + fn install(store: &TestAttempts, phase: Phase) -> Self { + let (schema, mut client) = store.postgres_commit_observer(); + let lock: i32 = client.query_one(&format!("SELECT (('{schema}.auths_gateway_records'::regclass::oid)::bigint - 2147483648)::integer"), &[]).expect("table lock identity").get(0); + client + .query_one("SELECT pg_advisory_lock($1, $2)", &[&LOCK_GROUP, &lock]) + .expect("commit barrier"); + let stage = phase.stage(); + let target = hex::encode(key().as_bytes()); + client.batch_execute(&format!( + "CREATE FUNCTION {schema}.fixture_commit_barrier() RETURNS trigger LANGUAGE plpgsql AS $body$ + BEGIN + IF convert_from(NEW.record_bytes, 'UTF8')::jsonb #>> '{{state,facts,phase,stage}}' = '{stage}' THEN + PERFORM pg_advisory_xact_lock({LOCK_GROUP}, {lock}); + END IF; + RETURN NEW; + END; $body$; + CREATE CONSTRAINT TRIGGER fixture_commit_barrier AFTER INSERT OR UPDATE + ON {schema}.auths_gateway_records DEFERRABLE INITIALLY DEFERRED FOR EACH ROW + WHEN (NEW.record_kind = 'attempt' AND NEW.record_key = decode('{target}', 'hex')) + EXECUTE FUNCTION {schema}.fixture_commit_barrier();" + )).expect("deferred test trigger"); + Self { + client, + schema, + lock, + } + } + fn waiter(&mut self) -> i32 { + let deadline = Instant::now() + Duration::from_secs(1); + let group = i64::from(LOCK_GROUP); + let object = i64::from(u32::from_ne_bytes(self.lock.to_ne_bytes())); + loop { + let rows = self.client.query("SELECT locks.pid, ssl.ssl FROM pg_locks AS locks JOIN pg_stat_ssl AS ssl ON ssl.pid = locks.pid WHERE locktype = 'advisory' AND NOT granted AND classid::bigint = $1 AND objid::bigint = $2 AND objsubid = 2 AND locks.pid IS NOT NULL", &[&group, &object]).expect("commit wait observation"); + if let Some(row) = rows.first() { + assert_eq!(rows.len(), 1); + assert!(row.get::<_, bool>(1), "selected native COMMIT uses TLS"); + return row.get(0); + } + assert!( + Instant::now() < deadline, + "native COMMIT did not reach deferred trigger" + ); + thread::sleep(Duration::from_millis(1)); + } + } + fn release(&mut self) { + let released: bool = self + .client + .query_one( + "SELECT pg_advisory_unlock($1, $2)", + &[&LOCK_GROUP, &self.lock], + ) + .expect("release commit") + .get(0); + assert!(released); + } + fn abort(&mut self, pid: i32) { + let terminated: bool = self + .client + .query_one("SELECT pg_terminate_backend($1)", &[&pid]) + .expect("terminate blocked fixture backend") + .get(0); + assert!(terminated); + let deadline = Instant::now() + Duration::from_secs(1); + loop { + let gone: bool = self + .client + .query_one( + "SELECT NOT EXISTS (SELECT 1 FROM pg_stat_activity WHERE pid = $1)", + &[&pid], + ) + .expect("backend exit") + .get(0); + if gone { + break; + } + assert!( + Instant::now() < deadline, + "blocked backend did not terminate" + ); + thread::sleep(Duration::from_millis(1)); + } + self.release(); + } + fn phase(&mut self) -> Option { + self.client.query_opt(&format!("SELECT convert_from(record_bytes, 'UTF8')::jsonb #>> '{{state,facts,phase,stage}}' FROM {}.auths_gateway_records WHERE record_key = $1", self.schema), &[&&key().as_bytes()[..]]).expect("committed state").map(|row| row.get(0)) + } + fn committed(&mut self, expected: Option<&str>) { + let deadline = Instant::now() + Duration::from_secs(1); + loop { + if self.phase().as_deref() == expected { + return; + } + assert!( + Instant::now() < deadline, + "independent committed-state observation" + ); + thread::sleep(Duration::from_millis(1)); + } + } + fn retire(&mut self) { + self.client + .batch_execute(&format!( + "DROP TRIGGER fixture_commit_barrier ON {}.auths_gateway_records", + self.schema + )) + .expect("retire trigger"); + } + fn records(&mut self) -> BTreeMap> { + self.client.query(&format!("SELECT encode(record_key, 'hex'), record_bytes FROM {}.auths_gateway_records ORDER BY record_key", self.schema), &[]).expect("record snapshot").into_iter().map(|row| (row.get(0), row.get(1))).collect() + } +} + +fn fixture_url() -> (String, u16) { + let url = std::env::var("AUTHS_POSTGRES_URL").expect("fixture URL"); + let config = Config::from_str(&url).expect("fixture parameters"); + assert_eq!(config.get_ssl_mode(), SslMode::Require); + assert_eq!(config.get_hosts().len(), 1); + assert!( + matches!(&config.get_hosts()[0], Host::Tcp(host) if host == "localhost" || host == "127.0.0.1") + ); + assert_eq!(config.get_ports().len(), 1); + (url, config.get_ports()[0]) +} +struct Peer(Child); +impl Drop for Peer { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} +impl Peer { + fn start(setup: &CommitSetup, url: &str) -> Self { + let input = setup.installation.root.join("commit-setup.json"); + private(&input, &serde_json::to_vec(setup).expect("setup")); + Self( + Command::new(std::env::current_exe().expect("test executable")) + .args([ + "--exact", + "native_postgres_commit_tests::native_postgres_commit_peer", + "--nocapture", + ]) + .env("AUTHS_AP074_POSTGRES_COMMIT_PEER", input) + .env("AUTHS_POSTGRES_URL", url) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("native worker"), + ) + } + fn finish(&mut self) { + let deadline = Instant::now() + Duration::from_secs(20); + loop { + if let Some(status) = self.0.try_wait().expect("status") { + let mut diagnostic = String::new(); + self.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "native worker: {diagnostic}"); + return; + } + assert!(Instant::now() < deadline, "native worker completion"); + thread::sleep(Duration::from_millis(2)); + } + } +} +fn ready(listener: &TcpListener) -> TcpStream { + let deadline = Instant::now() + Duration::from_secs(10); + loop { + match listener.accept() { + Ok((mut stream, _)) => { + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut marker = [0]; + stream.read_exact(&mut marker).expect("ready"); + assert_eq!(marker, *b"R"); + return stream; + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "native worker readiness"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("control: {error}"), + } + } +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: CommitSetup, + provider: Provider, + proxy: Proxy, + url: String, + control: TcpListener, + signed: Vec>, +} +impl Case { + fn new(schedule: Schedule) -> Self { + let (url, port) = fixture_url(); + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private mode"); + let store = TestAttempts::open(Backend::Postgres); + let provider = Provider::controlled(None); + let proxy = Proxy::start(port); + let control = TcpListener::bind("127.0.0.1:0").expect("control"); + control.set_nonblocking(true).expect("control polling"); + let setup = CommitSetup { + schedule, + installation: Setup { + backend: "postgres".to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: control.local_addr().expect("address").port(), + }, + }; + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_engine( + &setup.installation, + "parent", + store.attempts().clone(), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let policy = ArgumentCeilingPolicy::new("maximum_response_bytes", 1024, 3600, 4) + .expect("count") + .with_sum(4096, None) + .expect("sum"); + runtime.block_on(authorize_policy( + &engine, + &setup.installation.root, + OPERATION, + &policy, + )); + let signed = Self::inputs(&setup); + Self { + _directory: directory, + store, + setup, + provider, + proxy, + url, + control, + signed, + } + } + fn inputs(setup: &CommitSetup) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| { + std::fs::read( + setup + .installation + .root + .join(format!("{OPERATION}.{suffix}")), + ) + .expect("signed inputs") + }) + .to_vec() + } + fn interrupt(&self) -> Barrier { + let mut worker = Peer::start(&self.setup, &self.proxy.url(&self.url)); + let mut signal = ready(&self.control); + let mut barrier = Barrier::install(&self.store, self.setup.schedule.phase); + signal.write_all(b"G").expect("release worker"); + let pid = barrier.waiter(); + self.proxy.hold_replies(); + match self.setup.schedule.outcome { + Outcome::Committed => { + barrier.release(); + barrier.committed(self.setup.schedule.retained()); + self.proxy.wait_for_withheld_reply(); + } + Outcome::Aborted => { + barrier.abort(pid); + barrier.committed(self.setup.schedule.retained()); + } + } + self.proxy.disconnect_and_resume(); + worker.finish(); + barrier.retire(); + let result: WorkerResult = serde_json::from_slice( + &std::fs::read(self.setup.installation.root.join("worker-result")).expect("result"), + ) + .expect("native result"); + assert_eq!( + result.errors, 1, + "actual native adapter returned an error at the selected commit" + ); + assert_eq!(result.witness.write_transport_entries, 0); + assert_eq!( + result.witness.read_transport_entries, + u64::try_from(self.setup.schedule.reads()).expect("reads") + ); + assert_eq!( + result.witness.credential_lease_calls, + u64::from(!matches!(self.setup.schedule.phase, Phase::Admission)) + ); + match result.result { + Ok(history) => { + assert!(self.setup.schedule.retained().is_some()); + assert_eq!(history.stage, self.setup.schedule.stage()); + assert_eq!((history.reserved_calls, history.reserved_bytes), (1, 1024)); + } + Err(GatewaySubmitResult::Indeterminate { code }) => { + assert_eq!(code, "gateway.attempt.state-unavailable"); + } + Err(other) => panic!("unexpected failure projection: {other:?}"), + } + assert_eq!( + self.provider.calls.load(Ordering::SeqCst), + self.setup.schedule.reads() + ); + assert_eq!(Self::inputs(&self.setup), self.signed); + assert_eq!( + self.store.postgres_gateway_record_counts(), + expected_counts(self.setup.schedule.retained().is_some()), + "the transaction outcome retains either every charge or none" + ); + barrier + } + fn reopen(&self, barrier: &mut Barrier) -> Value { + let before = barrier.records(); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_engine( + &self.setup.installation, + "reopened", + self.store.reopen(), + )); + let history = runtime.block_on(engine.content_history(OPERATION)); + if self.setup.schedule.retained().is_none() { + assert!(history.is_err()); + } else { + match history.expect("retained history") { + ContentHistory::Acquisition(history) => { + assert_eq!(history.stage, self.setup.schedule.stage()); + } + ContentHistory::Disclosure(_) => panic!("wrong protocol"), + } + } + let witness = engine.execution_witness(); + let result = runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("native replay"); + assert_eq!( + result.stage, + if self.setup.schedule.resumable() { + AcquisitionStage::ResponseRecorded + } else { + self.setup.schedule.stage() + } + ); + assert_eq!((result.reserved_calls, result.reserved_bytes), (1, 1024)); + assert_eq!( + (result.policy_count_counters, result.policy_byte_counters), + (1, 1) + ); + if !self.setup.schedule.resumable() { + assert_eq!(engine.execution_witness(), witness); + assert_eq!(barrier.records(), before); + } + let total = self.setup.schedule.reads() + usize::from(self.setup.schedule.resumable()); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), total); + let record = self + .store + .raw() + .load(GatewayRecordKind::Attempt, &key()) + .expect("record") + .expect("retained record"); + let value: Value = serde_json::from_slice(&record).expect("native record"); + assert_eq!(value["evaluated_at"], NOW); + assert_eq!(value["state"]["facts"]["allocation"], 0); + assert_eq!( + self.store.postgres_gateway_record_counts(), + expected_counts(true) + ); + let retained = barrier.records(); + let witness = engine.execution_witness(); + assert_eq!( + runtime + .block_on(acquire(&engine, &self.setup.installation.root, OPERATION)) + .expect("terminal replay"), + result + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(barrier.records(), retained); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), total); + assert_eq!(Self::inputs(&self.setup), self.signed); + json!({"schedule":self.setup.schedule,"commit_observed_at_server_deferred_trigger":true,"actual_adapter_commit_error":true,"independently_observed_retained_phase":self.setup.schedule.retained(),"end_to_end_tls_preserved":true,"actual_http_reads_before_reopen":self.setup.schedule.reads(),"new_execution_allowed":self.setup.schedule.resumable(),"actual_http_reads_after_reopen":total,"native_history":result,"one_allocation_count_and_sum_slot":true,"terminal_journal_and_execution_witness_unchanged":true,"signed_inputs_unchanged":true}) + } +} + +fn expected_counts(charged: bool) -> BTreeMap { + let mut counts = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ]); + if charged { + for kind in ["attempt", "effect-allocation", "count-slot", "sum-slot"] { + counts.insert(kind.to_owned(), 1); + } + } + counts +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_commit_reply_loss_fixture_is_current() { + assert!(postgres_configured()); + let mut cases = Vec::new(); + for phase in [Phase::Admission, Phase::Entry, Phase::Response] { + for outcome in [Outcome::Committed, Outcome::Aborted] { + eprintln!("native commit reply schedule: {phase:?}/{outcome:?}"); + let case = Case::new(Schedule { phase, outcome }); + let mut barrier = case.interrupt(); + cases.push(case.reopen(&mut barrier)); + } + } + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-postgres-commit-reply-loss/1","scope":"full native acquisition engine in separate OS workers; actual TLS PostgreSQL COMMIT paused by a schema-local deferred trigger, opaque TCP reply suppression/disconnection and independent committed/aborted-state observation; real bounded authority/exact approvals, local custody and HTTP; fixed public test keys and maintained clock","excluded":["TLS decryption or forged adapter error","PostgreSQL power failure or whole-store rollback","mutation/disclosure commit fault matrices","hostile OS containment or human review","live provider qualification"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-postgres-commit-reply-loss.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 4229879bb..d07ec4e30 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "2740a14f59cfd47637f8ffba4a8c344cb5f7fad58e43d39e67fc64333846c123"; + "f41c9a4a77303a1c852ad3c5418c35778dc3fc2e0059b0b871d158d66ab62e1c"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store_testkit.rs b/product/runtime/auths-gateway/src/store_testkit.rs index d70aded0e..fbf0faffa 100644 --- a/product/runtime/auths-gateway/src/store_testkit.rs +++ b/product/runtime/auths-gateway/src/store_testkit.rs @@ -213,6 +213,13 @@ impl TestAttempts { }).collect() }) } + + /// Direct fixture connection for independent commit/rollback observation. + /// The ownership check confines test DDL to a schema this handle created. + #[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] + pub(crate) fn postgres_commit_observer(&self) -> (String, Client) { + (self.owned_postgres_schema(), off_runtime(admin_client)) + } } impl Drop for TestAttempts { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 8950b1fd0..359f0e470 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 400 +freeze_version = 401 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 400 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 145 +"auths.identity.protocol" = 146 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 400 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 142 +"auths.product.public-sdk-contract" = 143 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 400 +"auths.release.public-surface" = 401 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index b96efa407..d1698703a 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 400, + "freezeVersion": 401, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 145, + "version": 146, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "2f4e23ab35238bb8db232e418d0cbb88ebdd5c6fd7af61676887e64c9bb0e6af" + "sha256": "1f8ccbcba1ec12c46b603bd7f4f48175bb8bde895d67027477ff8e6f6c26545d" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 142, + "version": 143, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "684e9110f8dabe7a295a95de0eeb66d4584801de829a166718103996586544e9" + "sha256": "314e69c4e3fe5c9366594d5d7cf9611d35a4d3bc8bd5ec600d28ccf06311f1ea" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 400, + "version": 401, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "426e8fed82bbda57ec7f4cfdb50c2b14403b06b2aab6619a3f14ad7e7c541dee" + "sha256": "aa17694c5384466d0abea35ff50b2ce5d97b525c23a92832f937e9e8ba33bac5" } ] } From d7eea2729ac0a52019a7c096a4867b61d90b9774 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 12:39:30 +0000 Subject: [PATCH 080/136] test(gateway): restore native approval controls across CLI checks --- .../tests/script_pipeline.rs | 4 +++ .../auths-gateway/src/bin/auths-gateway.rs | 29 ++++++++++++++----- .../auths-gateway/tests/socket_paths.rs | 27 +++++++++++++++-- 3 files changed, 49 insertions(+), 11 deletions(-) diff --git a/product/qualification/auths-recipe-qualification-issuance/tests/script_pipeline.rs b/product/qualification/auths-recipe-qualification-issuance/tests/script_pipeline.rs index 79a77aea8..f1e6b9028 100644 --- a/product/qualification/auths-recipe-qualification-issuance/tests/script_pipeline.rs +++ b/product/qualification/auths-recipe-qualification-issuance/tests/script_pipeline.rs @@ -70,7 +70,11 @@ fn stage_reports_flow_through_redaction_and_assembly_and_missing_execution_refus } succeed(Command::new("git").args(["init", "--quiet"]).arg(&root)); succeed(Command::new("git").arg("-C").arg(&root).args(["add", "."])); + // This disposable corpus needs a source revision, not the developer's + // signing identity. Qualification signing is exercised separately. succeed(Command::new("git").arg("-C").arg(&root).args([ + "-c", + "commit.gpgsign=false", "-c", "user.name=Qualification test", "-c", diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index e055f8228..0dce2e952 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -5266,11 +5266,29 @@ mod unix { assert_eq!(stored.revoked_signers.len(), 8); } + fn canonical_application_frame() -> serde_json::Value { + let fixture: serde_json::Value = serde_json::from_slice(include_bytes!( + "../../../../../bindings/fixtures/gateway/effect-binding.json" + )) + .expect("native exact-effect fixture"); + let frame: serde_json::Value = serde_json::from_str( + fixture["submission_frame_canonical"] + .as_str() + .expect("native submission frame"), + ) + .expect("canonical frame JSON"); + let submission: AppSubmission = + serde_json::from_value(frame.clone()).expect("current submission shape"); + assert_eq!(submission.schema, APP_REQUEST_SCHEMA); + assert!(submission.decode().is_ok(), "native approval must decode"); + frame + } + #[test] fn application_and_admin_frames_cannot_select_a_commissioning_session() { + let canonical = canonical_application_frame(); for field in ["commissioning", "permit", "authority", "operator_session"] { - let mut frame = serde_json::json!({"schema": APP_REQUEST_SCHEMA, - "proof_b64": "AA", "action_b64": "AA"}); + let mut frame = canonical.clone(); frame[field] = serde_json::json!("synthetic-untrusted-authority"); assert!( serde_json::from_value::(frame).is_err(), @@ -5391,12 +5409,7 @@ mod unix { .expect("service hostile cases"); assert_eq!(cases["schema"], "auths.gateway-service-hostile/1"); assert_eq!(cases["cases"].as_array().expect("cases").len(), 15); - let canonical = serde_json::json!({ - "schema": APP_REQUEST_SCHEMA, - "proof_b64": "AA", - "action_b64": "AA" - }); - assert!(serde_json::from_value::(canonical.clone()).is_ok()); + let canonical = canonical_application_frame(); for (key, value) in [ ("url", "https://attacker.example"), ("method", "POST"), diff --git a/product/runtime/auths-gateway/tests/socket_paths.rs b/product/runtime/auths-gateway/tests/socket_paths.rs index 57d763e1f..71c43a4ae 100644 --- a/product/runtime/auths-gateway/tests/socket_paths.rs +++ b/product/runtime/auths-gateway/tests/socket_paths.rs @@ -8,6 +8,7 @@ use auths_gateway::CompiledRecipe; use auths_gateway::listener::max_socket_path_bytes; +use base64ct::{Base64UrlUnpadded, Encoding as _}; use std::{ ffi::OsStr, fs, @@ -546,8 +547,26 @@ fn a_client_reports_the_length_and_the_connect_error() { let (_directory, root) = private_root(); let proof = root.join("proof"); let action = root.join("action"); - fs::write(&proof, b"p").expect("proof"); - fs::write(&action, b"a").expect("action"); + let approval = root.join("approval"); + let fixture: serde_json::Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/effect-binding.json" + )) + .expect("native exact-effect fixture"); + let frame: serde_json::Value = serde_json::from_str( + fixture["submission_frame_canonical"] + .as_str() + .expect("native submission"), + ) + .expect("canonical frame"); + for (path, field) in [ + (&proof, "proof_b64"), + (&action, "action_b64"), + (&approval, "approval_b64"), + ] { + let bytes = Base64UrlUnpadded::decode_vec(frame[field].as_str().expect("encoded field")) + .expect("native bytes"); + fs::write(path, bytes).expect("submission input"); + } let submit = |socket: &Path| { run_with_deadline( Command::new(BIN) @@ -557,7 +576,9 @@ fn a_client_reports_the_length_and_the_connect_error() { .arg("--proof") .arg(&proof) .arg("--action") - .arg(&action), + .arg(&action) + .arg("--approval") + .arg(&approval), DEADLINE, ) }; From bc7783342c90a3a59d234e56c72588d32f782a6f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 12:48:37 +0000 Subject: [PATCH 081/136] chore(assurance): refresh canonical CLI controls and source attribution --- docs/plans/0074-implementation-status.md | 56 +++++++++++++++++++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 4 +- release/semantic-freeze.json | 6 +- 5 files changed, 63 insertions(+), 7 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 002c3fb62..d6eb3abca 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2212,6 +2212,62 @@ closure regeneration passed after that correction (one artifact-generation test) inventory. The shipping store and translated kernel are unchanged. Fresh exact-head hosted execution is required before acceptance claims. +## Integrated canonical application controls and CI attribution + +- Reviewed isolated CI batch31969a61 and integrated it as d7eea272. Two binary + negative-frame tests now begin with the canonical native submission fixture + and assert that exact approval actually decodes. The commissioning-field + negatives are no longer vacuous, and every forbidden provider/authority field + remains rejected. The socket-path tests supply real fixture proof/action/ + approval so clap parsing cannot mask the intended socket failures. +- Qualification's disposable synthetic source commit disables inherited Git + signing only on that single command. No user/repository setting, real commit + signing, qualification signer or signing acceptance gate is changed. Focused + isolated checks passed binary9/9, socket13/13 and pipeline2/2. +- The actual failed workspace command was reproduced with no-fail-fast to expose + downstream issues before publishing another batch. Its305 result suites + reported1,503 passed,4 failed and47 ignored. Failures were the now-repaired + socket caller and synthetic signing environment, expected gateway closure drift + after binary source edits, and one typed Unavailable under broad-run file-store + contention. The original binary root had already been repaired before that run. + The identical compiled conformance test subsequently passed1/1 in8.82 seconds + with unchanged two-second lock/fence bounds and unchanged exact-once assertions. + This is not advertised as a successful full-workspace run or a store fix. +- Published ab36's pinned translation job123431724418 passed two clean identical + translations. Authoritative Lean job123448869608 is still running and final + formal evidence follows it; no completed qualification is claimed yet. Hosted + compliance and all49 Kani harnesses passed, with zero Kani failures. Fresh + Python tests passed428 with11 skips, and native/WASM live-demo parity passed. +- Producer attribution is retained precisely: standalone Python/TypeScript and + default-checkout CI/isolation jobs built the recorded PR merge revision + f25217f68ab1b69930660a29a61e5433cbd84210. Demo producers explicitly built ab36. + Both revisions have the identical verified tree + dc691ccb384709520202274dd2db7904841048a6, confirmed by Git tree inspection and + an empty diff. Their behavior covers the published source tree; their producer + revision is not relabeled as ab36. Future final-head evidence must retain its + actual source/producer attribution too. + +## Retained replay source audit + +- Source inspection shows execution methods compiling current authority and exact + approval before retained terminal lookup. A regression is required for original + requests after approval/resource expiry, connection revocation and configuration + replacement: retained grants must not be reported as NotEntered, replay must + not remint execution, and historical facts must remain queryable. This audit + is not yet behavioral evidence of a failure or a completed fix. +- Any replay repair belongs to the native effect/journal owner. It must preserve + exact identity checks, reject changed actor/action/resource/recipient inputs, + keep pre-grant continuation subject to fresh native checks and keep historical + data separate from executable capabilities. No alternate binding, approval, + clock or fallback authority is authorized by this audit. + +- The combined gateway source closure was regenerated after integrating the + binary controls, and its rebuilt verification passed1/1 in0.06 seconds. + Release freeze402 advances only the generator-reported public + surface402 subject; no protocol/ABI meaning counter was advanced for test-only + repairs. The CI agent's formal final-head report and fresh publication are + still pending; these metadata changes do not turn the failed hosted root green. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index db1a2634f..a6d869bf4 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"298dc5ec3689063015d6fc23252591ad3421fa1a450143421d4f1d784b149a07"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"448512dd483139f9e7e9a70c2cb66d00e8a9d0eaf4eb38db017a7a938dbb7af8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"448512dd483139f9e7e9a70c2cb66d00e8a9d0eaf4eb38db017a7a938dbb7af8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index d07ec4e30..61e6148a1 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "f41c9a4a77303a1c852ad3c5418c35778dc3fc2e0059b0b871d158d66ab62e1c"; + "367d7abda8c215f0d5e9ffc51fb6af4fea1a10eb38aaedfcd5e797a397f32136"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 359f0e470..e776cf8ae 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 401 +freeze_version = 402 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -67,4 +67,4 @@ freeze_version = 401 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 401 +"auths.release.public-surface" = 402 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index d1698703a..ac1c141a9 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 401, + "freezeVersion": 402, "publicSurface": { "rustRoots": [ "auths", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 401, + "version": 402, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "aa17694c5384466d0abea35ff50b2ce5d97b525c23a92832f937e9e8ba33bac5" + "sha256": "b0cda095565912e9c5d5d8897ad56aa4808ef9a9a6bfeaaea69a0cf98176eeb8" } ] } From 9ae2e2c79756ffa6ae3b7fbe45b3b3541a33660f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 13:36:19 +0000 Subject: [PATCH 082/136] fix(gateway): preserve retained facts independently of current authority --- .github/workflows/postgres-lifecycle.yml | 4 + .../gateway/attempt-scenarios-v3.json | 2 +- bindings/fixtures/gateway/effect-entry.json | 8 +- ...tive-information-retained-replay-file.json | 297 ++++++++++ ...-information-retained-replay-postgres.json | 297 ++++++++++ .../native-mutation-retained-replay-file.json | 62 +++ ...ive-mutation-retained-replay-postgres.json | 62 +++ .../fixtures/gateway/prerequisite-entry.json | 2 +- compliance.toml | 9 +- ...017-bound-effect-and-recovery-ownership.md | 29 + .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 103 +++- .../0009-bound-effect-and-recovery.md | 12 + ...ound-effects-and-recovery-state-machine.md | 14 +- .../record-entry-granted-synthetic-entry | 2 +- .../record-not-entered-synthetic-entry | 2 +- .../record-reserved-synthetic-entry | 2 +- .../record-response-recorded-synthetic-entry | 2 +- .../record-unknown-synthetic-entry | 2 +- ...anted-to-response-recorded-synthetic-entry | Bin 6577 -> 7433 bytes ...n-entry-granted-to-unknown-synthetic-entry | Bin 6460 -> 7316 bytes ...-reserved-to-entry-granted-synthetic-entry | Bin 5732 -> 6591 bytes ...on-reserved-to-not-entered-synthetic-entry | Bin 5031 -> 5893 bytes .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/candidate_runtime.rs | 32 +- product/runtime/auths-gateway/src/effect.rs | 88 ++- .../auths-gateway/src/effect/acquisition.rs | 15 +- .../auths-gateway/src/effect/authority.rs | 140 +++++ .../auths-gateway/src/effect/prerequisite.rs | 2 +- .../auths-gateway/src/effect/release.rs | 11 +- .../src/effect_prerequisite_tests.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 317 +++++++++-- .../runtime/auths-gateway/src/entry_tests.rs | 43 ++ product/runtime/auths-gateway/src/lib.rs | 5 + .../src/native_dependency_tests.rs | 2 + .../src/native_information_replay_tests.rs | 478 ++++++++++++++++ .../src/native_mutation_replay_tests.rs | 514 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 9 +- .../src/pending_vectors/attempts.rs | 2 +- .../auths-gateway/src/qualification.rs | 2 +- .../auths-gateway/src/qualification_tests.rs | 2 +- .../auths-gateway/src/scenario_tests.rs | 8 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 106 +++- .../auths-gateway/src/store/acquisition.rs | 2 + .../auths-gateway/src/store/disclosure.rs | 2 + release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 48 files changed, 2535 insertions(+), 186 deletions(-) create mode 100644 bindings/fixtures/gateway/native-information-retained-replay-file.json create mode 100644 bindings/fixtures/gateway/native-information-retained-replay-postgres.json create mode 100644 bindings/fixtures/gateway/native-mutation-retained-replay-file.json create mode 100644 bindings/fixtures/gateway/native-mutation-retained-replay-postgres.json create mode 100644 product/runtime/auths-gateway/src/effect/authority.rs create mode 100644 product/runtime/auths-gateway/src/native_information_replay_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_replay_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 401a4fd70..aa865fa04 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -52,6 +52,10 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::native_file_mutation_retained_replay_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/attempt-scenarios-v3.json b/bindings/fixtures/gateway/attempt-scenarios-v3.json index 60e7d6370..c8db7455a 100644 --- a/bindings/fixtures/gateway/attempt-scenarios-v3.json +++ b/bindings/fixtures/gateway/attempt-scenarios-v3.json @@ -1,6 +1,6 @@ { "schema": "auths.gateway-attempt-scenarios/3", - "attempt_schema": "auths.gateway-attempt/15", + "attempt_schema": "auths.gateway-attempt/16", "recipes": "hostile-recipes-v2.json", "evaluated_at": 1790000000, "defaults": { diff --git a/bindings/fixtures/gateway/effect-entry.json b/bindings/fixtures/gateway/effect-entry.json index ef4818d40..483724d72 100644 --- a/bindings/fixtures/gateway/effect-entry.json +++ b/bindings/fixtures/gateway/effect-entry.json @@ -13,7 +13,7 @@ "grant_audit": { "revision": 3, "authorization_started_at": 1790000061, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[166,97,245,226,218,191,75,185,149,176,105,118,248,30,105,62,64,99,52,105,241,98,144,158,120,101,6,206,121,211,32,44],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"yHsmoV2MRU1udcUF0ozR8jh9RMsKFCKbHe53d93nMX02YCL57kcnm_CCBJnMaVULU7LF7jChz19kgEUuAiSqDw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[81,66,124,178,16,0,69,207,209,135,29,109,222,228,78,84,212,136,149,179,216,112,202,202,114,156,82,173,86,16,241,169],\"expires_at\":1790003661,\"not_before\":1790000061,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"IzrD0XvpbxVYxEJ388jUKMV28IY9ivtH9Yvkd6pkZJyrcM7UiO8NfmAobo-pmkmnrvLCkndIDsUGFq0pctZ5CA\"}", "pre_entry": { "basis": { "value": 1002, @@ -23,7 +23,7 @@ }, "schema": "auths.effect-entry/3", "granted_at": 1790000061, - "effect_id": "a661f5e2dabf4bb995b06976f81e693e40633469f162909e786506ce79d3202c", + "effect_id": "51427cb2100045cfd1871d6ddee44e54d48895b3d870caca729c52ad5610f1a9", "dependencies": [ "55aab28f95092b9b9abc5dce74fcd3a13b02a2f54250893bed28852ac45fa264", "f2e4936daf26963e87b15bc36f0cdd7d548fbe5e291e318f65867fcd9156f7b2" @@ -39,11 +39,11 @@ "entry_audit": { "revision": 2, "authorization_started_at": 1790000000, - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}", "pre_entry": null, "schema": "auths.effect-entry/3", "granted_at": 1790000000, - "effect_id": "ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8", + "effect_id": "da6f9e85c415185c8311dd28fb5a669799cc9c5c9adf28d6d5de0c5cf5a096fc", "dependencies": [] } } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-information-retained-replay-file.json b/bindings/fixtures/gateway/native-information-retained-replay-file.json new file mode 100644 index 000000000..aebec5bb6 --- /dev/null +++ b/bindings/fixtures/gateway/native-information-retained-replay-file.json @@ -0,0 +1,297 @@ +{ + "schema": "auths.native-information-retained-replay/1", + "adapter": "file", + "scope": "native proof, independent read/release approvals, real HTTP and authenticated Unix delivery; fixed public keys, same UID and maintained clock; retained facts confer no execution authority", + "cases": [ + { + "protocol": "acquisition-response", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-information-retained-replay-postgres.json b/bindings/fixtures/gateway/native-information-retained-replay-postgres.json new file mode 100644 index 000000000..7dfdf004b --- /dev/null +++ b/bindings/fixtures/gateway/native-information-retained-replay-postgres.json @@ -0,0 +1,297 @@ +{ + "schema": "auths.native-information-retained-replay/1", + "adapter": "postgres", + "scope": "native proof, independent read/release approvals, real HTTP and authenticated Unix delivery; fixed public keys, same UID and maintained clock; retained facts confer no execution authority", + "cases": [ + { + "protocol": "acquisition-response", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "acquisition-response", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-acknowledged", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "unchanged", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "approval-expired", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "resource-authority-expired", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "connection-revoked", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + }, + { + "protocol": "disclosure-unknown", + "change": "configuration-replaced", + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "provider_reads": 1, + "reopened_native_engine": true, + "no_replay_authentication_or_delivery": true, + "changed_caller_target_refused": true, + "journal_and_execution_witness_unchanged": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-retained-replay-file.json b/bindings/fixtures/gateway/native-mutation-retained-replay-file.json new file mode 100644 index 000000000..bb0538017 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-retained-replay-file.json @@ -0,0 +1,62 @@ +{ + "schema": "auths.native-mutation-retained-replay/1", + "adapter": "file", + "scope": "full native mutation engine, actual exact approval/proof, maintained durable adapter and real local HTTP; fixed public keys and maintained test clock; no current execution authority inferred from retained history", + "cases": [ + { + "change": "unchanged", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "approval-expired", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "resource-authority-expired", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "connection-revoked", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "configuration-replaced", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-retained-replay-postgres.json b/bindings/fixtures/gateway/native-mutation-retained-replay-postgres.json new file mode 100644 index 000000000..9ef87d242 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-retained-replay-postgres.json @@ -0,0 +1,62 @@ +{ + "schema": "auths.native-mutation-retained-replay/1", + "adapter": "postgres", + "scope": "full native mutation engine, actual exact approval/proof, maintained durable adapter and real local HTTP; fixed public keys and maintained test clock; no current execution authority inferred from retained history", + "cases": [ + { + "change": "unchanged", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "approval-expired", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "resource-authority-expired", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "connection-revoked", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + }, + { + "change": "configuration-replaced", + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "same_request_body_as_review": true, + "retained_journal_and_execution_witness_unchanged": true, + "different_valid_proof_action_and_invalid_approval_refused": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-entry.json b/bindings/fixtures/gateway/prerequisite-entry.json index 362c8d054..72afac67d 100644 --- a/bindings/fixtures/gateway/prerequisite-entry.json +++ b/bindings/fixtures/gateway/prerequisite-entry.json @@ -1,7 +1,7 @@ { "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/15", + "attempt_schema": "auths.gateway-attempt/16", "cases": [ { "recipe": "stripe", diff --git a/compliance.toml b/compliance.toml index 001e45b1a..3fa1dd561 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1309,7 +1309,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/15", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/16", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1640,7 +1640,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/15", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1813,6 +1813,11 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_commit_tests.rs#postgres_native_commit_reply_loss_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#native_file_mutation_retained_replay_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#postgres_native_mutation_retained_replay_fixture_is_current", + "product/runtime/auths-gateway/src/native_information_replay_tests.rs#native_file_information_retained_replay_fixture_is_current", + "product/runtime/auths-gateway/src/native_information_replay_tests.rs#postgres_native_information_retained_replay_fixture_is_current", + "product/runtime/auths-gateway/src/entry_tests.rs#retained_native_authority_projection_is_required_and_bound", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/effect_content_tests.rs#native_content_journal_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 381f97f24..a70ca7ac8 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -42,6 +42,35 @@ identity after compilation; the signature is not an input to its own identity. The stored effect is data. Only a successful new durable entry transition yields a non-cloneable, non-deserializable, consumed transport capability. +### Retained submission identity and current authorization + +Retrieving an admitted fact is independent of authorizing another entry. The +native journal retains a bounded, canonical portable projection of the original +native verification result, including its exact proof and action digests. Its +normalized authority commitment must equal the immutable binding's existing +native-authority commitment. The projection's portable self-digest is validated; +the original commitment preimage is reconstructed with the native codec, keeping +the existing binding identity unchanged. The private projection is at most +65,536 bytes and is immutable under every protocol transition. + +The application action supplies bounded lookup hints only. Native history +retrieval checks the partition/epoch, namespace, operation, recipe, both original +input digests and a signature for the retained effect under its retained approver +pin. Approval validity intervals and installed keys are current-entry conditions; +an expired original approval can identify history without granting current +authority. Additional API resource, recovery-source and disclosure-target inputs +must still match the historical signed action. No credential lease, native +reauthorization, peer authentication or provider/delivery request is needed to +return already entered or terminal facts. + +A reserved operation may continue only through the existing full fresh native +compilation, current exact approval and atomic writer fence. Failure to acquire +current authority leaves its retained reservation visible; it does not rewrite +history as a new non-entry fact. This history path returns only typed snapshots, +never `BoundEffect`, `ApprovedEffect`, an authenticated channel or a permit. +The journal cuts over directly to `auths.gateway-attempt/16`; obsolete disposable +records are rejected. There is no legacy reader or second authority cache. + Retain lifecycle identity/commitment helpers only where their exact contract matches. `PreparationBindingV1` is not reused as the effect: its optional connection/evidence and single principal do not encode disclosure/source/channel, diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index f6d19fd56..1ec8e3b4a 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -188,7 +188,7 @@ held which key, is operator evidence and is not produced by this code. `auths.lifecycle.postgresql/8`; it installs only into an empty database. A database created with an obsolete schema is disposable prelaunch state: recreate it. Gateway claims are stored as attempt record - `auths.gateway-attempt/15`; a store holding obsolete records is refused as + `auths.gateway-attempt/16`; a store holding obsolete records is refused as corrupt, so the file store's attempts directory is recreated too. The journal keeps typed mutation/acquisition facts under one header. Recovery allocations are permanent source-lifetime count/byte reservations and are never swept. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index d6eb3abca..4e1b821ee 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2247,26 +2247,81 @@ closure regeneration passed after that correction (one artifact-generation test) revision is not relabeled as ab36. Future final-head evidence must retain its actual source/producer attribution too. -## Retained replay source audit - -- Source inspection shows execution methods compiling current authority and exact - approval before retained terminal lookup. A regression is required for original - requests after approval/resource expiry, connection revocation and configuration - replacement: retained grants must not be reported as NotEntered, replay must - not remint execution, and historical facts must remain queryable. This audit - is not yet behavioral evidence of a failure or a completed fix. -- Any replay repair belongs to the native effect/journal owner. It must preserve - exact identity checks, reject changed actor/action/resource/recipient inputs, - keep pre-grant continuation subject to fresh native checks and keep historical - data separate from executable capabilities. No alternate binding, approval, - clock or fallback authority is authorized by this audit. - -- The combined gateway source closure was regenerated after integrating the - binary controls, and its rebuilt verification passed1/1 in0.06 seconds. - Release freeze402 advances only the generator-reported public - surface402 subject; no protocol/ABI meaning counter was advanced for test-only - repairs. The CI agent's formal final-head report and fresh publication are - still pending; these metadata changes do not turn the failed hosted root green. +## Retained replay correction and journal cutover + +- The native real-HTTP mutation regression reproduced the source-audited bug: + an original PATCH completed with HTTP 200, but its identical submission after + exact approval expiry returned `NotEntered gateway.effect.approval`. Stored + facts themselves remained retained. That projection did not satisfy §5.3. +- `effect::NativeAuthority` now retains the bounded canonical native authority + projection that reconstructs the binding's existing normalized commitment. + It includes exact native proof/action digests, validates the portable + self-digest, stays private and is limited to 65,536 bytes. No new effect identity + algorithm or alternative verifier is introduced. The common journal validates + it against the binding and includes it in immutable fields for all protocols. +- The native journal cuts over directly from `/15` to `/16`. Qualification + candidates, fixture generators, decoder fuzz seeds, compliance and the runbook + use the new schema; obsolete disposable records fail closed. There is no + migration/compatibility reader, runtime selector or second authority cache. +- One native history matcher checks the partition/epoch, namespace, operation, + recipe, both committed inputs and the retained binding's exact approver + signature. Its historical signature check grants no current entry authority. + Mutation, content, recovery, candidate-check and disclosure entry APIs use + typed stored projections; additional resource/source/recipient inputs still + have to match the original signed action. Terminal replay requires no current + approval window, connection, credential lease or authenticated delivery. +- Real native binding/signing fixtures stayed byte-identical under the retained + commitment algorithm. Post-verification reference commands now carry explicit + canonical oracle authority evidence instead of an all-zero digest; only those + synthetic IDs/signatures regenerate. No production path can use that oracle. +- Historical approval matching verifies the original signature and binding + without sampling or inventing an evaluation time. Current-entry approval + verification still requires the signed window at the real sampled time. +- A reserved operation can only continue through full current native compilation, + exact approval and the existing atomic writer fence. Current authorization + failure returns the unchanged retained reservation. A history value cannot + construct a sealed effect, approved effect, live channel or lost permit. +- The four required fixture generators passed 4/4, zero ignored, in 4.90 seconds + against the real file store and independent TLS PostgreSQL fixture on port 55451. + They author 40 histories: ten mutation histories and thirty acquisition/disclosure + histories. Mutation checks run in the original and reopened native engines, + rejecting different valid proof/action inputs and a damaged approval. Read and + release histories reopen the native engine, preserve exact response/ACK/unknown + facts after expiry/revocation/configuration replacement, and reject changed + resource/recipient proposals. Actual provider counts, native execution witnesses + and journal bytes remain unchanged through replay. The release cases use real + authenticated Unix sockets and both exact ACK and lost-ACK outcomes. +- The older required artifact generators passed 31/31, zero ignored, in 83.06 seconds + after the cutover, including both adapters' capacity, SIGKILL, dependency-order, + window-budget, real file I/O faults and real PostgreSQL failure/COMMIT reply-loss + matrices, plus native candidate/content/recovery/prerequisite/admission fixtures. + This is artifact-construction evidence, not a new complete hosted gate. +- Assumptions remain explicit: fixed public test keys, maintained test clock, + local provider transport, same-UID recipient tests and trusted durable stores. + No human-presence, hostile-host, whole-store rollback, live-provider or managed + Google guarantee follows. Full A01–A22 acceptance and exact new-head CI remain + open. AP070 stays independent; AP073 remains untouched. + +- Release freeze 403 advances the generator-reported identity protocol 147, + public SDK contract 144 and public surface 403 subjects. The gateway source + closure is regenerated. No kernel source, proof statement, tool pin, security + deadline or test assertion was relaxed. The additional retained-header test and + regenerated matrices passed in the final selected generator run (8/8, zero + ignored, 4.89 seconds); four commissioning-floor tests also matched that filter. + +## Published formal/CI batch resolution + +- The CI agent's final report is `/tmp/ap074-ci-ab36-report.md`. On the published + revision `ab36e4b76420a37912d00b2c5b1fac1ad6c556c5`, all 85 successful checks + include authoritative Lean and final formal evidence. The final formal job is + `123460599133` in run `40867724155`. Eight conditional skips establish no live + qualification. The three failed badges are the original authoritative CLI + fixture root and its two rollups, already repaired by local commit `d7eea272`. +- That integrated repair's 24 focused checks passed. The broad workspace + reproduction did not pass; its load-sensitive file conformance case passed + only in isolation with original deadlines and assertions preserved. Combined + source still requires exact published-head hosted verification. Final formal + evidence on `ab36` does not attest to subsequent replay sources or journal `/16`. ## Phase gates @@ -2286,14 +2341,14 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | Case | Required evidence | Implementation / authored / executed | Limitation or next work | | --- | --- | --- | --- | -| A01 | Same bound identity and exact request across review/approval/send | Partial / partial / native fixture only | Installed transport and review-completeness evidence pending | -| A02 | Independent mutation of every binding dimension | Pending / no / no | Freeze canonical corpus | -| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter and candidate process cases / local candidate concurrency/restart executed | Complete mutation/conflict and PostgreSQL evidence | +| A01 | Same bound identity and exact request across review/approval/send | Partial / native review/compiler and real mutation replay corpus / ten file/TLS PostgreSQL histories send the exact reviewed PATCH body | Full installed review-completeness and authenticated human/UI evidence pending | +| A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus and native retained-input controls / distinct valid proof/action, damaged approval, changed resource and changed recipient rejected during file/TLS PostgreSQL replay | Complete independent substitutions for every binding dimension and installed surface remain required | +| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | | A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file and daemon/recipient process corpus / both peers killed after receipt before ACK; charged unknown, no redelivery, late ACK executed | Remaining crash/persistence boundaries and PostgreSQL pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file, daemon/recipient process and native file/TLS PostgreSQL history corpora / both peers killed before ACK in the process corpus; native lost-ACK history retained across expiry, revocation, configuration replacement and engine reopen on both stores | Remaining crash/persistence boundaries and complete late-ACK PostgreSQL schedules pending | | A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 4535bb843..710f3b0d3 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -97,6 +97,18 @@ Independent observation adds a typed fact without replacing response/ACK or original actor. Conserved capacity is available + held + consumed = allocated; unknown keeps charges. Pre-entry refusal only releases declared releasable units. +Retained submission lookup is another shared mechanism across the three typed +protocols. It uses the same canonical native authority projection and retained +binding/approver pin, rather than recompiling expired authority before returning +history. The exact proof and action digests are both required; each endpoint +also binds any additional resource/source/recipient proposal to the historical +action. The journal's canonical projection reconstructs the existing authority +commitment and cannot mint a sealed effect or permit. These common checks do not +merge mutation response, acquisition content and disclosure ACK facts. Reserved +continuation still uses each protocol's full fresh native compilation and the +shared writer fence. The direct journal schema cutover is `/16`, with a 65,536 +byte private authority projection limit and no reader for obsolete state. + ## Cutover and evidence Replace affected formats and call sites in one bounded PR. No production diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index ed1409ef8..88fc9c5ae 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -355,7 +355,7 @@ read proof/approval. Custody is checked for the exact staged reference before publication; independently stored custody and connection state are not claimed to be one atomic transaction. -The concrete journal encoding is `auths.gateway-attempt/15`. Each prerequisite +The concrete journal encoding is `auths.gateway-attempt/16`. Each prerequisite has a component replay key derived from the parent's logical operation key and its compiler ordinal, a permanent one-call/maximum-response-byte allocation, and a typed acquisition record retaining the parent's exact approval. A bounded @@ -859,6 +859,18 @@ For this milestone, provider-entry and disclosure-entry permits are one-use, and Identical admitted/terminal replay returns stored facts with no credential lease, provider read or new observation credit. Reservation continuation is the separate fresh-authorization rule above. +- Historical submission matching MUST use the retained native proof and action + commitments plus a valid signature for the retained binding under its retained + approval policy. Operation IDs or action bodies alone are insufficient. The + private journal retains the bounded canonical native authority projection + needed to validate those commitments; it is immutable under every protocol + transition and grants no execution authority. Current authority, approval + expiry, connection revocation or configuration replacement MUST NOT turn an + already entered fact into `not-entered`. Extra API resource/source/recipient + inputs remain bound to the historical signed action. The same retrieval rule + applies to mutation, acquisition and disclosure. A fresh authorization failure + for an unchanged pre-grant reservation returns the retained reservation without + continuing it, refunding charges or modifying the journal. - Provider idempotency may improve provider guarantees but does not override the default prohibition on Auths re-entry. Any future retry mode requires an explicit versioned protocol and evidence for key scope, retention, fencing and late requests. - Late valid response/ACK evidence can refine an unknown outcome. Revocation or expiry must not erase legitimate history or prevent recording a previously authorized delivery's exact ACK. Recording history confers no current execution authority. - Read-only recovery requires its own bounded authority and accounting. It cannot borrow a revoked writer's proof, use an expired approval as current authority, acquire broader credentials or change the original actor attribution. diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry index 2e7953d91..1b8507450 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-entry-granted-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/16","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[18,235,131,109,161,47,186,164,207,117,158,84,83,81,226,82,123,165,214,134,91,192,31,155,84,121,98,93,248,158,220,213],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","authority_canonical_b64":"sgAAAQQCogAAAWphdXRob3JpemVkA1ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvYHWCAKhJq0RdktVd4THsBIP8vGv9Mb8AiIH854B9rXBwvtyAiACYAKgAunAAABAAIAAwAEAAUABgAMWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA32DlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBBCAEYA=","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"da6f9e85c415185c8311dd28fb5a669799cc9c5c9adf28d6d5de0c5cf5a096fc","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"entry-granted","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry index 8dcf1740b..bc0cbd7ff 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-not-entered-synthetic-entry @@ -1 +1 @@ -{"revision":2,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":2,"schema":"auths.gateway-attempt/16","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[18,235,131,109,161,47,186,164,207,117,158,84,83,81,226,82,123,165,214,134,91,192,31,155,84,121,98,93,248,158,220,213],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","authority_canonical_b64":"sgAAAQQCogAAAWphdXRob3JpemVkA1ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvYHWCAKhJq0RdktVd4THsBIP8vGv9Mb8AiIH854B9rXBwvtyAiACYAKgAunAAABAAIAAwAEAAUABgAMWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA32DlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBBCAEYA=","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"not-entered","refusal":"test.before-grant","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry index 3162999c1..6ed0371f9 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-reserved-synthetic-entry @@ -1 +1 @@ -{"revision":1,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":1,"schema":"auths.gateway-attempt/16","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[18,235,131,109,161,47,186,164,207,117,158,84,83,81,226,82,123,165,214,134,91,192,31,155,84,121,98,93,248,158,220,213],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","authority_canonical_b64":"sgAAAQQCogAAAWphdXRob3JpemVkA1ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvYHWCAKhJq0RdktVd4THsBIP8vGv9Mb8AiIH854B9rXBwvtyAiACYAKgAunAAABAAIAAwAEAAUABgAMWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA32DlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBBCAEYA=","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":null,"state":{"protocol":"mutation","facts":{"stage":"reserved","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry index eb5dad28b..764783e08 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-response-recorded-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/16","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[18,235,131,109,161,47,186,164,207,117,158,84,83,81,226,82,123,165,214,134,91,192,31,155,84,121,98,93,248,158,220,213],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","authority_canonical_b64":"sgAAAQQCogAAAWphdXRob3JpemVkA1ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvYHWCAKhJq0RdktVd4THsBIP8vGv9Mb8AiIH854B9rXBwvtyAiACYAKgAunAAABAAIAAwAEAAUABgAMWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA32DlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBBCAEYA=","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"da6f9e85c415185c8311dd28fb5a669799cc9c5c9adf28d6d5de0c5cf5a096fc","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"response-recorded","response_status":200,"response_digest":"0909090909090909090909090909090909090909090909090909090909090909","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry index db7ab189b..ee7c96f6f 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/record-unknown-synthetic-entry @@ -1 +1 @@ -{"revision":3,"schema":"auths.gateway-attempt/15","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[234,213,120,147,82,216,135,161,17,187,161,113,146,89,202,161,111,223,126,128,190,103,243,121,127,233,32,83,22,61,222,232],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"aLqqY4m9psWCNhdbQuwDSeKT_vd73u-0X3rOSvoTf5P4XVuFobxH4YgG9OKdEDGrWyjHVzAjnbPmIZU0_lIrBw\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"ead5789352d887a111bba1719259caa16fdf7e80be67f3797fe92053163ddee8","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file +{"revision":3,"schema":"auths.gateway-attempt/16","binding_canonical":"{\"action\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"connection\":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[18,235,131,109,161,47,186,164,207,117,158,84,83,81,226,82,123,165,214,134,91,192,31,155,84,121,98,93,248,158,220,213],\"operation\":\"synthetic-entry\",\"partition\":\"test-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[133,246,13,83,160,52,144,78,110,249,236,145,242,255,85,229,203,206,104,215,97,230,81,91,198,238,222,43,194,199,159,214]},\"qualification_policy\":\"optional\",\"recipe\":[100,255,80,4,185,117,142,47,179,116,233,214,180,67,239,27,53,170,0,196,0,219,225,53,139,144,239,137,197,201,237,169],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}","authority_canonical_b64":"sgAAAQQCogAAAWphdXRob3JpemVkA1ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABvYHWCAKhJq0RdktVd4THsBIP8vGv9Mb8AiIH854B9rXBwvtyAiACYAKgAunAAABAAIAAwAEAAUABgAMWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA32DlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBBCAEYA=","approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","namespace":"airtable-demo","operation_id":"synthetic-entry","action_commitment":"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","recipe_digest":"64ff5004b9758e2fb374e9d6b443ef1b35aa00c400dbe1358b90ef89c5c9eda9","nonce":"00112233445566778899aabbccddeeff","evaluated_at":1790000000,"entry":{"revision":2,"authorization_started_at":1790000000,"approval_canonical":"{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[218,111,158,133,196,21,24,92,131,17,221,40,251,90,102,151,153,204,156,92,154,223,40,214,213,222,12,92,245,160,150,252],\"expires_at\":1790003600,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"qLYR1rtS2s4I4BRH3O2W6D6LAwOm8GDI6o1XBGsQtDBRnh4BZcKt4KakVAq5x2gcIigaqdkof557aY0Via0JCQ\"}","pre_entry":null,"schema":"auths.effect-entry/3","granted_at":1790000000,"effect_id":"da6f9e85c415185c8311dd28fb5a669799cc9c5c9adf28d6d5de0c5cf5a096fc","dependencies":[]},"state":{"protocol":"mutation","facts":{"stage":"unknown","observation_plan":{"origin":"https://api.airtable.com","segments":[{"kind":"resolved","value":"v0"},{"kind":"resolved","value":"appTEST0000000001"},{"kind":"resolved","value":"tblTEST0000000001"},{"kind":"resolved","value":"recTEST0000000001"}],"headers":[],"json_pointer":"/fields/DemoStatus","expected":"\"Approved\"","maximum_response_bytes":16384,"echo_pointer":"/fields/auths_echo"}}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-response-recorded-synthetic-entry index be1bf6c879a7bb27d7643d0ebe9498a1254ab38b..2b853f75f7c41523571666f07c6bfa8189ab31d2 100644 GIT binary patch literal 7433 zcmeHMZBN@s5biIyAK}lNX4mgVx(^PZLTS}Pd$e3rMQeNQ?BUqPb^;vYzuz;P7oe@K zMcheMl>}k4JD#1_XJ*W^XTKfYSgl&7Eur)nmx9ZSypY4^O4y}Fdw1KIa# z*7QT+Tg*yymFcROq_V0joyrpAH)BhtJ-Cdmolior|MTZF!(mO+)(crqn!42KHBKc7 z%%W;Z2HUZjEkYJWO!zJnHZDFBj>l}y@u$md4-~jY*a|`x5D|8Gh$|>X07{ny4im%! zmr$@UV7|lf0Q9p#$cZIb(KX;C*g1@Y^T(FDf+ITK$Yua-paK_IeXHV1WW6x!ci+1J&7GNnx?JFRMl%Zp-`3D2rF=yYU*?fGthk{ zXR2#ts*G8rZhM)OYLKZ}ZIrE`U)$4QsJzEF{ibl4*URiN$^{VR!_m+sDt@}EyOQ?a6+=Rny-mkm~npR!R z@ubnzAwejNNDtw2hOiVa0uRCo2L&LP{@hM$8TF;)%MIX2uNEZ6b|^15**&7dp{zd zw5n6>!U)-s7__#8Dg3q0r=*@&*QOtX(Cb>h5i)a>*;76q;T=x6`K?vIiZ-RarkBgjXKvjgxyn!dc? zC)s&_nz`=}y3yg=aPeXhy-vbdA0C9BJBr$mqsv8q9qV}aEIumYd4*#}ag5V0&MCJ*n8!pZ1Hw9+KumYY6|Mj@%{3PXg)7sG`uLf>I4MBBQ`e0 zySi#L@?atfGmvYXbH_(I0$uBVlBm3HDb$xc*rc7Wa>P`mRgMhS)*p&xjp}p(AfC61 z5&*0K53kNnMBBf!JNM8Xog6rC><|8)|0=$GGYenr9s0HSIC{|?_j{w0YU+;uOpki^ zNS>d@7v7a!q=&kY7uk88dtM;V_^Fos3#-i1{F`9_66Hk5ztLCT>zTF(s%RR#iMYzcDD~1vWilc)>nc?w9Tx)bc3ju+dCacRk9|H=bR4`3~P84bp0xW50fmHOS>v>{Roz{HnKK zwVsA#=pY1(R#x8%q9x%n8#C$WkqW)k1*+i^IznWb9p;HAeLo7KC{0ZU$Sk+R%+I_` zab!g9Ngnxmieoa>s0y89s#Qnj{1%d-H$tA=Y?>!T>AGRU6FD*-q&GxYP(B%%2P=6& zP$!!fVbYWmqs)zkUb4`*v!;FDbUVYLZ1nRr);tGz;JHo}gdZfvjcL_D4w$XWh03r^ zDM`mIINJDsBS4zH-+%X>fY*G)cj)`1d=x#P=}Y?0%$h2hsn*z#S$}n=htu$23z3Jp zR%O-=_t0g(gLUT}^g$KD1OU}`tg#g@hb6Q^*qO;IJ)6%aP`;_F4n^P^tu1iKchE9h zDxKD75Wi$@Mwtn1qMf?Ey^m1NSK+oDCAXvGx29NXZ?>c4c9g`tw;d(FGx=>t$vXpW zN6GCdxg909qa?jL#T%5nH}KonHUIhRnqPR7Tu(d$%vg1snYnMhHleu`lhY3U%ZLWU WJou&8QJfm%W((wUQ227e1r@ z$6_#LIuJ5I(g1Z1g4AjPG6T>=Kn^HWg=2W7n;;~RM!ymQQD{~U5`a>LXbeaXHDw_V z#27FFp;Q7DL#h#@GdNATlirp8z1FK)`~7}X@5tV5J$-QL*oVV$rs5W>t&zjoa6@ab zL8&t8Rz0JvH)_Ld*Pi6{=0#4Hiq2jpH>lsW^R@e(_KjWc6poLy)^%a9I}TpgQ?WVz z&wpP!*>)|*;6gHk93i-ch_-DZM@fb}w=6V0$K$ThY}e!-B+X!GGRJXU;m?xU V;3e@E{fA?&;Qtdif?2W{`vKEgD?b1L diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_attempt/transition-entry-granted-to-unknown-synthetic-entry index ee09ac318a6159cc5afca41637322c681329509c..3f640003f9016c0b2950f38ed803b2f946f4f9b2 100644 GIT binary patch literal 7316 zcmeHLZEw>^5at)$kMQRW*|pbimF|PnR!|Cp7Ov1EC|a-A&R!GSwVkxRs{j3-agx3O zI;gml5K2n`)_Mle(H&eT7p= zf_~97B!la@%oP!fVMr z!)WaE50tqr7LD3il(QfDl3=y{5V`nJGI9ClsbMx55e>X6i~$VFtP{ z)!ekT(xx|yvQ4MbnHgkeUiHeB&~j-eWS6S39r^Mj9OuGS!b2o+@}OWcga=?|IMe00 zhkt}0u}HGWV{nZNr$z9L3r_{`vVcF~niw45VPfR_L@ivwV#Ed9DB(e{aN%}Wcx0ri zzSCpuv{z*}HJ#N1=-EIpP}HjF?AnTBr!#FgxVJ%<(8i9>UZWK8q2t9w%G$ zN|OmmIhRR_VQ5Zq?Bh8hKT%koFVxKDNMKUuE|JIzw4$IwFRQjS`R=1Y;`GOJ24)bV z_W@)g*M#6L0vrjM$n+6s0m*~oLgqt&kU~zx0sgxJtFGTKgMhRpLg9fADZ$}Qx({OV zNn={mEPEka5`)%OFoj>6d`hcDnGIIiH1vAGTMci5uL7kxJtbjwV9usC8D6!@BQq*-~C=vqB}V~cm(-qdHNju52r8A z`EhpEon-Re^LBLbCR#pQ#;?*Su?Np1UykDD!{}n!T_rZzJxvaaWKrUnQIg=ai)24Z z{zyhe^6GK2dhXurQMPz98to?gr^)YR{0)SER!8oV<0paiRa8;vQ9&W-C)5y#bP8v{ z$-0OT#vppJASqFhhEz_F&A1gv0V*fL5Bh@RBjkZpM2Ktw`t*s4Dg~@^k?I5l!Y4K^ z#k;wzE%IQZ2s4mtoO3TgIs#p*Zjze3YADoKJJ_V1FLI=>Nb4LKY^*;Ns~XkX0zkZI z3?%?q0UlnS9*d@X>$dVhj*g#uuif{-Uhp!xcs-Av?HvS__%M3b9(8-8<8mrTf9k_d z9;&mG3w>YCbcMr{pUf3Lv1?NFA!^6bXTclZWrkXG9q`}K3IMlP>or(DctU-b6t z*0U!WdI-UyQRUZyXhpcn#!LlyY$9Jvpc*cbCq$OHQJ(rL2;wk~weB-OWw{$=LFQ+M zBO`KO@i@pej>$}IN_39enwHA>4J1Qvggm*vZJrRNn}!Kb- zWAwB_gZMe~ew3NeCfcc+oBIgmeGzWkQF1#U}ItD3HS(B!D5)1pZR|n_#Wgl#UhdT<9%#XGsDTU9}T`%QsL^trxtuH zh7)E0Ap;~G(BL3Qtrj3N0WAdNfI`)5oLw0f2nnRquY^D}Gb;xPK&e7>24u`MWg!m4 z7%&2%R00)4su818I7xcr?q%@3)~(umy=i1_q08A|L$9-b zu{`Wle6wWKtAk9(8Rv|~c~%w+?ru8UuidtC)w}K1wNq;6j}GNgnBbe1DQ$17Gj-}?^w0)VYPG6~;f$BOv ztGl7_EM~=~Oih_j5>-~ENmK#y+p(pR4qV38&bbimzx?~cuvuL<)j}1Mx++X^gI!62 zeo{9igR~`+B4A<2gy%3JF?dYaE|Z+&r^BQR3XCC^{DApHgcTlO1f}pn=`i1Bf_PvE z1PgrT*$gj0KM6ukEWwIKpOau0Fb?(~TlyLX8C!RlOR8CIie4@V`N*(3%XHEW))d2F zZ1pdcnaSskT3eK}ANrDDNmZ8EY6Z~`v17faNuyI;b_O8iy3`wC1vb-ll}up9V(Q41+p2)_V~4iE$j3D~8u$w*awugBPG zZ^~|}JCh8cX9K}NQLCmiD=UtzPPg6Q!4wfRRaYfd0X5)~8+Vw^yA_(CY4qhBZ}ytn zBnY_?=^;GM;FiLH<3Tt9!JH7Lz`6sS9C$2gfk%mHj#tU^;HFZzEQH6}oNUo6O(rDe zBy-4zp*i`ni}!@{h1~LTt_qVOfJvSEKq4#9jDiZitcj@!yK{lS>9^+$%pgRM0c0X* zeDD??wuDS%`hYW!QwAyBEAofF?*DqA)M}Sw!gF9WvR*=k9aaB=#KSvo?>S z==gZIqVZEbO+TMhvHiN%v(t-6U=zCM~Cl&#j8d5HVz_lco4YGC~Q8Dt`^-*WTM@(=qQioCAJww5q7(Z_M_;xXp~29 zpC_v=_ljrP;{9l}8||M(zmoCSDf~$txetz?B&9FCid>Hh3Z;I^8Umh9?u>M@Dk79) z;Juh|C{PfFR8A1hcoYZ$DksAA`hw%a<&mj~5Yd9{(+4W56mpeBs8b>kF0qm1@A|qn zh=YluoPk*5oZBA45!tosCb7<{hFpEQf<;>STa5G-X%!=bwe^Q$S)*E$BN5LVO#uK_ zNDpt$PDImvkgap*j7|>hck+|B=e>!p-pztndxu^nK963t$KBrOq?|gV-;<-xIZ_v= z(WQGW^W@Ov>N35kGS~Ih89z0OzurB@Zoqz16R6X8SP`(c$-xtoQY1c3!sIx86`P=D z&P+E$Y6caLf9wmkjiy95NllK_43?ggWiIDV9QtmcWft4Mqr=pT9mm$0h;3IX&J&08 zG}dS=f;i+l3&O-rLY=CR)U3)xlXP4Nz->E@>w2E=2SFGr6~{@ErW)=AQjKP2j&3Uj z#*cus`r2ddl=GrMe}*aoj<=gK1Mch60xlVB)6z2Na@u*BJavk-D&FMLNnI%Pd$$$} zZf@{oO}nmccZNe%o0n@qUc$n7uhlsj8EnsQ`+BxyTNR6*Ey+zgEjW6ee zk-W42h;Pt$aq%pA;P;gN3$vzLrMe;E@#BxSFLb8tbOVuxnbAes4)@TCe1Ku+Edg;| zqfLTpJJ#5WmK`PP1y*M2+RWy&32a(dWs69;LH!3+4UY>qaO+v&(67%pum~nd4V9Z1F(2d{?WKJS; z0P!B~%n>|*GvFz7QB?gu_5D!PJ6k{|m0J0D&EyUHjR$6Em?~T|m!j45w-MGiqG!f| zkO7hf$OTA>r31)pKnDQ@po}XSlP&ImR6rK}S_ni591|n~RUBe5Af9+JLIQ{}U<5LD z3E~)v8!@_o^PHX!Z^D<&VbeVvjXJ!qhWD+#qif$gp3Dk$U1@ZuzF?CrtIfvM`gG6; z>>6)3CkF#>UgDjrqN-N>{X%ivdhC^&PdmLkuhuW0o><-6@_2U^JuK(b|M2X^dd~dA zZw*V?vu*AAwvdY1D2r7UMnUF!4>r;-K3 zqH4(o+p(D~LKa0#_%0JRE8h>mey5;qaGppDRpe{G;LL;Dx(2Hp(?d8R^Twz)ae{yp!-TL zRM*H<4PlYGH8LsHC{v4iaJGV%OEsgo)U7szCXKv@7!Koda&5GF;QN7BL;EJ9uYMi&S|g$>wk;ZTt3=E;w# z)!kKQu8dAc@Uw+skZ5FU^kWpKmQkGmtw^{q*qZ8wu)7o}oZ)!RpbSO~7{Dfi zCV+0?<4D*8D1>%$C#Ub<`&);10)9lKe zXYR+tZgTV?T)tjL?~*XqM~9*3PNMen)z4+iF{+)uqZsFg|k*DJLMOykQt0?topit|lt|5@=l+I`;k3)od z46+vsE)@#Okj4qB8Mgu@K;uMs{xEPnq&zwm38GrieTG8CltQnvQR>tPghy&@%6E0! zXw<<>QqMrGan2nd<%sTDn^~grx}{WK?O>C3{!t^tM0%`|(K`BLv6@kxF3^bkR#5>! z723nwi&N2>GrMz-+{x*o^WOgC@B44#oA-Yn;tyV8CBxfO_&mAm|`=` z%!M`!v}Q>0 zo+S#zB1|H#@-RxhG*X$2$j!P+644DrBf*WCYR-)L~?yV`vF9 z#K2g`$OI$?)M8|=V`OZsV{D{j0TeaT0UBcjq>PM>Vs&DaQY#8FC$D2K2ut)SEQ~bC zwJazOclOIjNeV12cL`4Q4v8;IF*h#NHHa`S@((V{4@ol(Fo_5&b<0nx@Gyx?cenKS sPH}Z{FAA^B@(8PP%*sm&$n}g0HHgpgEOIK}T*9HxJOaJ_L|Bm-09+}Cy#N3J diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index a6d869bf4..99a1b164d 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5015ba2efebd3183736a6e452b942994be51a72040420eca9a3048561835bbc6"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"ec6946dc29427d25a75eadacc07b7ef8c0d8b8cc7cc21c2d5fd8586539c8c71a"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"9208d094f86417e990a2bc9cfaa79019dba83fe0074f47d0b6cbb50d341a9ab1"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"69e89867e3cfba6c80948240127de9d6d051de90137ffef3247c57d90b0d0130"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"e00bb1428efe63e816b97594e723d15b158a9987d30bfd8056958cf8e743a63b"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"271aaa0bc3fd735401b6f1b3700b9707eed13e2b44fa6e82105111cf844787e8"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"46a9a0f784fb0aed7d3ea1d74fa7bb8aa3372818588d105735cd0056a83755b6"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"58b2caff5f84f4131229a1e043149b5d8d4146f1de3f86320a7688cc578e7503"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"448512dd483139f9e7e9a70c2cb66d00e8a9d0eaf4eb38db017a7a938dbb7af8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"6366a85dad1f7c0c3e223a279a7eba1d8fe77c41e6865fa114998faae6bb971e"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"ca86c232a4a73b74b24765d9a6038a059ab99a82d569f55bea9ac4c0bb6db743"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"3ace705b67971cdea7962bd25c46177f1d83e46d65469018b5afb6af1830acad"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"fb47da2a926cfe51464e80570a9163851434e0ecc759f0c3d69922a45c1dcb08"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"b44b0d9216c3ad07a4f5a2218bc4d02a93b3071362ec2c0ff97a964235af7989"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"46c37671bc58cb1f66b902fcb543b93da6ff0874456df1bdc7f464dfd05a1ded"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"36d0be48098c8c424fb1d996dcbfd7c81c1cb945e190a5e7ffc018146742f01e"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"62bd348db3c4794590b1f416b6ffbb346a29504a2e64e93ad5bccaa50e35b818"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"8d2e8222e4d2b61c009805156c2454a7e30e8200a64639d751db145452fd4c4b"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"1d9f5682b93908ae670067a15f53d97369e2510d56eb1f65529833176aa86bdc"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8326f25e92ee4f114620f7fee268f3e3d0a08d01dabc3c40387893c0e1b3e4e2"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"76882cc523eb8a1e33438d0ec0e3533cfa9fa9675da2f51c1c3661b963c12977"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"77702d7841708b772d6cf1344a636e8484a96669cf0b5c4aed7bf30854d4fbb9"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"005be8acd2c6a995eeea538cd03970319e79a87d5519898a5d242ebb309b7f86"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"a1a6181f2d647d5b547b7f6d3873a10f5614851763226b0786d669e5179e0d0a"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index a06592fbc..c34f101c3 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -390,16 +390,28 @@ impl GatewayEngine { approval: ExactEffectApproval, ) -> Result { let started = Instant::now(); - let effect = self.compile_candidate_effect(target, proof, action).await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); + let retained = self + .retained_acquisition( + proof, + action, + &approval, + super::RetainedRoute::Candidate(target), + ) + .await?; + if let Some(snapshot) = &retained + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot.clone()); + } + let current = async { + let effect = self.compile_candidate_effect(target, proof, action).await?; + self.approve_current_effect(effect, approval) + } + .await; + let (approved, now) = match current { + Ok(current) => current, + Err(result) => return retained.map_or(Err(result), Ok), + }; if let Some(snapshot) = self .attempts .read_acquisition(&approved) diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 405d44d0f..6802c0357 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -11,13 +11,15 @@ use crate::{ OperatorNamespace, QualificationPolicy, }; use auths_connections::ConnectionRecord; -use auths_model::{PortableVerificationResult, Timestamp, TrustedContext, VerificationResources}; +use auths_model::TrustedContext; use base64ct::{Base64UrlUnpadded, Encoding as _}; use ed25519_dalek::{Signature, VerifyingKey}; use serde::{Deserialize, Serialize}; use std::fmt; use zeroize::Zeroizing; +mod authority; +pub(crate) use authority::NativeAuthority; mod acquisition; mod capacity; pub(crate) use capacity::SourceCapacity; @@ -279,7 +281,7 @@ fn approve_driver_with_plan( let mut binding = store_binding_fixture( &command.request, recipe_digest, - command.native_authority, + command.native_authority.commitment(), &fixture_policy().map_err(|_| invalid())?, ) .map_err(|_| invalid())?; @@ -288,6 +290,7 @@ fn approve_driver_with_plan( }; binding = EffectBinding::new(binding.wire).map_err(|_| invalid())?; let effect = BoundEffect { + authority: command.native_authority.clone(), review: serde_json::json!({"scope": "synthetic post-verification oracle; no human review claim"}), binding, command: CompiledEffect::Mutation(Box::new(VerifiedMutation { @@ -601,6 +604,18 @@ impl EffectBinding { let ApprovalPolicy::Exact { approver } = self.wire.approval_policy; approval.verify(self.id(), &approver, at) } + pub(crate) fn validate_historical_approval( + &self, + approval: &ExactEffectApproval, + ) -> Result<(), EffectBindingError> { + let ApprovalPolicy::Exact { approver } = self.wire.approval_policy; + approval.verify_signature(self.id(), &approver) + } + + pub(crate) fn matches_authority(&self, authority: &NativeAuthority) -> bool { + self.wire.native_authority == authority.commitment() + } + fn new(wire: BindingWire) -> Result { validate(&wire)?; let bytes = canonical(&wire)?; @@ -755,6 +770,7 @@ struct VerifiedMutation { /// exact immutable compiler output. There is no public constructor, clone or /// deserializer. Compiling this value does not approve it or grant entry. pub struct BoundEffect { + authority: NativeAuthority, review: serde_json::Value, binding: EffectBinding, command: CompiledEffect, @@ -843,6 +859,10 @@ impl fmt::Debug for BoundEffect { } impl BoundEffect { + pub(crate) fn native_authority(&self) -> &NativeAuthority { + &self.authority + } + /// Returns immutable audit/approval data, never entry authority. #[must_use] pub const fn binding(&self) -> &EffectBinding { @@ -1112,11 +1132,21 @@ impl ExactEffectApproval { now: u64, ) -> Result<(), EffectBindingError> { self.request.validate()?; - if self.request.effect != *effect.as_bytes() - || self.request.approver != *installed - || now < self.request.not_before - || now >= self.request.expires_at - { + if now < self.request.not_before || now >= self.request.expires_at { + return Err(EffectBindingError::Invalid); + } + self.verify_signature(effect, installed) + } + + /// Identifies private retained history only; this samples no clock, changes + /// no signed event time and cannot establish current execution permission. + fn verify_signature( + &self, + effect: EffectId, + installed: &[u8; 32], + ) -> Result<(), EffectBindingError> { + self.request.validate()?; + if self.request.effect != *effect.as_bytes() || self.request.approver != *installed { return Err(EffectBindingError::Invalid); } VerifyingKey::from_bytes(installed) @@ -1437,7 +1467,7 @@ fn bind_mutation( epoch: installed.epoch, operation: request.operation_id().as_str().to_owned(), action: *request.action_commitment(), - native_authority: command.native_authority, + native_authority: command.native_authority.commitment(), scope: Scope::Unscoped, recipe: *installed.recipe.digest(), compiler: COMPILER.to_owned(), @@ -1459,6 +1489,7 @@ fn bind_mutation( "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.", }); let effect = BoundEffect { + authority: command.native_authority.clone(), review, binding, command: CompiledEffect::Mutation(Box::new(VerifiedMutation { @@ -1477,47 +1508,6 @@ fn bind_mutation( Ok(effect) } -/// Preserve all selected branches and evidence through the existing native -/// codec. Evaluation time and work counters are not authority identities: the -/// full verifier is rerun at a new time, without changing signed event times. -pub(crate) fn native_authority_commitment( - result: &PortableVerificationResult, - context: &TrustedContext, -) -> Result<[u8; 32], EffectBindingError> { - let normalized = context - .for_request( - context.expected_audience().clone(), - context.expected_challenge(), - Timestamp::new(0), - ) - .map_err(|_| EffectBindingError::Invalid)?; - let context_digest = - auths_codec::context_digest(&normalized).map_err(|_| EffectBindingError::Invalid)?; - let projection = PortableVerificationResult::new( - result.decision(), - result.stage(), - result.code(), - result.proof_digest(), - result.action_digest(), - context_digest, - result.plan_id(), - result.authorized_branches().to_vec(), - result.assurance().to_vec(), - result.assurance_satisfactions().to_vec(), - VerificationResources::new(0, 0, 0, 0, 0, 0, 0), - result.registry_manifest(), - result.required_configuration(), - result.local_configuration(), - ) - .with_observation_satisfactions(result.observation_satisfactions().to_vec()) - .with_approval_satisfactions(result.approval_satisfactions().to_vec()); - let bytes = Zeroizing::new( - auths_codec::encode_verification_result(&projection) - .map_err(|_| EffectBindingError::Invalid)?, - ); - commitment("auths.effect-native-authority/1", &bytes) -} - #[derive(Serialize)] struct ReadWire<'a> { url: &'a str, diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 1b67a7462..136469dd4 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -6,9 +6,9 @@ use super::{ ApprovalPolicy, BindingWire, BoundEffect, COMPILER, CompiledEffect, CompiledRecipe, Deserialize, EFFECT_BINDING_SCHEMA, EffectBinding, EffectBindingError, EffectInstallation, GatewayConnectionDescriptor, GatewaySubmitResult, LogicalOperationId, MAX_EFFECT_BYTES, - PrerequisitePlan, Prerequisites, Protocol, ReadWire, Reservation, ReservationWindow, Scope, - Serialize, SourceCapacity, Unit, Zeroizing, canonical, commitment, fmt, managed_reservations, - native_authority_commitment, not_entered, + NativeAuthority, PrerequisitePlan, Prerequisites, Protocol, ReadWire, Reservation, + ReservationWindow, Scope, Serialize, SourceCapacity, Unit, Zeroizing, canonical, commitment, + fmt, managed_reservations, not_entered, }; use auths_profile_api::ActionProfile as _; use auths_profile_mcp::{McpProfile, McpToolCall}; @@ -581,14 +581,14 @@ pub(super) fn compile_verified_acquisition( AcquisitionTarget::Candidate(target) => target.prerequisites().clone(), }; let authority = - native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?; + NativeAuthority::verified(sealed.portable(), installed.context).map_err(|_| invalid())?; let (binding, review) = match &target { AcquisitionTarget::Recovery(target) => ( target.binding( installed, &operation, action_commitment, - authority, + authority.commitment(), bound.as_ref(), &prerequisites, )?, @@ -600,7 +600,7 @@ pub(super) fn compile_verified_acquisition( installed, &operation, action_commitment, - authority, + authority.commitment(), bound.as_ref(), &prerequisites, )?, @@ -612,7 +612,7 @@ pub(super) fn compile_verified_acquisition( installed, &operation, action_commitment, - authority, + authority.commitment(), bound.as_ref(), )?, json!({"contract": "auths.gateway-candidate-check/1", "candidate": target.contract(), @@ -620,6 +620,7 @@ pub(super) fn compile_verified_acquisition( ), }; let effect = BoundEffect { + authority, review, binding, command: CompiledEffect::Acquisition(Box::new(VerifiedAcquisition { diff --git a/product/runtime/auths-gateway/src/effect/authority.rs b/product/runtime/auths-gateway/src/effect/authority.rs new file mode 100644 index 000000000..feebc2bb7 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect/authority.rs @@ -0,0 +1,140 @@ +//! Retained preimage of the existing native authority commitment. This is +//! private historical evidence, never a verifier result that can grant entry. +use super::{EffectBindingError, MAX_EFFECT_BYTES, commitment}; +use auths_model::{ + PortableVerificationResult, Timestamp, TrustedContext, VerificationDecision, + VerificationResources, +}; +use std::fmt; +use zeroize::Zeroizing; + +#[derive(Clone)] +pub(crate) struct NativeAuthority { + canonical: Zeroizing>, + commitment: [u8; 32], +} + +impl fmt::Debug for NativeAuthority { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("NativeAuthority { private: [redacted] }") + } +} + +impl NativeAuthority { + /// Time and work counters are not authority identities. Preserve the exact + /// native branch/evidence selection and installed trust, with only those + /// two evaluation-specific inputs normalized as before. + pub(crate) fn verified( + result: &PortableVerificationResult, + context: &TrustedContext, + ) -> Result { + let normalized = context + .for_request( + context.expected_audience().clone(), + context.expected_challenge(), + Timestamp::new(0), + ) + .map_err(|_| EffectBindingError::Invalid)?; + let context_digest = + auths_codec::context_digest(&normalized).map_err(|_| EffectBindingError::Invalid)?; + let projection = PortableVerificationResult::new( + result.decision(), + result.stage(), + result.code(), + result.proof_digest(), + result.action_digest(), + context_digest, + result.plan_id(), + result.authorized_branches().to_vec(), + result.assurance().to_vec(), + result.assurance_satisfactions().to_vec(), + VerificationResources::new(0, 0, 0, 0, 0, 0, 0), + result.registry_manifest(), + result.required_configuration(), + result.local_configuration(), + ) + .with_observation_satisfactions(result.observation_satisfactions().to_vec()) + .with_approval_satisfactions(result.approval_satisfactions().to_vec()); + Self::from_result(&projection) + } + + fn from_result(result: &PortableVerificationResult) -> Result { + let result = result.clone().with_result_digest( + auths_codec::verification_result_digest(result) + .map_err(|_| EffectBindingError::Invalid)?, + ); + let bytes = Zeroizing::new( + auths_codec::encode_verification_result(&result) + .map_err(|_| EffectBindingError::Invalid)?, + ); + Self::from_private_bytes(&bytes) + } + + pub(crate) fn from_private_bytes(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_EFFECT_BYTES { + return Err(EffectBindingError::Invalid); + } + let result = auths_codec::decode_verification_result(bytes) + .map_err(|_| EffectBindingError::Invalid)?; + if result.decision() != VerificationDecision::Authorized + || result.resources() != VerificationResources::new(0, 0, 0, 0, 0, 0, 0) + { + return Err(EffectBindingError::Invalid); + } + // The existing binding commitment encodes the normalized projection + // before its portable self-digest is attached. Retain a valid canonical + // report, and reconstruct that exact preimage through the native codec. + // This preserves EffectId while making the history input digests usable. + let preimage = Zeroizing::new( + auths_codec::encode_verification_result( + &result.with_result_digest(auths_model::VerificationResultDigest::new([0; 32])), + ) + .map_err(|_| EffectBindingError::Invalid)?, + ); + Ok(Self { + canonical: Zeroizing::new(bytes.to_vec()), + commitment: commitment("auths.effect-native-authority/1", &preimage)?, + }) + } + + pub(crate) const fn commitment(&self) -> [u8; 32] { + self.commitment + } + + pub(crate) fn private_bytes(&self) -> &[u8] { + &self.canonical + } + + pub(crate) fn matches_inputs(&self, proof: &[u8], action: &[u8]) -> bool { + auths_codec::decode_verification_result(&self.canonical).is_ok_and(|result| { + result.proof_digest() == auths_codec::body_digest(proof) + && result.action_digest() == auths_codec::body_digest(action) + }) + } + + /// Explicit post-verification reference data. No installed engine uses it. + #[cfg(test)] + pub(crate) fn oracle(proof: [u8; 32]) -> Self { + use auths_model::{ + ContextDigest, Digest, RegistryManifestId, VerificationCode, VerificationStage, + VerifierConfigurationId, + }; + Self::from_result(&PortableVerificationResult::new( + VerificationDecision::Authorized, + VerificationStage::Complete, + VerificationCode::Authorized, + Digest::new(proof), + Digest::new([0; 32]), + ContextDigest::new([0; 32]), + None, + Vec::new(), + Vec::new(), + Vec::new(), + VerificationResources::new(0, 0, 0, 0, 0, 0, 0), + RegistryManifestId::new([0; 32]), + None, + VerifierConfigurationId::new([0; 32]), + )) + .expect("post-verification oracle authority") + } +} diff --git a/product/runtime/auths-gateway/src/effect/prerequisite.rs b/product/runtime/auths-gateway/src/effect/prerequisite.rs index 8dc748119..0f13419ae 100644 --- a/product/runtime/auths-gateway/src/effect/prerequisite.rs +++ b/product/runtime/auths-gateway/src/effect/prerequisite.rs @@ -222,7 +222,7 @@ impl Prerequisites { (Some(read), Some(pointers)) => plan.push( Purpose::PreEntry { json_pointers: pointers.to_vec(), - native_authority: command.native_authority, + native_authority: command.native_authority.commitment(), }, ClosedPrerequisiteRead::Action(read.clone()), )?, diff --git a/product/runtime/auths-gateway/src/effect/release.rs b/product/runtime/auths-gateway/src/effect/release.rs index 5dd2aa771..be8d733bf 100644 --- a/product/runtime/auths-gateway/src/effect/release.rs +++ b/product/runtime/auths-gateway/src/effect/release.rs @@ -4,9 +4,9 @@ use super::{ BoundEffect, CompiledEffect, CompiledRecipe, DISCLOSURE_ACK_SCHEMA, Deserialize, DisclosureAcknowledgementRequest, EffectBinding, EffectBindingError, EffectInstallation, GatewayConnectionDescriptor, GatewaySubmitResult, LogicalOperationId, MAX_EFFECT_BYTES, - Prerequisites, Protocol, Reservation, ReservationWindow, Scope, Serialize, SourceCapacity, - Unit, VerifyingKey, Zeroizing, acquisition, canonical, commitment, fmt, managed_reservations, - native_authority_commitment, not_entered, + NativeAuthority, Prerequisites, Protocol, Reservation, ReservationWindow, Scope, Serialize, + SourceCapacity, Unit, VerifyingKey, Zeroizing, acquisition, canonical, commitment, fmt, + managed_reservations, not_entered, }; use auths_profile_api::ActionProfile as _; use auths_profile_mcp::{McpProfile, McpToolCall}; @@ -242,7 +242,7 @@ pub fn compile_disclosure( let action_commitment = commitment("auths.canonical-action.v1", &canonical_action).map_err(|_| invalid())?; let authority = - native_authority_commitment(sealed.portable(), installed.context).map_err(|_| invalid())?; + NativeAuthority::verified(sealed.portable(), installed.context).map_err(|_| invalid())?; let mut reservations = target.reservations().map_err(|_| invalid())?; reservations.extend(managed_reservations( bound.as_ref(), @@ -254,11 +254,12 @@ pub fn compile_disclosure( installed, &operation, action_commitment, - authority, + authority.commitment(), target.protocol(), reservations, )?; let effect = BoundEffect { + authority, review: json!({"contract": CONTRACT, "disclosure": target.contract(), "consequences": "Release the exact retained projection to this recipient and channel once. A grant makes delivery possible; only an exact authenticated ACK records the recipient assertion. Lost delivery or ACK never authorizes redelivery or refund."}), binding, diff --git a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs index 257c70f9c..0c4b844bd 100644 --- a/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs +++ b/product/runtime/auths-gateway/src/effect_prerequisite_tests.rs @@ -242,7 +242,7 @@ async fn native_prerequisite_compilation_fixture_is_current() { let journal = serde_json::to_vec_pretty(&json!({ "schema": "auths.prerequisite-entry-fixture/1", "scope": "native signed compilation; real file journal with explicit-time oracle grants and synthetic responses; no provider send or installed authority claim", - "attempt_schema": "auths.gateway-attempt/15", + "attempt_schema": "auths.gateway-attempt/16", "cases": journals, })).expect("journal fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index e26d4c07f..abc45ddc2 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -396,6 +396,56 @@ struct PreparedEntry { transport: GatewayHttpTransport, } +/// Data-only endpoint constraints for retained history. Native compilation still +/// owns all fresh authorization and grants; these checks bind extra API inputs +/// to the exact historical action rather than trusting an operation-ID hint. +enum RetainedRoute<'a> { + Mutation, + Content(Option<&'a Map>), + Recovery(&'a str), + Disclosure(&'a crate::effect::DisclosureTarget), + Candidate(&'a crate::effect::CandidateCredentialTarget), +} + +impl RetainedRoute<'_> { + fn matches( + &self, + recipe: &CompiledRecipe, + operation: &crate::LogicalOperationId, + call: &auths_profile_mcp::McpToolCall, + ) -> bool { + if call.service() != recipe.review().service() { + return false; + } + match self { + Self::Mutation => call.name() == recipe.review().tool(), + Self::Content(arguments) => { + call.name() == crate::effect::CONTENT_READ_TOOL + && arguments.is_none_or(|arguments| { + call.arguments() + .get("resource_arguments") + .and_then(Value::as_object) + == Some(arguments) + }) + } + Self::Recovery(source) => { + call.name() == crate::effect::RECOVERY_READ_TOOL + && call + .arguments() + .get("source_operation") + .and_then(Value::as_str) + == Some(*source) + } + Self::Disclosure(target) => target + .authorization_call(recipe, operation) + .is_ok_and(|expected| &expected == call), + Self::Candidate(target) => target + .authorization_call(recipe, operation) + .is_ok_and(|expected| &expected == call), + } + } +} + impl GatewayEngine { /// Constructs an engine only for an exact operator-approved recipe digest. /// The caller must be the separately deployed gateway, never the app. @@ -1385,6 +1435,12 @@ impl GatewayEngine { action: &[u8], approval: ExactEffectApproval, ) -> Result { + if let Some(snapshot) = self + .retained_disclosure(target, proof, action, &approval) + .await? + { + return Ok(snapshot); + } let started = Instant::now(); let effect = self .compile_disclosure_effect(target, proof, action) @@ -1469,18 +1525,25 @@ impl GatewayEngine { connection: crate::disclosure_transport::DisclosureConnection, ) -> Result { let started = Instant::now(); - let effect = self - .compile_disclosure_effect(target, proof, action) + let retained = self + .retained_disclosure(target, proof, action, &approval) .await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); + if let Some(snapshot) = &retained + && snapshot.stage != crate::DisclosureStage::Reserved + { + return Ok(snapshot.clone()); + } + let current = async { + let effect = self + .compile_disclosure_effect(target, proof, action) + .await?; + self.approve_current_effect(effect, approval) + } + .await; + let (approved, now) = match current { + Ok(current) => current, + Err(result) => return retained.map_or(Err(result), Ok), + }; if let Some(snapshot) = self .attempts .read_disclosure(&approved) @@ -1626,16 +1689,23 @@ impl GatewayEngine { approval: ExactEffectApproval, ) -> Result { let started = Instant::now(); - let effect = self.compile_content_action(proof, action).await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); + let retained = self + .retained_acquisition(proof, action, &approval, RetainedRoute::Content(None)) + .await?; + if let Some(snapshot) = &retained + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot.clone()); + } + let current = async { + let effect = self.compile_content_action(proof, action).await?; + self.approve_current_effect(effect, approval) + } + .await; + let (approved, now) = match current { + Ok(current) => current, + Err(result) => return retained.map_or(Err(result), Ok), + }; self.acquire_read_approved(approved, now, started).await } @@ -1723,18 +1793,30 @@ impl GatewayEngine { approval: ExactEffectApproval, ) -> Result { let started = Instant::now(); - let effect = self - .compile_content_effect(arguments, proof, action) + let retained = self + .retained_acquisition( + proof, + action, + &approval, + RetainedRoute::Content(Some(&arguments)), + ) .await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); + if let Some(snapshot) = &retained + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot.clone()); + } + let current = async { + let effect = self + .compile_content_effect(arguments, proof, action) + .await?; + self.approve_current_effect(effect, approval) + } + .await; + let (approved, now) = match current { + Ok(current) => current, + Err(result) => return retained.map_or(Err(result), Ok), + }; self.acquire_read_approved(approved, now, started).await } @@ -1786,18 +1868,30 @@ impl GatewayEngine { approval: ExactEffectApproval, ) -> Result { let started = Instant::now(); - let effect = self - .compile_recovery_effect(source_operation, proof, action) + let retained = self + .retained_acquisition( + proof, + action, + &approval, + RetainedRoute::Recovery(source_operation), + ) .await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); + if let Some(snapshot) = &retained + && snapshot.stage != crate::AcquisitionStage::Reserved + { + return Ok(snapshot.clone()); + } + let current = async { + let effect = self + .compile_recovery_effect(source_operation, proof, action) + .await?; + self.approve_current_effect(effect, approval) + } + .await; + let (approved, now) = match current { + Ok(current) => current, + Err(result) => return retained.map_or(Err(result), Ok), + }; self.acquire_read_approved(approved, now, started).await } @@ -2021,12 +2115,26 @@ impl GatewayEngine { action_cbor: &[u8], approval: ExactEffectApproval, ) -> GatewaySubmitResult { + let retained = match self + .retained_submission(proof_cbor, action_cbor, &approval, RetainedRoute::Mutation) + .await + { + Ok(Some(crate::store::RetainedSubmission::Mutation(snapshot))) => Some(snapshot), + Ok(None) => None, + Ok(Some(_)) => return not_entered("gateway.effect.operation-conflict"), + Err(result) => return result, + }; + if let Some(snapshot) = &retained + && snapshot.stage() != crate::GatewayAttemptStage::Reserved + { + return stored_result(snapshot); + } let approved = match self .approve_submission(proof_cbor, action_cbor, approval) .await { Ok(approved) => approved, - Err(result) => return result, + Err(result) => return retained.as_ref().map_or(result, stored_result), }; let io = EngineIo { engine: self, @@ -2052,6 +2160,123 @@ impl GatewayEngine { .await } + async fn retained_submission( + &self, + proof: &[u8], + action: &[u8], + approval: &ExactEffectApproval, + route: RetainedRoute<'_>, + ) -> Result, GatewaySubmitResult> { + if proof.is_empty() + || proof.len() > MAX_PROOF_BYTES + || action.is_empty() + || action.len() > MAX_ACTION_BYTES + { + return Err(GatewaySubmitResult::Indeterminate { + code: "gateway.submit.invalid-size".to_owned(), + }); + } + // Data-only lookup hints, never a verified command. Hard decode bounds + // keep historical lookup independent of a newly installed trust policy. + // The journal must match the native committed proof AND action digests, + // complete binding and its own pinned approval key before exposing facts. + let Some(call) = + auths_codec::decode_canonical_action(action, &auths_model::VerifierLimits::hard()) + .ok() + .and_then(|action| { + auths_profile_mcp::McpToolCall::from_canonical_bytes(action.body()).ok() + }) + else { + return Ok(None); + }; + if call + .arguments() + .get("operator_namespace") + .and_then(Value::as_str) + != Some(self.recipe.namespace().as_str()) + { + return Ok(None); + } + let Some(operation) = call + .arguments() + .get("operation_id") + .and_then(Value::as_str) + .and_then(|value| crate::LogicalOperationId::parse(value).ok()) + else { + return Ok(None); + }; + if !route.matches(&self.recipe, &operation, &call) { + return Ok(None); + } + self.attempts + .retained_submission( + self.recipe.namespace(), + &operation, + *self.recipe.digest(), + proof, + action, + approval, + ) + .await + .map_err(|error| match error { + crate::GatewayAttemptError::BindingConflict => { + not_entered("gateway.effect.operation-conflict") + } + _ => GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned(), + }, + }) + } + + async fn retained_acquisition( + &self, + proof: &[u8], + action: &[u8], + approval: &ExactEffectApproval, + route: RetainedRoute<'_>, + ) -> Result, GatewaySubmitResult> { + match self + .retained_submission(proof, action, approval, route) + .await? + { + Some(crate::store::RetainedSubmission::Acquisition(snapshot)) => Ok(Some(snapshot)), + None => Ok(None), + Some(_) => Err(not_entered("gateway.effect.operation-conflict")), + } + } + + async fn retained_disclosure( + &self, + target: &crate::effect::DisclosureTarget, + proof: &[u8], + action: &[u8], + approval: &ExactEffectApproval, + ) -> Result, GatewaySubmitResult> { + match self + .retained_submission(proof, action, approval, RetainedRoute::Disclosure(target)) + .await? + { + Some(crate::store::RetainedSubmission::Disclosure(snapshot)) => Ok(Some(snapshot)), + None => Ok(None), + Some(_) => Err(not_entered("gateway.effect.operation-conflict")), + } + } + + fn approve_current_effect( + &self, + effect: crate::effect::BoundEffect, + approval: ExactEffectApproval, + ) -> Result<(Arc, u64), GatewaySubmitResult> { + let now = self + .qualification + .effect_time() + .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; + let approved = effect + .approve(approval, self.effect_policy.approver(), now) + .map_err(|_| not_entered("gateway.effect.approval"))?; + Ok((Arc::new(approved), now)) + } + async fn approve_submission( &self, proof: &[u8], @@ -2552,7 +2777,7 @@ pub(crate) fn verify_command( #[derive(Clone, Debug)] pub(crate) struct VerifiedCommand { /// Stable native branch/evidence selection and installed trust identity. - pub(crate) native_authority: [u8; 32], + pub(crate) native_authority: crate::effect::NativeAuthority, /// Exact actors of action IDs already sealed by the native verifier. #[cfg(unix)] pub(crate) actors: Vec, @@ -2652,7 +2877,7 @@ pub(crate) fn verify_detailed( .map_err(|_| not_entered("gateway.policy.proof-unavailable"))?; let observer_refusal = crate::separation::check_proof_observers(proof_cbor, action).err(); Ok(VerifiedCommand { - native_authority: crate::effect::native_authority_commitment(sealed.portable(), context) + native_authority: crate::effect::NativeAuthority::verified(sealed.portable(), context) .map_err(|_| not_entered("gateway.effect.native-authority"))?, #[cfg(unix)] actors: branches.actors, diff --git a/product/runtime/auths-gateway/src/entry_tests.rs b/product/runtime/auths-gateway/src/entry_tests.rs index c73c93340..a303fa970 100644 --- a/product/runtime/auths-gateway/src/entry_tests.rs +++ b/product/runtime/auths-gateway/src/entry_tests.rs @@ -32,6 +32,49 @@ fn approved() -> Arc { ) } +#[test] +fn retained_native_authority_projection_is_required_and_bound() { + use base64ct::{Base64, Encoding as _}; + let approved = approved(); + let record = claim_record( + &approved.command().expect("mutation").request, + approved.effect().binding(), + approved.approval(), + approved.effect().native_authority(), + NOW, + ) + .expect("native header"); + let bytes = encode(&record).expect("encode"); + assert!(decode(&bytes).is_ok()); + let original: serde_json::Value = serde_json::from_slice(&bytes).expect("record JSON"); + let evidence = approved.effect().native_authority().private_bytes(); + let mut damaged = evidence.to_vec(); + damaged[0] ^= 1; + for replacement in [ + None, + Some("not-canonical-base64".to_owned()), + Some(Base64::encode_string(&damaged)), + Some(Base64::encode_string( + crate::effect::NativeAuthority::oracle([42; 32]).private_bytes(), + )), + ] { + let mut altered = original.clone(); + match replacement { + Some(value) => altered["authority_canonical_b64"] = serde_json::json!(value), + None => { + altered + .as_object_mut() + .expect("object") + .remove("authority_canonical_b64"); + } + } + assert!(matches!( + decode(&serde_json::to_vec(&altered).expect("JSON")), + Err(GatewayAttemptError::Corrupt) + )); + } +} + fn bounded_approval() -> Arc { use ed25519_dalek::Signer as _; let recipes: serde_json::Value = serde_json::from_slice(include_bytes!( diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 3a58a5d6c..2323478ca 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -175,3 +175,8 @@ mod native_postgres_fault_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_postgres_commit_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_information_replay_tests; +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_mutation_replay_tests; diff --git a/product/runtime/auths-gateway/src/native_dependency_tests.rs b/product/runtime/auths-gateway/src/native_dependency_tests.rs index 5b114003a..e6d8c3bae 100644 --- a/product/runtime/auths-gateway/src/native_dependency_tests.rs +++ b/product/runtime/auths-gateway/src/native_dependency_tests.rs @@ -253,6 +253,8 @@ fn run_worker(race: &Race, store: &TestAttempts) { let controls = EngineControls { policy: crate::effect::fixture_policy().expect("policy"), clock, + recipe: None, + trust: None, }; let runtime = runtime(); let (engine, _) = runtime.block_on(load_controlled_engine( diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs new file mode 100644 index 000000000..6c1fb4eb4 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -0,0 +1,478 @@ +//! Native retained read/release replay over real HTTP and authenticated Unix +//! sockets. Same-UID tests establish no hostile-process isolation guarantee. +use crate::effect::{ + CONTENT_READ_TOOL, DISCLOSURE_TOOL, ExactEffectApproval, UnixDisclosurePolicy, +}; +use crate::harness::authoring::{tool_fixture_until, tools_context}; +use crate::native_mutation_replay_tests::Change; +use crate::native_process_tests::{ + CONTENT, EngineControls, NOW, Provider, Setup, load_controlled_engine, recipe, runtime, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + FixedClock, GatewayAttempts, GatewayEngine, GatewayRecordKind, LogicalOperationId, + SharedConnection, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde_json::{Value, json}; +use std::{ + os::unix::fs::{MetadataExt as _, PermissionsExt as _}, + path::Path, + sync::{Arc, atomic::Ordering}, +}; +use tokio::net::UnixStream; + +const SOURCE: &str = "retained-read"; +const RELEASE: &str = "retained-release"; + +#[derive(Clone, Copy, Debug)] +enum Protocol { + Acquisition, + Acknowledged, + LostAcknowledgement, +} +impl Protocol { + const fn label(self) -> &'static str { + match self { + Self::Acquisition => "acquisition-response", + Self::Acknowledged => "disclosure-acknowledged", + Self::LostAcknowledgement => "disclosure-unknown", + } + } +} + +fn controls(clock: Arc, reviewer: u8) -> EngineControls { + let recipe = recipe(); + let tools = [CONTENT_READ_TOOL, DISCLOSURE_TOOL].map(|name| { + McpToolCall::new(recipe.review().service(), name, serde_json::Map::new()).expect("tool") + }); + let mut controls = EngineControls::baseline(); + controls.trust = Some(tools_context(&tools, NOW).expect("native trust")); + controls.clock = clock; + controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + SigningKey::from_bytes(&[reviewer; 32]) + .verifying_key() + .to_bytes(), + ) + .expect("policy"); + controls +} + +struct Input { + proof: Vec, + action: Vec, + approval: ExactEffectApproval, +} +impl Input { + fn approval(effect: crate::effect::BoundEffect, change: Change) -> ExactEffectApproval { + let until = if matches!(change, Change::ApprovalExpiry) { + NOW + 5 + } else { + NOW + 300 + }; + let request = effect.approval_request(NOW, until).expect("review request"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + request.with_signature(signature) + } + fn until(change: Change) -> u64 { + if matches!(change, Change::AuthorityExpiry) { + NOW + 5 + } else { + NOW + 86_400 + } + } + async fn content(engine: &GatewayEngine, change: Change) -> Self { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, SOURCE) + .await + .expect("native read call"); + let signed = + tool_fixture_until(&call, NOW, Self::until(change)).expect("native read proof"); + let effect = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("native read effect"); + Self { + proof: signed.proof, + action: signed.action, + approval: Self::approval(effect, change), + } + } + async fn disclosure( + engine: &GatewayEngine, + target: &crate::effect::DisclosureTarget, + change: Change, + ) -> Self { + let operation = LogicalOperationId::parse(RELEASE).expect("operation"); + let call = target + .authorization_call(&recipe(), &operation) + .expect("native release call"); + let signed = + tool_fixture_until(&call, NOW, Self::until(change)).expect("independent release proof"); + let effect = engine + .compile_disclosure_effect(target, &signed.proof, &signed.action) + .await + .expect("native release effect"); + Self { + proof: signed.proof, + action: signed.action, + approval: Self::approval(effect, change), + } + } +} + +struct Fixture { + _directory: tempfile::TempDir, + setup: Setup, + store: TestAttempts, + provider: Provider, + clock: Arc, + runtime: tokio::runtime::Runtime, + engine: GatewayEngine, +} +impl Fixture { + fn new(backend: Backend) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::controlled(None); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }; + let clock = Arc::new(FixedClock::at(NOW)); + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "original", + store.attempts().clone(), + controls(clock.clone(), 29), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + Self { + _directory: directory, + setup, + store, + provider, + clock, + runtime, + engine, + } + } + fn records(&self) -> Vec> { + let raw = self.store.raw(); + raw.attempt_keys(8) + .expect("keys") + .iter() + .map(|key| { + raw.load(GatewayRecordKind::Attempt, key) + .expect("load") + .expect("record") + }) + .collect() + } + fn change_and_reopen(&self, change: Change) -> GatewayEngine { + match change { + Change::None | Change::ConfigurationReplaced => {} + Change::ApprovalExpiry | Change::AuthorityExpiry => self.clock.set(NOW + 6), + Change::ConnectionRevoked => { + self.runtime + .block_on(self.engine.revoke_connection()) + .expect("native revocation"); + } + } + let controls = controls( + self.clock.clone(), + if matches!(change, Change::ConfigurationReplaced) { + 30 + } else { + 29 + }, + ); + let attempts = GatewayAttempts::new(self.store.reopen().store(), controls.policy.clone()) + .expect("reopened policy"); + let (engine, _) = self.runtime.block_on(load_controlled_engine( + &self.setup, + "reopened", + attempts, + controls, + )); + if matches!(change, Change::ConfigurationReplaced) { + let revision = engine + .effect_configuration_revision() + .expect("review configuration"); + engine + .activate_effect_configuration(revision) + .expect("native configuration CAS"); + } + engine + } +} + +async fn release( + engine: &GatewayEngine, + input: &Input, + target: &crate::effect::DisclosureTarget, + policy: &UnixDisclosurePolicy, + recipient: &SigningKey, + acknowledge: bool, +) -> crate::DisclosureSnapshot { + let effect = engine + .compile_disclosure_effect(target, &input.proof, &input.action) + .await + .expect("review"); + let binding = effect.binding().clone(); + let (server, client) = UnixStream::pair().expect("local channel"); + let receiver = async { + let received = crate::disclosure_transport::receive_disclosure( + crate::disclosure_transport::DisclosureConnection::new(client, policy.clone()), + &binding, + CONTENT.len() as u64, + recipient, + ) + .await + .expect("authenticated exact delivery"); + assert_eq!(received.content(), CONTENT); + if acknowledge { + received + .acknowledge(recipient) + .await + .expect("exact native ACK"); + } + }; + let (result, ()) = tokio::join!( + engine.disclose( + target, + &input.proof, + &input.action, + input.approval.clone(), + crate::disclosure_transport::DisclosureConnection::new(server, policy.clone()) + ), + receiver, + ); + let result = result.expect("native release"); + assert_eq!( + result.stage, + if acknowledge { + crate::DisclosureStage::Acknowledged + } else { + crate::DisclosureStage::Unknown + } + ); + result +} + +struct ReleaseHistory { + input: Input, + target: crate::effect::DisclosureTarget, + policy: UnixDisclosurePolicy, + snapshot: crate::DisclosureSnapshot, +} + +fn prepare_release( + fixture: &Fixture, + protocol: Protocol, + change: Change, +) -> Option { + if matches!(protocol, Protocol::Acquisition) { + return None; + } + let recipient = SigningKey::from_bytes(&[47; 32]); + let uid = std::fs::metadata(&fixture.setup.root).expect("owner").uid(); + let policy = UnixDisclosurePolicy::new(uid, uid, [51; 32]); + let target = fixture + .runtime + .block_on(fixture.engine.disclosure_target( + SOURCE, + recipient.verifying_key().to_bytes(), + policy.commitment().expect("channel"), + [52; 32], + )) + .expect("retained source"); + let input = fixture + .runtime + .block_on(Input::disclosure(&fixture.engine, &target, change)); + let snapshot = fixture.runtime.block_on(release( + &fixture.engine, + &input, + &target, + &policy, + &recipient, + matches!(protocol, Protocol::Acknowledged), + )); + Some(ReleaseHistory { + input, + target, + policy, + snapshot, + }) +} + +async fn replay_content( + engine: &GatewayEngine, + input: &Input, + expected: &crate::AcquisitionSnapshot, +) -> Value { + let replay = engine + .acquire_content_action(&input.proof, &input.action, input.approval.clone()) + .await + .expect("retained read"); + assert_eq!(&replay, expected); + let changed = json!({"record_id":"recTEST0000000002"}) + .as_object() + .expect("arguments") + .clone(); + assert!( + engine + .acquire_content(changed, &input.proof, &input.action, input.approval.clone()) + .await + .is_err() + ); + serde_json::to_value(replay).expect("snapshot") +} + +async fn replay_release(engine: &GatewayEngine, history: &ReleaseHistory) -> Value { + let ReleaseHistory { + input, + target, + policy, + snapshot, + } = history; + let (server, mut client) = UnixStream::pair().expect("replay channel"); + let replay = engine + .disclose( + target, + &input.proof, + &input.action, + input.approval.clone(), + crate::disclosure_transport::DisclosureConnection::new(server, policy.clone()), + ) + .await + .expect("retained release"); + assert_eq!(&replay, snapshot); + use tokio::io::AsyncReadExt as _; + let mut byte = [0]; + assert_eq!( + client.read(&mut byte).await.expect("closed replay"), + 0, + "history sends neither challenge nor content" + ); + let changed = engine + .disclosure_target( + SOURCE, + SigningKey::from_bytes(&[48; 32]).verifying_key().to_bytes(), + policy.commitment().expect("channel"), + [52; 32], + ) + .await + .expect("changed proposal"); + assert!( + engine + .admit_disclosure( + &changed, + &input.proof, + &input.action, + input.approval.clone() + ) + .await + .is_err() + ); + serde_json::to_value(replay).expect("snapshot") +} + +fn one_case(backend: Backend, protocol: Protocol, change: Change) -> Value { + eprintln!( + "native information replay: {}/{protocol:?}/{change:?}", + backend.label() + ); + let fixture = Fixture::new(backend); + let source = fixture + .runtime + .block_on(Input::content(&fixture.engine, change)); + let acquired = fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &source.proof, + &source.action, + source.approval.clone(), + )) + .expect("native acquisition"); + assert_eq!(acquired.stage, crate::AcquisitionStage::ResponseRecorded); + assert_eq!(acquired.reserved_calls, 1); + assert_eq!(acquired.reserved_bytes, 1024); + let disclosure = prepare_release(&fixture, protocol, change); + let retained = fixture.records(); + let reopened = fixture.change_and_reopen(change); + let witness = reopened.execution_witness(); + let result = fixture.runtime.block_on(async { + match &disclosure { + None => replay_content(&reopened, &source, &acquired).await, + Some(disclosure) => replay_release(&reopened, disclosure).await, + } + }); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!(fixture.records(), retained); + json!({"protocol":protocol.label(), "change":change.label(), "native_snapshot":result, + "provider_reads":1, "reopened_native_engine":true, "no_replay_authentication_or_delivery":true, + "changed_caller_target_refused":true, "journal_and_execution_witness_unchanged":true}) +} + +fn matrix(backend: Backend) { + let mut cases = Vec::new(); + for protocol in [ + Protocol::Acquisition, + Protocol::Acknowledged, + Protocol::LostAcknowledgement, + ] { + for change in [ + Change::None, + Change::ApprovalExpiry, + Change::AuthorityExpiry, + Change::ConnectionRevoked, + Change::ConfigurationReplaced, + ] { + cases.push(one_case(backend, protocol, change)); + } + } + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-information-retained-replay/1", "adapter":backend.label(), + "scope":"native proof, independent read/release approvals, real HTTP and authenticated Unix delivery; fixed public keys, same UID and maintained clock; retained facts confer no execution authority", "cases":cases})).expect("artifact"); + let output = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-information-retained-replay-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &artifact).expect("write"); + } + assert_eq!(std::fs::read(output).expect("fixture"), artifact); +} + +#[test] +fn native_file_information_retained_replay_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_information_retained_replay_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs new file mode 100644 index 000000000..f424aa97f --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs @@ -0,0 +1,514 @@ +//! Retained mutation facts outlive current authority and exact approval. +//! Real native compilation, approval, durable adapters and local HTTP; public +//! fixture identities and the maintained test clock remain explicit assumptions. +use crate::harness::authoring::{tool_fixture_until, tools_context}; +use crate::native_process_tests::{EngineControls, NOW, Setup, load_controlled_engine, runtime}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + CompiledRecipe, FixedClock, GatewayAttempts, GatewayEngine, GatewayRecordKind, + GatewaySubmitResult, LogicalOperationId, SharedConnection, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::TcpListener, + os::unix::fs::PermissionsExt as _, + path::Path, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + thread::{self, JoinHandle}, + time::Duration, +}; + +const OPERATION: &str = "retained-mutation"; +const SECRET: &[u8] = b"public-native-process-fixture"; + +struct Provider { + port: u16, + bodies: Arc>>>, + stop: Arc, + task: Option>, +} +impl Provider { + fn start() -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); + listener.set_nonblocking(true).expect("poll"); + let port = listener.local_addr().expect("address").port(); + let bodies = Arc::new(Mutex::new(Vec::new())); + let captured = bodies.clone(); + let stop = Arc::new(AtomicBool::new(false)); + let done = stop.clone(); + let task = thread::spawn(move || { + while !done.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(pair) => pair, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(2)); + continue; + } + Err(error) => panic!("accept: {error}"), + }; + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut header = Vec::new(); + while !header.ends_with(b"\r\n\r\n") { + assert!(header.len() < 16_384); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + header.push(byte[0]); + } + let header = String::from_utf8(header).expect("header UTF-8"); + assert!(header.starts_with( + "PATCH /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1\r\n" + )); + assert!(header.to_ascii_lowercase().contains(&format!( + "authorization: bearer {}\r\n", + String::from_utf8_lossy(SECRET) + ))); + let length = header + .lines() + .find_map(|line| { + let (key, value) = line.split_once(':')?; + key.eq_ignore_ascii_case("content-length") + .then(|| value.trim().parse::().expect("length")) + }) + .expect("body length"); + assert!(length <= 65_536); + let mut body = vec![0; length]; + stream.read_exact(&mut body).expect("body"); + captured.lock().expect("capture").push(body); + stream + .write_all( + b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}", + ) + .expect("response"); + } + }); + Self { + port, + bodies, + stop, + task: Some(task), + } + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(task) = self.task.take() { + let result = task.join(); + if !thread::panicking() { + result.expect("provider task"); + } + } + } +} + +#[derive(Clone, Copy, Debug)] +pub(super) enum Change { + None, + ApprovalExpiry, + AuthorityExpiry, + ConnectionRevoked, + ConfigurationReplaced, +} +impl Change { + pub(super) const fn label(self) -> &'static str { + match self { + Self::None => "unchanged", + Self::ApprovalExpiry => "approval-expired", + Self::AuthorityExpiry => "resource-authority-expired", + Self::ConnectionRevoked => "connection-revoked", + Self::ConfigurationReplaced => "configuration-replaced", + } + } +} +fn recipe() -> CompiledRecipe { + CompiledRecipe::compile( + include_bytes!("../../../../bindings/fixtures/gateway/airtable/recipe.json"), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), + ) + .expect("mutation recipe") +} +fn controls(clock: Arc, reviewer: u8) -> EngineControls { + let recipe = recipe(); + let call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + serde_json::Map::new(), + ) + .expect("tool"); + let mut controls = EngineControls::baseline(); + controls.recipe = Some(recipe); + controls.trust = Some(tools_context(&[call], NOW).expect("native trust")); + controls.clock = clock; + controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + SigningKey::from_bytes(&[reviewer; 32]) + .verifying_key() + .to_bytes(), + ) + .expect("policy"); + controls +} +struct Input { + proof: Vec, + action: Vec, + approval: crate::effect::ExactEffectApproval, + body: Vec, + changed: Vec, +} +impl Input { + async fn author(engine: &GatewayEngine, change: Change) -> Self { + let recipe = recipe(); + let arguments = json!({"operator_namespace":recipe.namespace().as_str(),"recipe_digest":recipe.digest_hex(),"operation_id":OPERATION,"record_id":"recTEST0000000001","replacement":"Approved"}); + let call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + arguments.as_object().expect("arguments").clone(), + ) + .expect("call"); + let signed = tool_fixture_until( + &call, + NOW, + if matches!(change, Change::AuthorityExpiry) { + NOW + 5 + } else { + NOW + 86_400 + }, + ) + .expect("native signed authority"); + let effect = engine + .compile_effect(&signed.proof, &signed.action) + .await + .expect("native effect"); + let mut changed_call = call.arguments().clone(); + changed_call.insert("replacement".to_owned(), json!("Pending")); + let changed_call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + changed_call, + ) + .expect("changed call"); + let changed = vec![ + tool_fixture_until(&call, NOW, NOW + 86_399).expect("different valid native proof"), + tool_fixture_until(&changed_call, NOW, NOW + 86_400) + .expect("different valid native action"), + ]; + for alternative in &changed { + let compiled = engine + .compile_effect(&alternative.proof, &alternative.action) + .await + .expect("positive native changed-input control"); + assert_ne!(compiled.binding().id(), effect.binding().id()); + } + let body = effect + .private_request() + .expect("mutation request") + .body() + .to_vec(); + let expires = if matches!(change, Change::ApprovalExpiry) { + NOW + 5 + } else { + NOW + 300 + }; + let request = effect + .approval_request(NOW, expires) + .expect("approval request"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + Self { + proof: signed.proof, + action: signed.action, + approval: request.with_signature(signature), + body, + changed, + } + } + async fn submit(&self, engine: &GatewayEngine) -> GatewaySubmitResult { + engine + .submit(&self.proof, &self.action, self.approval.clone()) + .await + } +} + +fn one_case(backend: Backend, change: Change) -> Value { + eprintln!("native retained mutation: {}/{change:?}", backend.label()); + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::start(); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }; + let clock = Arc::new(FixedClock::at(NOW)); + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "original", + store.attempts().clone(), + controls(clock.clone(), 29), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let input = runtime.block_on(Input::author(&engine, change)); + let expected = runtime.block_on(input.submit(&engine)); + assert_eq!( + expected, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!( + *provider.bodies.lock().expect("requests"), + vec![input.body.clone()] + ); + let operation = LogicalOperationId::parse(OPERATION).expect("operation"); + let key = crate::GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &operation, + ) + .expect("key"); + let stored = store + .raw() + .load(GatewayRecordKind::Attempt, &key) + .expect("record") + .expect("record"); + let history = runtime + .block_on(store.attempts().read(recipe().namespace(), &operation)) + .expect("history") + .expect("history"); + let replacement = changed_engine(change, &runtime, &engine, &setup, &store, &clock); + let engine = replacement.as_ref().unwrap_or(&engine); + let result = assert_replay(ReplayCheck { + runtime: &runtime, + engine, + input: &input, + store: &store, + provider: &provider, + key: &key, + stored: &stored, + history: &history, + expected: &expected, + change, + }); + let reopened = reopened_engine(change, &runtime, &setup, &store, &clock); + assert_replay(ReplayCheck { + runtime: &runtime, + engine: &reopened, + input: &input, + store: &store, + provider: &provider, + key: &key, + stored: &stored, + history: &history, + expected: &expected, + change, + }); + result +} + +fn changed_engine( + change: Change, + runtime: &tokio::runtime::Runtime, + engine: &GatewayEngine, + setup: &Setup, + store: &TestAttempts, + clock: &Arc, +) -> Option { + let mut replacement = None; + match change { + Change::None => {} + Change::ApprovalExpiry | Change::AuthorityExpiry => clock.set(NOW + 6), + Change::ConnectionRevoked => { + runtime + .block_on(engine.revoke_connection()) + .expect("native revocation"); + } + Change::ConfigurationReplaced => { + let control = controls(clock.clone(), 30); + let attempts = + GatewayAttempts::new(store.raw(), control.policy.clone()).expect("new policy"); + let (next, _) = runtime.block_on(load_controlled_engine( + setup, + "replacement", + attempts, + control, + )); + let revision = next + .effect_configuration_revision() + .expect("review revision"); + next.activate_effect_configuration(revision) + .expect("native configuration CAS"); + replacement = Some(next); + } + } + replacement +} + +fn reopened_engine( + change: Change, + runtime: &tokio::runtime::Runtime, + setup: &Setup, + store: &TestAttempts, + clock: &Arc, +) -> GatewayEngine { + let control = controls( + clock.clone(), + if matches!(change, Change::ConfigurationReplaced) { + 30 + } else { + 29 + }, + ); + let attempts = GatewayAttempts::new(store.reopen().store(), control.policy.clone()) + .expect("reopened policy"); + let (reopened, _) = + runtime.block_on(load_controlled_engine(setup, "reopened", attempts, control)); + reopened +} + +struct ReplayCheck<'a> { + runtime: &'a tokio::runtime::Runtime, + engine: &'a GatewayEngine, + input: &'a Input, + store: &'a TestAttempts, + provider: &'a Provider, + key: &'a crate::GatewayAttemptKey, + stored: &'a [u8], + history: &'a crate::GatewayAttemptSnapshot, + expected: &'a GatewaySubmitResult, + change: Change, +} + +fn assert_replay(check: ReplayCheck<'_>) -> Value { + let ReplayCheck { + runtime, + engine, + input, + store, + provider, + key, + stored, + history, + expected, + change, + } = check; + let operation = LogicalOperationId::parse(OPERATION).expect("operation"); + let witness = engine.execution_witness(); + for alternative in &input.changed { + let result = runtime.block_on(engine.submit( + &alternative.proof, + &alternative.action, + input.approval.clone(), + )); + assert_eq!( + result, + GatewaySubmitResult::NotEntered { + code: "gateway.effect.operation-conflict".to_owned() + } + ); + } + let mut invalid: Value = + serde_json::from_slice(&input.approval.to_private_bytes().expect("approval")) + .expect("shape"); + use base64ct::{Base64UrlUnpadded, Encoding as _}; + let mut signature = + Base64UrlUnpadded::decode_vec(invalid["signature_b64"].as_str().expect("signature")) + .expect("base64"); + signature[0] ^= 1; + invalid["signature_b64"] = json!(Base64UrlUnpadded::encode_string(&signature)); + let invalid = crate::effect::ExactEffectApproval::from_private_bytes( + &serde_json_canonicalizer::to_vec(&invalid).expect("canonical"), + ) + .expect("invalid signature is data"); + let refused = runtime.block_on(engine.submit(&input.proof, &input.action, invalid)); + assert_eq!( + refused, + GatewaySubmitResult::NotEntered { + code: "gateway.effect.operation-conflict".to_owned() + } + ); + let replay = runtime.block_on(input.submit(engine)); + assert_eq!( + &replay, expected, + "retained entered facts cannot become a current non-entry assertion: {change:?}" + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!( + *provider.bodies.lock().expect("requests"), + vec![input.body.clone()] + ); + assert_eq!( + store + .raw() + .load(GatewayRecordKind::Attempt, key) + .expect("record") + .expect("record"), + stored + ); + assert_eq!( + runtime + .block_on(store.attempts().read(recipe().namespace(), &operation)) + .expect("history") + .expect("history"), + *history + ); + json!({"change":change.label(),"native_result":replay,"actual_provider_writes":1,"same_request_body_as_review":true,"retained_journal_and_execution_witness_unchanged":true,"different_valid_proof_action_and_invalid_approval_refused":true}) +} + +fn matrix(backend: Backend) { + let cases: Vec<_> = [ + Change::None, + Change::ApprovalExpiry, + Change::AuthorityExpiry, + Change::ConnectionRevoked, + Change::ConfigurationReplaced, + ] + .into_iter() + .map(|change| one_case(backend, change)) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-retained-replay/1","adapter":backend.label(),"scope":"full native mutation engine, actual exact approval/proof, maintained durable adapter and real local HTTP; fixed public keys and maintained test clock; no current execution authority inferred from retained history","cases":cases})).expect("artifact"); + let output = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-mutation-retained-replay-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&output, &artifact).expect("write"); + } + assert_eq!(std::fs::read(output).expect("fixture"), artifact); +} +#[test] +fn native_file_mutation_retained_replay_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_retained_replay_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index ffb3c8836..167ff2927 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -80,12 +80,16 @@ pub(super) fn runtime() -> tokio::runtime::Runtime { pub(super) struct EngineControls { pub(super) policy: crate::effect::EffectPolicy, pub(super) clock: Arc, + pub(super) recipe: Option, + pub(super) trust: Option>, } impl EngineControls { pub(super) fn baseline() -> Self { Self { policy: fixture_policy().expect("policy"), clock: Arc::new(crate::FixedClock::at(NOW)), + recipe: None, + trust: None, } } } @@ -104,7 +108,8 @@ pub(super) async fn load_controlled_engine( attempts: GatewayAttempts, controls: EngineControls, ) -> (GatewayEngine, ConnectionRecord) { - let recipe = recipe(); + let recipe = controls.recipe.unwrap_or_else(recipe); + let trust = controls.trust.unwrap_or_else(|| trust(&recipe)); let initial = crate::harness::fixture_connection(&recipe).expect("connection template"); let credentials = Arc::new( PersistentCredentialStore::open(setup.root.join(format!("custody-{label}.cbor"))) @@ -154,7 +159,7 @@ pub(super) async fn load_controlled_engine( let engine = GatewayEngine::new( recipe.clone(), *recipe.digest(), - &trust(&recipe), + &trust, controls.policy, record.provider_kind().clone(), record.alias().clone(), diff --git a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs index ba80767e2..4d0dd19f2 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/attempts.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/attempts.rs @@ -19,7 +19,7 @@ use serde_json::{Map, Value, json}; pub(crate) const FILE: &str = "attempt-scenarios-v3.json"; const SCHEMA: &str = "auths.gateway-attempt-scenarios/3"; -const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/15"; +const ATTEMPT_SCHEMA: &str = "auths.gateway-attempt/16"; const STRIPE_VERSION: &str = "2025-03-31.basil"; const ACCOUNT: &str = "acct_TESTACCOUNT01"; const PLATFORM: &str = "acct_TESTPLATFORM1"; diff --git a/product/runtime/auths-gateway/src/qualification.rs b/product/runtime/auths-gateway/src/qualification.rs index 13d4a708f..e0fd234c0 100644 --- a/product/runtime/auths-gateway/src/qualification.rs +++ b/product/runtime/auths-gateway/src/qualification.rs @@ -25,7 +25,7 @@ pub const QUALIFICATION_POLICY_REFUSED: &str = "gateway.install.qualification-po /// The schema identifier of the production lifecycle store. pub const POSTGRES_STORE_SCHEMA: &str = "auths.lifecycle.postgresql/8"; /// The schema identifier of the development file store. -pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/15"; +pub const FILE_STORE_SCHEMA: &str = "auths.gateway-attempt/16"; /// The public qualification root this gateway build pins. A reviewed release /// supplies only the offline ceremony's public artifact here. A root alone diff --git a/product/runtime/auths-gateway/src/qualification_tests.rs b/product/runtime/auths-gateway/src/qualification_tests.rs index 37438e76e..93b27b20c 100644 --- a/product/runtime/auths-gateway/src/qualification_tests.rs +++ b/product/runtime/auths-gateway/src/qualification_tests.rs @@ -39,7 +39,7 @@ fn tuple_for(family: &str) -> QualificationTuple { "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": digest("55"), "store_kind": "shared-file-v1", - "store_schema": "auths.gateway-attempt/15", + "store_schema": "auths.gateway-attempt/16", "credential_store_kind": "local-file-v1", }, })) diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index d3c93d595..392070935 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -412,7 +412,7 @@ pub(crate) fn admitted( .map_err(|error| crate::engine::not_entered(error.code()))?; Ok(VerifiedCommand { // This corpus deliberately enters after native verification. - native_authority: [0; 32], + native_authority: crate::effect::NativeAuthority::oracle([0; 32]), #[cfg(unix)] actors: Vec::new(), request, @@ -1508,7 +1508,7 @@ async fn attempt_scenario(case: &Value, corpus: &Value, recipes: &Value, backend async fn attempt_scenarios(backend: Backend) { let corpus = corpus(SCENARIOS); assert_eq!(corpus["schema"], "auths.gateway-attempt-scenarios/3"); - assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/15"); + assert_eq!(corpus["attempt_schema"], "auths.gateway-attempt/16"); let recipes = self::corpus(corpus["recipes"].as_str().expect("recipes")); let mut ran = 0; for case in corpus["cases"].as_array().expect("cases") { @@ -1637,7 +1637,7 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { "gateway_semantic_closure_sha256": crate::GATEWAY_SEMANTIC_CLOSURE_SHA256, "target": {"os": "linux", "arch": "x86_64", "gateway_package": "auths-gateway", "gateway_version": "1.0.0-rc.1", "gateway_build_sha256": "55".repeat(32), - "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/15", + "store_kind": "shared-file-v1", "store_schema": "auths.gateway-attempt/16", "credential_store_kind": "local-file-v1"} })) .expect("tuple"); @@ -1897,7 +1897,7 @@ async fn conformance_complete_binding_and_scope(backend: Backend) { "renewing approval reopens the reservation without replacing its bytes" ); let mut changed_authority = command.clone(); - changed_authority.native_authority = [42; 32]; + changed_authority.native_authority = crate::effect::NativeAuthority::oracle([42; 32]); for changed in [ approve(changed_authority, *record.recipe.digest(), NOW), approve(command.clone(), [42; 32], NOW), diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 61e6148a1..69bb37a99 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "367d7abda8c215f0d5e9ffc51fb6af4fea1a10eb38aaedfcd5e797a397f32136"; + "7758b4850998aa8c6da86b7fef12a4176a3c90c9211683fd1f0b122789076932"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 0b7ad0a1b..846fcb94a 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -2,7 +2,7 @@ //! the shared connection record. This store does not infer provider effect. //! //! [`GatewayAttempts`] owns the attempt record format -//! `auths.gateway-attempt/15`, its stages, and which stage changes are valid; +//! `auths.gateway-attempt/16`, its stages, and which stage changes are valid; //! the transition rule itself is the translated leaf //! `auths_gateway_kernel::transition::valid_transition`. Records persist //! through a [`GatewayAttemptStore`], which is only an all-or-none @@ -36,7 +36,7 @@ use thiserror::Error; pub use auths_stores::GatewayRecordKind; -const SCHEMA: &str = "auths.gateway-attempt/15"; +const SCHEMA: &str = "auths.gateway-attempt/16"; const PRE_ENTRY_DOMAIN: &[u8] = b"auths.gateway-pre-entry/1\0"; const BATCH_SCHEMA: &str = "auths.gateway-file-batch/1"; const SLOT_FILE_SCHEMA: &str = "auths.gateway-file-slot/1"; @@ -524,6 +524,7 @@ struct Record { revision: u64, schema: String, binding_canonical: String, + authority_canonical_b64: String, approval_canonical: String, namespace: String, operation_id: String, @@ -539,6 +540,7 @@ impl Record { fn new( binding: &EffectBinding, approval: &ExactEffectApproval, + authority: &crate::effect::NativeAuthority, evaluated_at: u64, state: S, ) -> Result { @@ -554,6 +556,7 @@ impl Record { .to_vec(), ) .map_err(|_| GatewayAttemptError::Corrupt)?, + authority_canonical_b64: Base64::encode_string(authority.private_bytes()), approval_canonical: String::from_utf8( approval .to_private_bytes() @@ -572,9 +575,28 @@ impl Record { }) } + fn native_authority(&self) -> Result { + if self.authority_canonical_b64.len() > crate::effect::MAX_EFFECT_BYTES.div_ceil(3) * 4 { + return Err(GatewayAttemptError::Corrupt); + } + let bytes = zeroize::Zeroizing::new( + Base64::decode_vec(&self.authority_canonical_b64) + .map_err(|_| GatewayAttemptError::Corrupt)?, + ); + if Base64::encode_string(&bytes) != self.authority_canonical_b64 { + return Err(GatewayAttemptError::Corrupt); + } + crate::effect::NativeAuthority::from_private_bytes(&bytes) + .map_err(|_| GatewayAttemptError::Corrupt) + } + fn validate_header(&self) -> Result { let binding = EffectBinding::from_private_bytes(self.binding_canonical.as_bytes()) .map_err(|_| GatewayAttemptError::Corrupt)?; + let authority = self.native_authority()?; + if !binding.matches_authority(&authority) { + return Err(GatewayAttemptError::Corrupt); + } let approval = ExactEffectApproval::from_private_bytes(self.approval_canonical.as_bytes()) .map_err(|_| GatewayAttemptError::Corrupt)?; binding @@ -684,6 +706,7 @@ impl Record { revision: self.revision, schema: self.schema, binding_canonical: self.binding_canonical, + authority_canonical_b64: self.authority_canonical_b64, approval_canonical: self.approval_canonical, namespace: self.namespace, operation_id: self.operation_id, @@ -799,6 +822,7 @@ struct EntryAudit { struct FixedFields<'a> { schema: &'a str, binding_canonical: &'a str, + authority_canonical_b64: &'a str, approval_canonical: &'a str, namespace: &'a str, operation_id: &'a str, @@ -900,6 +924,7 @@ impl Record { fixed: canonical(&FixedFields { schema: &self.schema, binding_canonical: &self.binding_canonical, + authority_canonical_b64: &self.authority_canonical_b64, approval_canonical: &self.approval_canonical, namespace: &self.namespace, operation_id: &self.operation_id, @@ -2222,11 +2247,13 @@ fn claim_record( request: &ClosedProviderRequest, binding: &EffectBinding, approval: &ExactEffectApproval, + authority: &crate::effect::NativeAuthority, evaluated_at: u64, ) -> Result { let record = Record::new( binding, approval, + authority, evaluated_at, MutationState { counters: Vec::new(), @@ -2296,9 +2323,13 @@ impl GatewayAttempts { recipe_digest: [u8; 32], evaluated_at: u64, ) -> Result { - let binding = - crate::effect::store_binding_fixture(request, recipe_digest, [0; 32], &self.policy) - .map_err(|_| GatewayAttemptError::Corrupt)?; + let binding = crate::effect::store_binding_fixture( + request, + recipe_digest, + crate::effect::NativeAuthority::oracle([0; 32]).commitment(), + &self.policy, + ) + .map_err(|_| GatewayAttemptError::Corrupt)?; let approval = crate::effect::approval_fixture(&binding, evaluated_at) .map_err(|_| GatewayAttemptError::Corrupt)?; self.claim_binding(request, &binding, &approval, evaluated_at) @@ -2317,7 +2348,13 @@ impl GatewayAttempts { return Err(GatewayAttemptError::BindingConflict); } let key = self.key(request.namespace(), request.operation_id())?; - let record = claim_record(request, binding, approval, evaluated_at)?; + let record = claim_record( + request, + binding, + approval, + &crate::effect::NativeAuthority::oracle([0; 32]), + evaluated_at, + )?; let stored = encode(&record)?; let store = Arc::clone(&self.store); let entry = GatewayRecordEntry { @@ -3022,7 +3059,63 @@ pub enum ContentHistory { Disclosure(DisclosureSnapshot), } +/// Stored facts only. No variant contains an entry permit or current authority. +pub(crate) enum RetainedSubmission { + Mutation(GatewayAttemptSnapshot), + Acquisition(AcquisitionSnapshot), + Disclosure(DisclosureSnapshot), +} + impl GatewayAttempts { + /// Matches the native verifier's exact committed input digests and a signed + /// approval for that retained binding. Current approval windows and installed + /// keys govern new execution, not retrieval of already admitted facts. + pub(crate) async fn retained_submission( + &self, + namespace: &OperatorNamespace, + operation: &LogicalOperationId, + recipe: [u8; 32], + proof: &[u8], + action: &[u8], + approval: &ExactEffectApproval, + ) -> Result, GatewayAttemptError> { + let key = self.key(namespace, operation)?; + let store = Arc::clone(&self.store); + let Some(bytes) = blocking(move || store.load(GatewayRecordKind::Attempt, &key)).await? + else { + return Ok(None); + }; + let bytes = zeroize::Zeroizing::new(bytes); + let record = decode_protocol(&bytes)?; + let binding = record.validate_header()?; + if !self.policy.contains(&binding) + || record.namespace != namespace.as_str() + || record.operation_id != operation.as_str() + || record.recipe_digest != hex::encode(recipe) + || !record.native_authority()?.matches_inputs(proof, action) + { + return Err(GatewayAttemptError::BindingConflict); + } + binding + .validate_historical_approval(approval) + .map_err(|_| GatewayAttemptError::BindingConflict)?; + match &record.state { + ProtocolState::Mutation(_) => Ok(Some(RetainedSubmission::Mutation( + record.map_state(MutationState::extract)?.snapshot(true)?, + ))), + ProtocolState::Acquisition(_) => Ok(Some(RetainedSubmission::Acquisition( + record + .map_state(acquisition::AcquisitionState::extract)? + .snapshot()?, + ))), + ProtocolState::Disclosure(_) => Ok(Some(RetainedSubmission::Disclosure( + record + .map_state(disclosure::DisclosureState::extract)? + .disclosure_snapshot()?, + ))), + } + } + /// Loads exact local content history without reconstructing any entry permit. /// /// # Errors @@ -3426,6 +3519,7 @@ impl GatewayAttempts { .request, admission.approved.effect().binding(), admission.approved.approval(), + admission.approved.effect().native_authority(), evaluated_at, )?; let result = if let Some(bound) = &bound { diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index 618c7e13f..c003e8cf4 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -136,6 +136,7 @@ impl JournalProtocol for AcquisitionState { fixed: canonical(&( &record.schema, &record.binding_canonical, + &record.authority_canonical_b64, &record.approval_canonical, &record.namespace, &record.operation_id, @@ -681,6 +682,7 @@ impl GatewayAttempts { let base = Record::new( admission.approved.effect().binding(), admission.approved.approval(), + admission.approved.effect().native_authority(), evaluated_at, AcquisitionState { plan, diff --git a/product/runtime/auths-gateway/src/store/disclosure.rs b/product/runtime/auths-gateway/src/store/disclosure.rs index 26e4b2957..987575853 100644 --- a/product/runtime/auths-gateway/src/store/disclosure.rs +++ b/product/runtime/auths-gateway/src/store/disclosure.rs @@ -89,6 +89,7 @@ impl JournalProtocol for DisclosureState { fixed: canonical(&( &record.schema, &record.binding_canonical, + &record.authority_canonical_b64, &record.approval_canonical, &record.namespace, &record.operation_id, @@ -346,6 +347,7 @@ impl GatewayAttempts { let base = Record::new( admission.approved.effect().binding(), admission.approved.approval(), + admission.approved.effect().native_authority(), evaluated_at, DisclosureState { plan, diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index e776cf8ae..04d5d7681 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 402 +freeze_version = 403 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 402 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 146 +"auths.identity.protocol" = 147 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 402 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 143 +"auths.product.public-sdk-contract" = 144 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 402 +"auths.release.public-surface" = 403 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index ac1c141a9..b5a60bb4f 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 402, + "freezeVersion": 403, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 146, + "version": 147, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "1f8ccbcba1ec12c46b603bd7f4f48175bb8bde895d67027477ff8e6f6c26545d" + "sha256": "120d8fc30f52f769c2c71a878d205c3f9a4ecf0b89f265076f6d77b89044d21a" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 143, + "version": 144, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "314e69c4e3fe5c9366594d5d7cf9611d35a4d3bc8bd5ec600d28ccf06311f1ea" + "sha256": "77264682cf4831bcf2d5da3fb36bd75f392889329514fd6c94c36eef379e2228" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 402, + "version": 403, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "b0cda095565912e9c5d5d8897ad56aa4808ef9a9a6bfeaaea69a0cf98176eeb8" + "sha256": "e5084b6107ccb8b40f468cbf04cf0652f95225c1678385fec6486427b54f4036" } ] } From 9913d4c702451c19de2b601cd634e397db20f951 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 14:11:54 +0000 Subject: [PATCH 083/136] fix(gateway): preserve native checks across replay and crash recovery Treat only a mismatched offered native proof/action as a history miss so the normal installed verifier still checks its challenge before admission. Keep corrupt, foreign and invalidly signed history fail-closed. Strengthen replay controls with independently approved alternative effects and repair strict lint without relaxing demo assertions, deadlines or security gates. Add sixty native mutation SIGKILL/continuation histories over real HTTP and both maintained stores: Airtable and closed Stripe recipe data, count/sum conservation, acknowledged-grant loss, response persistence, and fresh expiry/revocation/config refusals for retained reservations. Original acquisition crash artifacts remain byte-identical. Refresh workflow/compliance anchors, source closure and freeze404. Integrates the reviewed holistic CI source batch 7ad003e423c6290599dee44842883f8dff210df0. --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-mutation-process-crash-file.json | 548 +++++++++++++ ...ative-mutation-process-crash-postgres.json | 548 +++++++++++++ compliance.toml | 2 + docs/plans/0074-implementation-status.md | 96 ++- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/candidate_runtime.rs | 2 +- product/runtime/auths-gateway/src/engine.rs | 10 +- .../auths-gateway/src/harness/authoring.rs | 19 +- product/runtime/auths-gateway/src/lib.rs | 2 + .../auths-gateway/src/native_crash_tests.rs | 116 ++- .../src/native_information_replay_tests.rs | 9 +- .../src/native_mutation_crash_tests.rs | 764 ++++++++++++++++++ .../src/native_mutation_replay_tests.rs | 83 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 13 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 18 files changed, 2151 insertions(+), 89 deletions(-) create mode 100644 bindings/fixtures/gateway/native-mutation-process-crash-file.json create mode 100644 bindings/fixtures/gateway/native-mutation-process-crash-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_mutation_crash_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index aa865fa04..4959f84ff 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -45,6 +45,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_crash_tests::native_file_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::native_file_mutation_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::postgres_native_mutation_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current diff --git a/bindings/fixtures/gateway/native-mutation-process-crash-file.json b/bindings/fixtures/gateway/native-mutation-process-crash-file.json new file mode 100644 index 000000000..e0a34aedf --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-process-crash-file.json @@ -0,0 +1,548 @@ +{ + "schema": "auths.native-mutation-process-crash/1", + "adapter": "file", + "scope": "full native mutation verification/approval, separate OS workers and custody, maintained Airtable and closed Stripe-plain recipe data, real local HTTP, actual adapter commit boundaries; fixed public keys and maintained clock", + "excluded": [ + "full Stripe guard/prerequisite schedules", + "disclosure schedules", + "mid-upload socket/backpressure faults", + "device/power failure and whole-store rollback", + "live provider qualification and hostile OS/human-presence guarantees" + ], + "cases": [ + { + "recipe": "airtable", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-process-crash-postgres.json b/bindings/fixtures/gateway/native-mutation-process-crash-postgres.json new file mode 100644 index 000000000..bf67d74fe --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-process-crash-postgres.json @@ -0,0 +1,548 @@ +{ + "schema": "auths.native-mutation-process-crash/1", + "adapter": "postgres", + "scope": "full native mutation verification/approval, separate OS workers and custody, maintained Airtable and closed Stripe-plain recipe data, real local HTTP, actual adapter commit boundaries; fixed public keys and maintained clock", + "excluded": [ + "full Stripe guard/prerequisite schedules", + "disclosure schedules", + "mid-upload socket/backpressure faults", + "device/power failure and whole-store rollback", + "live provider qualification and hostile OS/human-presence guarantees" + ], + "cases": [ + { + "recipe": "airtable", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "airtable", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 0, + "native_sum_units": 0, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + }, + { + "recipe": "stripe-plain", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 3fa1dd561..e3fdf01bc 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1806,6 +1806,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_process_tests.rs#postgres_native_process_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_crash_tests.rs#native_file_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_crash_tests.rs#postgres_native_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_crash_tests.rs#native_file_mutation_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_crash_tests.rs#postgres_native_mutation_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#native_file_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 4e1b821ee..1c670ed44 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2323,6 +2323,100 @@ closure regeneration passed after that correction (one artifact-generation test) source still requires exact published-head hosted verification. Final formal evidence on `ab36` does not attest to subsequent replay sources or journal `/16`. +## Native mutation SIGKILL and reserved-continuation checkpoint + +- `native_mutation_crash_tests.rs` exercises the real native mutation engine in + a separate OS worker with independently opened custody and the maintained + file/TLS PostgreSQL stores. A transparent test-only adapter wrapper pauses at + actual before/after reservation, entry and response commit boundaries. A real + local HTTP server pauses after a partial response. The parent sends SIGKILL, + verifies signal 9 and absence of a caller result, then reopens native history. + No native verifier result, decision closure, durable ACK or permit is replaced. +- The matrix includes the maintained Airtable recipe and the closed + `stripe-plain` recipe in the maintained hostile-recipe corpus. Stripe authority + carries native count and sum commitments: one invocation and 500 minor units are + held in slot 0, with no slot 1 allocation, refund or second charge after restart. + Initial admission/slot existence is all-or-none. Every observed write body and + declared idempotency header equals the original native review. The provider + counts all requests and performs no idempotency deduplication. +- Seven interruption points for each recipe and adapter give 28 crash histories. + A committed grant projects Unknown even when the provider received zero writes. + Loss during/before response persistence remains Unknown with the actual request + count retained; a committed response returns its HTTP 200 fact after caller loss. + Only absent or reserved operations with no prior grant may enter after full + fresh native authorization. A second replay changes neither journal/slots nor + the same native execution witness and performs no implicit observation. +- Another 32 histories kill workers after reservation or before entry, then + independently expire approval/resource authority, revoke the native connection + or activate changed native configuration before reopening. All retain Reserved + and the exact original charges/revision; no fresh custody, write or read occurs. + Original proof/action/approval bytes and admission event times are not renewed. +- The test authoring helper now accepts an explicit signed validity interval. + Existing callers retain their original intervals. New Stripe proofs are signed + from `NOW - 10` through `NOW + 3600` (or `NOW + 5` for isolated authority expiry), within the + recipe's declared idempotency retention. The initial long-lived fixture was + correctly refused with `gateway.idempotency.window-exceeds-retention`; no + verifier clock, retention rule, deadline or installed trust was changed to make + the positive control pass. +- Required generator execution passed 4/4, zero ignored, in 12.01 seconds: the two + new adapter matrices plus the two existing acquisition crash generators. The + new matrices contain 60 histories; all fourteen earlier acquisition histories + and their committed artifacts stayed unchanged after sharing the transparent + test pause/process helper. PostgreSQL uses the independent canonical TLS + fixture on port 55451 with CA/server-name verification and synchronous commit. +- Both new ignored PostgreSQL/file cases are explicitly registered in the hosted + workflow and compliance inventory. These are source/artifact-construction + results; exact new-head hosted verification remains required. Full Stripe + guard/prerequisite and disclosure interruption schedules, partial upload and + device/power failure, broad fault/concurrency histories, installed human UI, + differential/performance and the remaining A01–A22 gates remain open. Fixed + public test keys, maintained clock, trusted stores, local HTTP and same-UID + process assumptions are explicit; no live-provider or hostile-host claim follows. + +## Holistic CI repair after retained replay publication + +- The exact published revision `9ae2e2c7` finished with 64 successful checks, + thirteen failures and nineteen skips across all fourteen workflows. Two source + roots caused three failed jobs and ten fail-closed rollups: strict Clippy + diagnostics, and the same substituted-challenge assertion in both installed + Stripe/Airtable demos. Fast Lean feedback passed; required qualified formal + translation/Kani/Lean/evidence were preflight-skipped, not new passes. +- The CI agent's single source batch `7ad003e423c6290599dee44842883f8dff210df0` + is integrated into this combined change. A differing offered native proof or + action is now an advisory history miss, allowing ordinary native verification + to preserve the existing `denied / challenge-mismatch` result. Matching history + still requires both digests and the retained exact approval signature. Corrupt, + unavailable, foreign or invalidly signed retained state remains a hard refusal. + No existing demo assertion, security deadline, tool pin or invariant changed. +- New replay controls are stronger: each changed native proof/action is compiled + and independently exactly approved before the original entry. Live changed + bindings must reach durable operation conflict; current expiry, revocation or + configuration refusal has its explicit expected code. Reusing the original + approval on a different effect still fails before custody, with exact journal, + provider count/body and native execution witness preserved throughout. +- The agent reproduced the actual failing full workspace strict Clippy command + successfully, and passed four retained replay matrices on file/TLS PostgreSQL, + the native header-corruption test and unchanged demo diagnostics: Stripe 23, + Airtable 34 semantic plus 2 crash cases. The demo diagnostic uses existing installed + artifacts and same-UID execution; it is not fresh Docker/SDK/isolation evidence. + Detailed report: `/tmp/ap074-ci-9ae2-report.md`; machine matrix: + `/tmp/ap074-ci-9ae2-evidence.json`. +- Published PostgreSQL job `123481020880` in run `40883517998` actually passed all + sixteen explicit native cases, zero ignored in each, plus thirty existing + gateway PostgreSQL tests. The actual producer revision is PR merge + `d842ec5607c0d0c4fa915a732df78d5720b3aad7`, whose verified tree + `101b09d359ecba54d666b61d92f3b79d886c6ca8` equals the published source tree. + Preserve that producer identity; do not relabel it as literal source head. +- The combined gateway library/tests also passed strict all-feature Clippy in + 12.59 seconds after repairing three new test-style diagnostics with equivalent + patterns/borrowing. No lint allowance was added and every assertion remains. +- The combined source includes the sixty new mutation crash/continuation + histories, so fresh exact-head hosted verification is still required. Release + freeze 404 advances only the reported identity protocol 148, SDK contract 145 and + public surface 404 subjects. Journal schema remains `/16`; canonical effect + identity and existing native fixture bytes remain unchanged. AP074 is not + complete and no acceptance gate is waived by this source repair. + ## Phase gates | Phase | State | Outstanding gate | @@ -2345,7 +2439,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus and native retained-input controls / distinct valid proof/action, damaged approval, changed resource and changed recipient rejected during file/TLS PostgreSQL replay | Complete independent substitutions for every binding dimension and installed surface remain required | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | -| A05 | Crash at every persistence/transport boundary | Partial / daemon-recipient ACK loss plus seven full-native acquisition process points per adapter / fourteen file/TLS PostgreSQL SIGKILL schedules executed, truthful charged history and replay checks | Mutation/disclosure remaining boundaries, full ACK persistence and actual durability faults remain | +| A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file, daemon/recipient process and native file/TLS PostgreSQL history corpora / both peers killed before ACK in the process corpus; native lost-ACK history retained across expiry, revocation, configuration replacement and engine reopen on both stores | Remaining crash/persistence boundaries and complete late-ACK PostgreSQL schedules pending | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 99a1b164d..b08877f1f 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"1d9f5682b93908ae670067a15f53d97369e2510d56eb1f65529833176aa86bdc"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8326f25e92ee4f114620f7fee268f3e3d0a08d01dabc3c40387893c0e1b3e4e2"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"753c0157bb6e0e14e7552db14247b7cfc72c1095f1e28b1b5761422c6a3ff330"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"76882cc523eb8a1e33438d0ec0e3533cfa9fa9675da2f51c1c3661b963c12977"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"902372311a5a72a468be9cd4fedaaaff1ef3faf30c817af978e1e4805c5d70f9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"77702d7841708b772d6cf1344a636e8484a96669cf0b5c4aed7bf30854d4fbb9"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"005be8acd2c6a995eeea538cd03970319e79a87d5519898a5d242ebb309b7f86"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"a1a6181f2d647d5b547b7f6d3873a10f5614851763226b0786d669e5179e0d0a"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a209660efb8a740b432c5b1435014636e030373f6e5eafed04474aed0161fde5"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"83b87911250271617eea04f2929802d1f97010f0112eee287be52ab1f5354f00"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"80def71554fbacf4b930602341c0f398c4af48529c7354119340f698af268079"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/candidate_runtime.rs b/product/runtime/auths-gateway/src/candidate_runtime.rs index c34f101c3..9255f0c30 100644 --- a/product/runtime/auths-gateway/src/candidate_runtime.rs +++ b/product/runtime/auths-gateway/src/candidate_runtime.rs @@ -410,7 +410,7 @@ impl GatewayEngine { .await; let (approved, now) = match current { Ok(current) => current, - Err(result) => return retained.map_or(Err(result), Ok), + Err(result) => return retained.ok_or(result), }; if let Some(snapshot) = self .attempts diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index abc45ddc2..d9859beef 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1542,7 +1542,7 @@ impl GatewayEngine { .await; let (approved, now) = match current { Ok(current) => current, - Err(result) => return retained.map_or(Err(result), Ok), + Err(result) => return retained.ok_or(result), }; if let Some(snapshot) = self .attempts @@ -1704,7 +1704,7 @@ impl GatewayEngine { .await; let (approved, now) = match current { Ok(current) => current, - Err(result) => return retained.map_or(Err(result), Ok), + Err(result) => return retained.ok_or(result), }; self.acquire_read_approved(approved, now, started).await } @@ -1815,7 +1815,7 @@ impl GatewayEngine { .await; let (approved, now) = match current { Ok(current) => current, - Err(result) => return retained.map_or(Err(result), Ok), + Err(result) => return retained.ok_or(result), }; self.acquire_read_approved(approved, now, started).await } @@ -1890,7 +1890,7 @@ impl GatewayEngine { .await; let (approved, now) = match current { Ok(current) => current, - Err(result) => return retained.map_or(Err(result), Ok), + Err(result) => return retained.ok_or(result), }; self.acquire_read_approved(approved, now, started).await } @@ -2119,7 +2119,7 @@ impl GatewayEngine { .retained_submission(proof_cbor, action_cbor, &approval, RetainedRoute::Mutation) .await { - Ok(Some(crate::store::RetainedSubmission::Mutation(snapshot))) => Some(snapshot), + Ok(Some(crate::store::RetainedSubmission::Mutation(snapshot))) => Some(*snapshot), Ok(None) => None, Ok(Some(_)) => return not_entered("gateway.effect.operation-conflict"), Err(result) => return result, diff --git a/product/runtime/auths-gateway/src/harness/authoring.rs b/product/runtime/auths-gateway/src/harness/authoring.rs index ed38e5acb..6b72a7acd 100644 --- a/product/runtime/auths-gateway/src/harness/authoring.rs +++ b/product/runtime/auths-gateway/src/harness/authoring.rs @@ -59,12 +59,25 @@ pub(crate) fn tool_fixture_using_policy( until: u64, policy: Option<&crate::ArgumentCeilingPolicy>, ) -> Result { - let root = Signer::new(0x11); - let actor = Signer::new(0x22); - let observer = Signer::new(0x33); let from = now .checked_sub(86_400) .ok_or(HarnessError::Fixture("time"))?; + tool_fixture_in_window(call, now, from, until, policy) +} + +/// Authors the requested signed validity interval without changing the verifier +/// clock or installed trust. This permits positive controls for recipes whose +/// declared provider idempotency retention requires a shorter action interval. +pub(crate) fn tool_fixture_in_window( + call: &McpToolCall, + now: u64, + from: u64, + until: u64, + policy: Option<&crate::ArgumentCeilingPolicy>, +) -> Result { + let root = Signer::new(0x11); + let actor = Signer::new(0x22); + let observer = Signer::new(0x33); let context = context_for_tool(&root, &observer.principal, now, call)?; let grant = if let Some(policy) = policy { let extension = fixture( diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 2323478ca..57e86f1b3 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -160,6 +160,8 @@ mod native_process_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_crash_tests; +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_mutation_crash_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_dependency_tests; diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs index 7617f9560..64252cd53 100644 --- a/product/runtime/auths-gateway/src/native_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -31,7 +31,7 @@ const OPERATION: &str = "crash-read"; #[derive(Clone, Copy, Debug, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] -enum Point { +pub(super) enum Point { BeforeReservationCommit, AfterReservationCommit, BeforeEntryCommit, @@ -41,7 +41,7 @@ enum Point { AfterResponseCommit, } impl Point { - const ALL: [Self; 7] = [ + pub(super) const ALL: [Self; 7] = [ Self::BeforeReservationCommit, Self::AfterReservationCommit, Self::BeforeEntryCommit, @@ -50,7 +50,7 @@ impl Point { Self::BeforeResponseCommit, Self::AfterResponseCommit, ]; - const fn resumable(self) -> bool { + pub(super) const fn resumable(self) -> bool { matches!( self, Self::BeforeReservationCommit | Self::AfterReservationCommit | Self::BeforeEntryCommit @@ -66,7 +66,7 @@ impl Point { Self::AfterResponseCommit => Some("content-response-recorded"), } } - const fn provider_calls(self) -> usize { + pub(super) const fn provider_calls(self) -> usize { match self { Self::DuringResponse | Self::BeforeResponseCommit | Self::AfterResponseCommit => 1, _ => 0, @@ -82,9 +82,13 @@ impl Point { | ( Self::BeforeResponseCommit, false, - "content-response-recorded" + "content-response-recorded" | "response-recorded" + ) + | ( + Self::AfterResponseCommit, + true, + "content-response-recorded" | "response-recorded" ) - | (Self::AfterResponseCommit, true, "content-response-recorded") ) } } @@ -96,7 +100,7 @@ struct CrashSetup { point: Point, } -fn pause_at(port: u16) { +pub(super) fn pause_at(port: u16) { let mut channel = TcpStream::connect(("127.0.0.1", port)).expect("crash control"); channel .set_read_timeout(Some(Duration::from_secs(20))) @@ -112,7 +116,15 @@ fn pause_at(port: u16) { /// A transparent proxy around the actual adapter. Native closures are never /// replaced or rerun: the adapter invokes them at most once under its fence, /// and receives their bytes unchanged. -struct PausedStore { +#[derive(Clone, Copy)] +pub(super) enum CrashProtocol { + Acquisition, + Mutation, +} + +pub(super) struct PausedStore { + operation: &'static str, + protocol: CrashProtocol, inner: Arc, key: GatewayAttemptKey, point: Point, @@ -120,17 +132,45 @@ struct PausedStore { fired: AtomicBool, } impl PausedStore { + pub(super) fn new( + inner: Arc, + key: GatewayAttemptKey, + operation: &'static str, + protocol: CrashProtocol, + point: Point, + port: u16, + ) -> Self { + Self { + inner, + key, + operation, + protocol, + point, + port, + fired: AtomicBool::new(false), + } + } + fn target(&self, kind: GatewayRecordKind, key: GatewayAttemptKey) -> bool { kind == GatewayRecordKind::Attempt && key == self.key } - fn phase(bytes: &[u8]) -> String { + fn phase(&self, bytes: &[u8]) -> String { + Self::phase_for(self.protocol, self.operation, bytes) + } + pub(super) fn phase_for(protocol: CrashProtocol, operation: &str, bytes: &[u8]) -> String { let value: Value = serde_json::from_slice(bytes).expect("native record"); - assert_eq!(value["operation_id"], OPERATION); - assert_eq!(value["state"]["protocol"], "acquisition"); - value["state"]["facts"]["phase"]["stage"] - .as_str() - .expect("native phase") - .to_owned() + assert_eq!(value["operation_id"], operation); + let stage = match protocol { + CrashProtocol::Acquisition => { + assert_eq!(value["state"]["protocol"], "acquisition"); + &value["state"]["facts"]["phase"]["stage"] + } + CrashProtocol::Mutation => { + assert_eq!(value["state"]["protocol"], "mutation"); + &value["state"]["facts"]["stage"] + } + }; + stage.as_str().expect("native phase").to_owned() } fn pause(&self, after: bool, phase: &str) { if self.point.matches(after, phase) && !self.fired.swap(true, Ordering::SeqCst) { @@ -156,7 +196,7 @@ impl GatewayAttemptStore for PausedStore { .inner .fenced_insert_all(entries, dependencies, &mut |snapshots| { let next = decide(snapshots)?; - let current = Self::phase(&next); + let current = self.phase(&next); self.pause(false, ¤t); phase = Some(current); Ok(next) @@ -180,7 +220,7 @@ impl GatewayAttemptStore for PausedStore { let mut phase = None; let result = self.inner.fenced_replace(keys, &mut |snapshots| { let next = decide(snapshots)?; - let current = Self::phase(&next); + let current = self.phase(&next); self.pause(false, ¤t); phase = Some(current); Ok(next) @@ -200,7 +240,7 @@ impl GatewayAttemptStore for PausedStore { if !self.target(kind, *key) { return self.inner.replace(kind, key, current, next); } - let phase = Self::phase(next); + let phase = self.phase(next); self.pause(false, &phase); let result = self.inner.replace(kind, key, current, next); if result.is_ok() { @@ -249,13 +289,14 @@ fn native_crash_peer() { Backend::parse(&setup.installation.backend), &setup.installation.location, ); - let wrapped = Arc::new(PausedStore { - inner: attached.raw(), - key: operation_key(), - point: setup.point, - port: setup.installation.barrier_port, - fired: AtomicBool::new(false), - }); + let wrapped = Arc::new(PausedStore::new( + attached.raw(), + operation_key(), + OPERATION, + CrashProtocol::Acquisition, + setup.point, + setup.installation.barrier_port, + )); let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) .expect("attempts"); let runtime = runtime(); @@ -267,17 +308,13 @@ fn native_crash_peer() { ); } -struct Peer(Child); +pub(super) struct Peer(Child); impl Peer { - fn start(input: &Path) -> Self { + pub(super) fn start(input: &Path, selector: &str, environment: &str) -> Self { Self( Command::new(std::env::current_exe().expect("test executable")) - .args([ - "--exact", - "native_crash_tests::native_crash_peer", - "--nocapture", - ]) - .env("AUTHS_AP074_CRASH_PEER", input) + .args(["--exact", selector, "--nocapture"]) + .env(environment, input) .stdin(Stdio::null()) .stdout(Stdio::null()) .stderr(Stdio::piped()) @@ -285,7 +322,7 @@ impl Peer { .expect("native child"), ) } - fn await_pause(&mut self, listener: &TcpListener) -> TcpStream { + pub(super) fn await_pause(&mut self, listener: &TcpListener) -> TcpStream { let deadline = Instant::now() + Duration::from_secs(15); loop { if let Some(status) = self.0.try_wait().expect("child status") { @@ -317,7 +354,7 @@ impl Peer { } } } - fn kill(&mut self) { + pub(super) fn kill(&mut self) { self.0.kill().expect("SIGKILL"); assert_eq!(self.0.wait().expect("child exit").signal(), Some(9)); } @@ -391,7 +428,11 @@ impl Case { fn crash(&self) { let input = self.setup.installation.root.join("crash-setup.json"); private(&input, &serde_json::to_vec(&self.setup).expect("setup")); - let mut peer = Peer::start(&input); + let mut peer = Peer::start( + &input, + "native_crash_tests::native_crash_peer", + "AUTHS_AP074_CRASH_PEER", + ); let mut paused = peer.await_pause(&self.listener); assert!( !self @@ -419,7 +460,8 @@ impl Case { .expect("native record") } fn pre_crash_phase(&self, bytes: Option<&[u8]>) { - let phase = bytes.map(PausedStore::phase); + let phase = + bytes.map(|bytes| PausedStore::phase_for(CrashProtocol::Acquisition, OPERATION, bytes)); assert_eq!(phase.as_deref(), self.setup.point.expected_phase()); if let Some(bytes) = bytes { let value: Value = serde_json::from_slice(bytes).expect("native record"); diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index 6c1fb4eb4..34d63d3b9 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -21,7 +21,7 @@ use std::{ path::Path, sync::{Arc, atomic::Ordering}, }; -use tokio::net::UnixStream; +use tokio::{io::AsyncReadExt as _, net::UnixStream}; const SOURCE: &str = "retained-read"; const RELEASE: &str = "retained-release"; @@ -67,7 +67,7 @@ struct Input { approval: ExactEffectApproval, } impl Input { - fn approval(effect: crate::effect::BoundEffect, change: Change) -> ExactEffectApproval { + fn approval(effect: &crate::effect::BoundEffect, change: Change) -> ExactEffectApproval { let until = if matches!(change, Change::ApprovalExpiry) { NOW + 5 } else { @@ -100,7 +100,7 @@ impl Input { Self { proof: signed.proof, action: signed.action, - approval: Self::approval(effect, change), + approval: Self::approval(&effect, change), } } async fn disclosure( @@ -121,7 +121,7 @@ impl Input { Self { proof: signed.proof, action: signed.action, - approval: Self::approval(effect, change), + approval: Self::approval(&effect, change), } } } @@ -369,7 +369,6 @@ async fn replay_release(engine: &GatewayEngine, history: &ReleaseHistory) -> Val .await .expect("retained release"); assert_eq!(&replay, snapshot); - use tokio::io::AsyncReadExt as _; let mut byte = [0]; assert_eq!( client.read(&mut byte).await.expect("closed replay"), diff --git a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs new file mode 100644 index 000000000..d059abebe --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs @@ -0,0 +1,764 @@ +//! Real native mutation SIGKILL schedules with both durable adapters. The +//! provider counts every received write; its idempotency header deduplicates +//! nothing, so a replay cannot hide a second native send behind provider logic. +use crate::effect::ExactEffectApproval; +use crate::harness::authoring::{tool_fixture_in_window, tools_context}; +use crate::native_crash_tests::{CrashProtocol, PausedStore, Peer, Point, pause_at}; +use crate::native_process_tests::{ + EngineControls, NOW, Setup, load_controlled_engine, private, runtime, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + ArgumentCeilingPolicy, CompiledRecipe, GatewayAttemptKey, GatewayAttemptSnapshot, + GatewayAttempts, GatewayEngine, GatewayRecordKind, GatewaySubmitResult, LogicalOperationId, + SharedConnection, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::TcpListener, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + thread::{self, JoinHandle}, + time::Duration, +}; + +const OPERATION: &str = "crash-write"; +const RESPONSE: &[u8] = b"{\"id\":\"public-crash-response\"}"; +const ENVIRONMENT: &str = "AUTHS_AP074_MUTATION_CRASH_PEER"; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Flavor { + Airtable, + StripePlain, +} +impl Flavor { + const fn label(self) -> &'static str { + match self { + Self::Airtable => "airtable", + Self::StripePlain => "stripe-plain", + } + } + fn recipe(self) -> CompiledRecipe { + match self { + Self::Airtable => CompiledRecipe::compile( + include_bytes!("../../../../bindings/fixtures/gateway/airtable/recipe.json"), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), + ) + .expect("maintained Airtable recipe"), + Self::StripePlain => { + let corpus: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" + )) + .expect("maintained recipe corpus"); + let base = &corpus["bases"]["stripe-plain"]; + CompiledRecipe::compile( + &serde_json::to_vec(&base["recipe"]).expect("source"), + &serde_json::to_vec(&base["lock"]).expect("lock"), + ) + .expect("closed Stripe recipe") + } + } + } + fn controls(self) -> EngineControls { + let recipe = self.recipe(); + let call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + serde_json::Map::new(), + ) + .expect("tool"); + let mut controls = EngineControls::baseline(); + controls.trust = Some(tools_context(&[call], NOW).expect("native trust")); + controls.recipe = Some(recipe); + controls + } + fn call(self) -> McpToolCall { + let recipe = self.recipe(); + let mut arguments = json!({"operation_id":OPERATION, "operator_namespace":recipe.namespace().as_str(), "recipe_digest":recipe.digest_hex()}); + match self { + Self::Airtable => { + arguments["record_id"] = json!("recTEST0000000001"); + arguments["replacement"] = json!("Approved"); + } + Self::StripePlain => { + arguments["payment_intent"] = json!("pi_public_crash_fixture"); + arguments["amount"] = json!(500); + } + } + McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + arguments.as_object().expect("arguments").clone(), + ) + .expect("call") + } + fn policy(self) -> Option { + matches!(self, Self::StripePlain).then(|| { + ArgumentCeilingPolicy::new("amount", 500, 3600, 2) + .expect("count policy") + .with_sum(1000, None) + .expect("sum policy") + }) + } + const fn request_line(self) -> &'static str { + match self { + Self::Airtable => { + "PATCH /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1" + } + Self::StripePlain => "POST /v1/refunds HTTP/1.1", + } + } +} + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum ResumeGate { + Current, + ApprovalExpired, + AuthorityExpired, + Revoked, + ConfigurationReplaced, +} +impl ResumeGate { + const fn permits(self) -> bool { + matches!(self, Self::Current) + } + const fn clock(self) -> u64 { + match self { + Self::ApprovalExpired => NOW + 301, + Self::AuthorityExpired => NOW + 6, + _ => NOW, + } + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct CrashSetup { + installation: Setup, + point: Point, + flavor: Flavor, + gate: ResumeGate, +} + +#[derive(Debug, Eq, PartialEq)] +struct Request { + body: Vec, + idempotency: Option, +} +struct Provider { + port: u16, + requests: Arc>>, + stop: Arc, + task: Option>, +} +impl Provider { + fn new(flavor: Flavor, pause: Option) -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); + listener.set_nonblocking(true).expect("poll"); + let port = listener.local_addr().expect("address").port(); + let requests = Arc::new(Mutex::new(Vec::new())); + let captured = requests.clone(); + let stop = Arc::new(AtomicBool::new(false)); + let done = stop.clone(); + let task = thread::spawn(move || { + let mut pause = pause; + while !done.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(pair) => pair, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(2)); + continue; + } + Err(error) => panic!("accept: {error}"), + }; + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut header = Vec::new(); + while !header.ends_with(b"\r\n\r\n") { + assert!(header.len() < 16384); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + header.push(byte[0]); + } + let header = String::from_utf8(header).expect("header UTF8"); + assert_eq!( + header.lines().next(), + Some(flavor.request_line()), + "no implicit reads" + ); + assert!( + header + .to_ascii_lowercase() + .contains("authorization: bearer public-native-process-fixture\r\n") + ); + let value = |name: &str| { + header.lines().find_map(|line| { + let (key, value) = line.split_once(':')?; + key.eq_ignore_ascii_case(name) + .then(|| value.trim().to_owned()) + }) + }; + let length: usize = value("content-length") + .expect("body length") + .parse() + .expect("length"); + assert!(length <= 65536); + let mut body = vec![0; length]; + stream.read_exact(&mut body).expect("body"); + captured.lock().expect("requests").push(Request { + body, + idempotency: value("idempotency-key"), + }); + stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",RESPONSE.len()).as_bytes()).expect("response header"); + if let Some(port) = pause.take() { + stream.write_all(&RESPONSE[..1]).expect("partial response"); + pause_at(port); + let _ = stream.write_all(&RESPONSE[1..]); + } else { + stream.write_all(RESPONSE).expect("response body"); + } + } + }); + Self { + port, + requests, + stop, + task: Some(task), + } + } + fn calls(&self) -> usize { + self.requests.lock().expect("requests").len() + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(task) = self.task.take() { + let result = task.join(); + if !thread::panicking() { + result.expect("provider task"); + } + } + } +} + +fn key(flavor: Flavor) -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + flavor.recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") +} + +async fn submit(engine: &GatewayEngine, root: &Path) -> GatewaySubmitResult { + let proof = std::fs::read(root.join("write.proof")).expect("proof"); + let action = std::fs::read(root.join("write.action")).expect("action"); + let approval = ExactEffectApproval::from_private_bytes( + &std::fs::read(root.join("write.approval")).expect("approval"), + ) + .expect("canonical approval"); + engine.submit(&proof, &action, approval).await +} + +#[test] +fn native_mutation_crash_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: CrashSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("typed setup"); + let attached = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let wrapped = Arc::new(PausedStore::new( + attached.raw(), + key(setup.flavor), + OPERATION, + CrashProtocol::Mutation, + setup.point, + setup.installation.barrier_port, + )); + let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + "mutation-crash-peer", + attempts, + setup.flavor.controls(), + )); + let result = runtime.block_on(submit(&engine, &setup.installation.root)); + private( + &setup.installation.root.join("caller-result.json"), + &serde_json::to_vec(&result).expect("result"), + ); + panic!("native mutation worker completed before scheduled SIGKILL: {result:?}"); +} + +struct Authorization { + request: Request, + counters: Vec, +} +struct Counter { + kind: GatewayRecordKind, + digest: [u8; 32], +} +impl Counter { + fn key(&self, slot: u64) -> GatewayAttemptKey { + GatewayAttemptKey::from_bytes(match self.kind { + GatewayRecordKind::CountSlot => crate::bounds::count_slot_key(&self.digest, slot), + GatewayRecordKind::SumSlot => crate::bounds::sum_slot_key(&self.digest, slot), + _ => panic!("not a native fixed-window counter"), + }) + } +} +async fn authorize(engine: &GatewayEngine, setup: &CrashSetup) -> Authorization { + let signed = tool_fixture_in_window( + &setup.flavor.call(), + NOW, + NOW - 10, + if matches!(setup.gate, ResumeGate::AuthorityExpired) { + NOW + 5 + } else { + NOW + 3600 + }, + setup.flavor.policy().as_ref(), + ) + .expect("native proof"); + let effect = engine + .compile_effect(&signed.proof, &signed.action) + .await + .expect("native effect"); + let request = effect.private_request().expect("mutation"); + let request = Request { + body: request.body().to_vec(), + idempotency: request.idempotency_key().map(str::to_owned), + }; + let binding: Value = + serde_json::from_slice(&effect.binding().to_private_bytes().expect("binding")) + .expect("native binding"); + let counters = binding["reservations"] + .as_array() + .expect("native reservations") + .iter() + .map(|reservation| { + let kind = match reservation["unit"].as_str().expect("unit") { + "mutation-count" => GatewayRecordKind::CountSlot, + "mutation-sum" => GatewayRecordKind::SumSlot, + _ => panic!("wrong protocol reservation"), + }; + Counter { + kind, + digest: serde_json::from_value(reservation["key"].clone()).expect("counter digest"), + } + }) + .collect::>(); + assert_eq!( + counters.len(), + if matches!(setup.flavor, Flavor::StripePlain) { + 2 + } else { + 0 + } + ); + let approval = effect + .approval_request(NOW, NOW + 300) + .expect("exact review"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&approval.signing_message().expect("preimage")) + .to_bytes(); + for (name, bytes) in [ + ("write.proof", signed.proof), + ("write.action", signed.action), + ( + "write.approval", + approval + .with_signature(signature) + .to_private_bytes() + .expect("approval") + .to_vec(), + ), + ] { + private(&setup.installation.root.join(name), &bytes); + } + Authorization { request, counters } +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: CrashSetup, + listener: TcpListener, + provider: Provider, + runtime: tokio::runtime::Runtime, + authorization: Authorization, +} +impl Case { + fn new(backend: Backend, flavor: Flavor, point: Point, gate: ResumeGate) -> Self { + let directory = tempfile::tempdir().expect("private directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let listener = TcpListener::bind("127.0.0.1:0").expect("control"); + listener.set_nonblocking(true).expect("poll"); + let port = listener.local_addr().expect("address").port(); + let provider = Provider::new( + flavor, + matches!(point, Point::DuringResponse).then_some(port), + ); + let setup = CrashSetup { + flavor, + point, + gate, + installation: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: port, + }, + }; + let runtime = runtime(); + let (engine, record) = runtime.block_on(load_controlled_engine( + &setup.installation, + "parent", + store.attempts().clone(), + flavor.controls(), + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + runtime + .block_on(shared.insert(&record)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let authorization = runtime.block_on(authorize(&engine, &setup)); + assert_eq!(provider.calls(), 0); + Self { + _directory: directory, + store, + setup, + listener, + provider, + runtime, + authorization, + } + } + fn raw(&self) -> Option> { + self.store + .raw() + .load(GatewayRecordKind::Attempt, &key(self.setup.flavor)) + .expect("native record") + } + fn crash(&self) { + let input = self + .setup + .installation + .root + .join("mutation-crash-setup.json"); + private(&input, &serde_json::to_vec(&self.setup).expect("setup")); + let mut peer = Peer::start( + &input, + "native_mutation_crash_tests::native_mutation_crash_peer", + ENVIRONMENT, + ); + let mut paused = peer.await_pause(&self.listener); + assert!( + !self + .setup + .installation + .root + .join("caller-result.json") + .exists() + ); + peer.kill(); + if matches!(self.setup.point, Point::DuringResponse) { + paused + .write_all(b"G") + .expect("release provider after SIGKILL"); + } + assert_eq!(self.provider.calls(), self.setup.point.provider_calls()); + } + fn history(&self, attempts: &GatewayAttempts) -> Option { + self.runtime + .block_on(attempts.read( + self.setup.flavor.recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + )) + .expect("history") + } + fn slots(&self, present: bool) -> Vec> { + self.authorization + .counters + .iter() + .filter_map(|counter| { + let raw = self.store.raw(); + let bytes = raw.load(counter.kind, &counter.key(0)).expect("slot"); + assert_eq!( + bytes.is_some(), + present, + "claim and slots commit all-or-none" + ); + assert!( + raw.load(counter.kind, &counter.key(1)) + .expect("no second charge") + .is_none() + ); + bytes.inspect(|bytes| { + let value: Value = serde_json::from_slice(bytes).expect("native slot"); + assert_eq!(value["operation_id"], OPERATION); + assert_eq!(value["slot"], 0); + assert_eq!(value["window_seconds"], 3600); + assert_eq!(value["window_index"], NOW / 3600); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], 500); + assert_eq!(value["cumulative"], 500); + } + }) + }) + .collect() + } + fn before(&self, bytes: Option<&[u8]>) { + let expected = match self.setup.point { + Point::BeforeReservationCommit => None, + Point::AfterReservationCommit | Point::BeforeEntryCommit => Some("reserved"), + Point::AfterEntryCommit | Point::DuringResponse | Point::BeforeResponseCommit => { + Some("entry-granted") + } + Point::AfterResponseCommit => Some("response-recorded"), + }; + let phase = + bytes.map(|bytes| PausedStore::phase_for(CrashProtocol::Mutation, OPERATION, bytes)); + assert_eq!(phase.as_deref(), expected); + assert_eq!( + self.store.raw().attempt_keys(8).expect("keys").len(), + usize::from(bytes.is_some()) + ); + if let Some(snapshot) = self.history(&self.store.reopen()) { + assert_eq!(snapshot.evaluated_at(), NOW); + assert_eq!(snapshot.counters().len(), self.authorization.counters.len()); + assert!(snapshot.counters().iter().all(|counter| counter.slot == 0)); + assert_eq!( + crate::engine::stored_result(&snapshot), + match self.setup.point { + Point::AfterReservationCommit | Point::BeforeEntryCommit => + GatewaySubmitResult::Reserved { + revision: snapshot.revision() + }, + Point::AfterResponseCommit => + GatewaySubmitResult::ResponseRecorded { status: 200 }, + _ => GatewaySubmitResult::Unknown, + } + ); + } else { + assert!(bytes.is_none()); + } + } + fn reopened_engine(&self) -> GatewayEngine { + let mut controls = self.setup.flavor.controls(); + controls.clock.set(self.setup.gate.clock()); + if matches!(self.setup.gate, ResumeGate::ConfigurationReplaced) { + controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + SigningKey::from_bytes(&[30; 32]).verifying_key().to_bytes(), + ) + .expect("replacement policy"); + } + let attempts = GatewayAttempts::new(self.store.reopen().store(), controls.policy.clone()) + .expect("reopened policy"); + let (engine, _) = self.runtime.block_on(load_controlled_engine( + &self.setup.installation, + "reopened", + attempts, + controls, + )); + match self.setup.gate { + ResumeGate::Revoked => { + self.runtime + .block_on(engine.revoke_connection()) + .expect("native revocation"); + } + ResumeGate::ConfigurationReplaced => { + let revision = engine + .effect_configuration_revision() + .expect("configuration review"); + engine + .activate_effect_configuration(revision) + .expect("native configuration CAS"); + } + _ => {} + } + engine + } + fn expected_result(&self, before: Option<&[u8]>) -> GatewaySubmitResult { + if !self.setup.gate.permits() { + assert!(matches!( + self.setup.point, + Point::AfterReservationCommit | Point::BeforeEntryCommit + )); + let record: Value = + serde_json::from_slice(before.expect("prior reservation")).expect("journal"); + assert_eq!(record["state"]["facts"]["stage"], "reserved"); + return GatewaySubmitResult::Reserved { + revision: record["revision"].as_u64().expect("revision"), + }; + } + if self.setup.point.resumable() || matches!(self.setup.point, Point::AfterResponseCommit) { + GatewaySubmitResult::ResponseRecorded { status: 200 } + } else { + GatewaySubmitResult::Unknown + } + } + fn may_continue(&self) -> bool { + self.setup.point.resumable() && self.setup.gate.permits() + } + fn reopen(&self) -> Value { + let before = self.raw(); + self.before(before.as_deref()); + let slots = self.slots(before.is_some()); + let engine = self.reopened_engine(); + let witness = engine.execution_witness(); + let result = self + .runtime + .block_on(submit(&engine, &self.setup.installation.root)); + assert_eq!(result, self.expected_result(before.as_deref())); + let after = self.raw().expect("retained record"); + let after_slots = self.slots(true); + if before.is_some() { + assert_eq!( + slots, after_slots, + "retained charges are neither refunded nor repeated" + ); + } + if self.may_continue() { + let resumed = engine.execution_witness(); + assert_eq!( + resumed.credential_lease_calls - witness.credential_lease_calls, + 1 + ); + assert_eq!( + resumed.write_transport_entries - witness.write_transport_entries, + 1 + ); + assert_eq!( + resumed.read_transport_entries - witness.read_transport_entries, + 0 + ); + } else { + assert_eq!( + engine.execution_witness(), + witness, + "lost grant cannot reacquire custody or send" + ); + assert_eq!(before.as_deref(), Some(after.as_slice())); + } + let witness = engine.execution_witness(); + assert_eq!( + self.runtime + .block_on(submit(&engine, &self.setup.installation.root)), + result + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(self.raw().expect("retained"), after); + assert_eq!(self.slots(true), after_slots); + let calls = if self.may_continue() { + 1 + } else { + self.setup.point.provider_calls() + }; + assert_eq!(self.provider.calls(), calls); + assert!( + self.provider + .requests + .lock() + .expect("requests") + .iter() + .all(|request| request == &self.authorization.request), + "all actual writes match the original native review, including declared idempotency" + ); + let history = self.history(&self.store.reopen()).expect("history"); + assert_eq!(history.counters().len(), self.authorization.counters.len()); + assert_eq!(history.evaluated_at(), NOW); + json!({"recipe":self.setup.flavor.label(), "pause":self.setup.point, "sigkill":true, "resume_gate":self.setup.gate, + "provider_writes_at_kill":self.setup.point.provider_calls(), "native_result_after_reopen":result, + "prior_grant_absent":self.setup.point.resumable(), "continued_after_fresh_authorization":self.may_continue(), "provider_writes_after_replays":calls, + "native_count_slots":usize::from(matches!(self.setup.flavor, Flavor::StripePlain)), + "native_sum_units":if matches!(self.setup.flavor, Flavor::StripePlain) { 500 } else { 0 }, + "same_reviewed_request_and_declared_idempotency":true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged":true}) + } +} + +fn matrix(backend: Backend) { + let mut cases = Vec::new(); + for flavor in [Flavor::Airtable, Flavor::StripePlain] { + for point in Point::ALL { + eprintln!( + "native mutation SIGKILL: {}/{flavor:?}/{point:?}", + backend.label() + ); + let case = Case::new(backend, flavor, point, ResumeGate::Current); + case.crash(); + cases.push(case.reopen()); + } + for point in [Point::AfterReservationCommit, Point::BeforeEntryCommit] { + for gate in [ + ResumeGate::ApprovalExpired, + ResumeGate::AuthorityExpired, + ResumeGate::Revoked, + ResumeGate::ConfigurationReplaced, + ] { + eprintln!( + "native mutation reserved continuation: {}/{flavor:?}/{point:?}/{gate:?}", + backend.label() + ); + let case = Case::new(backend, flavor, point, gate); + case.crash(); + cases.push(case.reopen()); + } + } + } + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-process-crash/1", "adapter":backend.label(), + "scope":"full native mutation verification/approval, separate OS workers and custody, maintained Airtable and closed Stripe-plain recipe data, real local HTTP, actual adapter commit boundaries; fixed public keys and maintained clock", + "excluded":["full Stripe guard/prerequisite schedules", "disclosure schedules", "mid-upload socket/backpressure faults", "device/power failure and whole-store rollback", "live provider qualification and hostile OS/human-presence guarantees"], "cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-mutation-process-crash-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} +#[test] +fn native_file_mutation_process_crash_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_process_crash_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs index f424aa97f..ffb7219bd 100644 --- a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs @@ -9,6 +9,7 @@ use crate::{ GatewaySubmitResult, LogicalOperationId, SharedConnection, }; use auths_profile_mcp::McpToolCall; +use base64ct::{Base64UrlUnpadded, Encoding as _}; use ed25519_dalek::{Signer as _, SigningKey}; use serde_json::{Value, json}; use std::{ @@ -166,7 +167,23 @@ struct Input { action: Vec, approval: crate::effect::ExactEffectApproval, body: Vec, - changed: Vec, + changed: Vec, +} +struct ChangedInput { + signed: crate::harness::authoring::ToolFixture, + approval: crate::effect::ExactEffectApproval, +} +fn approval( + effect: &crate::effect::BoundEffect, + expires: u64, +) -> crate::effect::ExactEffectApproval { + let request = effect + .approval_request(NOW, expires) + .expect("approval request"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + request.with_signature(signature) } impl Input { async fn author(engine: &GatewayEngine, change: Change) -> Self { @@ -200,38 +217,37 @@ impl Input { changed_call, ) .expect("changed call"); - let changed = vec![ + let expires = if matches!(change, Change::ApprovalExpiry) { + NOW + 5 + } else { + NOW + 300 + }; + let alternatives = [ tool_fixture_until(&call, NOW, NOW + 86_399).expect("different valid native proof"), tool_fixture_until(&changed_call, NOW, NOW + 86_400) .expect("different valid native action"), ]; - for alternative in &changed { + let mut changed = Vec::new(); + for alternative in alternatives { let compiled = engine .compile_effect(&alternative.proof, &alternative.action) .await .expect("positive native changed-input control"); assert_ne!(compiled.binding().id(), effect.binding().id()); + changed.push(ChangedInput { + signed: alternative, + approval: approval(&compiled, expires), + }); } let body = effect .private_request() .expect("mutation request") .body() .to_vec(); - let expires = if matches!(change, Change::ApprovalExpiry) { - NOW + 5 - } else { - NOW + 300 - }; - let request = effect - .approval_request(NOW, expires) - .expect("approval request"); - let signature = SigningKey::from_bytes(&[29; 32]) - .sign(&request.signing_message().expect("preimage")) - .to_bytes(); Self { proof: signed.proof, action: signed.action, - approval: request.with_signature(signature), + approval: approval(&effect, expires), body, changed, } @@ -392,6 +408,7 @@ fn reopened_engine( reopened } +#[derive(Clone, Copy)] struct ReplayCheck<'a> { runtime: &'a tokio::runtime::Runtime, engine: &'a GatewayEngine, @@ -421,22 +438,48 @@ fn assert_replay(check: ReplayCheck<'_>) -> Value { let operation = LogicalOperationId::parse(OPERATION).expect("operation"); let witness = engine.execution_witness(); for alternative in &input.changed { - let result = runtime.block_on(engine.submit( - &alternative.proof, - &alternative.action, + // Foreign inputs do not retrieve history. The original approval cannot + // authorize them; their own real approval reaches the durable conflict + // only while current execution authority is still valid. + let stale_approval = runtime.block_on(engine.submit( + &alternative.signed.proof, + &alternative.signed.action, input.approval.clone(), )); + assert_eq!( + stale_approval, + GatewaySubmitResult::NotEntered { + code: if matches!(change, Change::ConnectionRevoked) { + "gateway.connection.unavailable" + } else { + "gateway.effect.approval" + } + .to_owned() + } + ); + let result = runtime.block_on(engine.submit( + &alternative.signed.proof, + &alternative.signed.action, + alternative.approval.clone(), + )); assert_eq!( result, GatewaySubmitResult::NotEntered { - code: "gateway.effect.operation-conflict".to_owned() + code: match change { + // These alternative proofs deliberately remain live even + // when the original source's authority has expired. + Change::None | Change::AuthorityExpiry => "gateway.effect.operation-conflict", + Change::ApprovalExpiry | Change::ConfigurationReplaced => + "gateway.effect.approval", + Change::ConnectionRevoked => "gateway.connection.unavailable", + } + .to_owned() } ); } let mut invalid: Value = serde_json::from_slice(&input.approval.to_private_bytes().expect("approval")) .expect("shape"); - use base64ct::{Base64UrlUnpadded, Encoding as _}; let mut signature = Base64UrlUnpadded::decode_vec(invalid["signature_b64"].as_str().expect("signature")) .expect("base64"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 69bb37a99..8b3125d6e 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "7758b4850998aa8c6da86b7fef12a4176a3c90c9211683fd1f0b122789076932"; + "beea897df3864ec1d793a2918572ffbec2a9e8e437ce63097624001696e32d6e"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 846fcb94a..de5aa5ead 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -3061,7 +3061,7 @@ pub enum ContentHistory { /// Stored facts only. No variant contains an entry permit or current authority. pub(crate) enum RetainedSubmission { - Mutation(GatewayAttemptSnapshot), + Mutation(Box), Acquisition(AcquisitionSnapshot), Disclosure(DisclosureSnapshot), } @@ -3092,17 +3092,22 @@ impl GatewayAttempts { || record.namespace != namespace.as_str() || record.operation_id != operation.as_str() || record.recipe_digest != hex::encode(recipe) - || !record.native_authority()?.matches_inputs(proof, action) { return Err(GatewayAttemptError::BindingConflict); } + // A different offered input is not a historical match. It must still + // pass current native verification before admission can report a + // changed-binding conflict; the lookup hint itself grants no authority. + if !record.native_authority()?.matches_inputs(proof, action) { + return Ok(None); + } binding .validate_historical_approval(approval) .map_err(|_| GatewayAttemptError::BindingConflict)?; match &record.state { - ProtocolState::Mutation(_) => Ok(Some(RetainedSubmission::Mutation( + ProtocolState::Mutation(_) => Ok(Some(RetainedSubmission::Mutation(Box::new( record.map_state(MutationState::extract)?.snapshot(true)?, - ))), + )))), ProtocolState::Acquisition(_) => Ok(Some(RetainedSubmission::Acquisition( record .map_state(acquisition::AcquisitionState::extract)? diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 04d5d7681..4790fdc98 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 403 +freeze_version = 404 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 403 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 147 +"auths.identity.protocol" = 148 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 403 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 144 +"auths.product.public-sdk-contract" = 145 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 403 +"auths.release.public-surface" = 404 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index b5a60bb4f..b39e40a11 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 403, + "freezeVersion": 404, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 147, + "version": 148, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "120d8fc30f52f769c2c71a878d205c3f9a4ecf0b89f265076f6d77b89044d21a" + "sha256": "5a9bc25de4b7273faa232d4dc84167ceed54a472bd89871235ec4c8d5e2cd3a7" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 144, + "version": 145, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "77264682cf4831bcf2d5da3fb36bd75f392889329514fd6c94c36eef379e2228" + "sha256": "6f1da74d98c1a7ef124eea91880b59901a614d551f68a3702d4d1230978165e6" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 403, + "version": 404, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "e5084b6107ccb8b40f468cbf04cf0652f95225c1678385fec6486427b54f4036" + "sha256": "328e0693e8cb8133916f31ffd003601e90197ae1b15b6481763e93f05fd2edce" } ] } From a81943a7b9bdd50ec85bbcfa943905d6d2a534e1 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 15:07:06 +0000 Subject: [PATCH 084/136] test(gateway): exercise disclosure crashes and late acknowledgements Add fifty-six real gateway/recipient process histories over file and TLS PostgreSQL, including partial native sends, reservation and grant loss, ACK persistence and expiry/revocation/configuration controls. Reject three hundred signed or signature-tampered ACK substitutions while preserving source bytes, allocations and fixed-window charges. Keep normal binaries free of the test-only I/O selector; refresh explicit workflow/compliance anchors and source freeze405. --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-disclosure-process-crash-file.json | 1210 +++++++++++++++++ ...ive-disclosure-process-crash-postgres.json | 1210 +++++++++++++++++ compliance.toml | 2 + docs/plans/0074-implementation-status.md | 68 +- .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/disclosure_transport.rs | 31 + product/runtime/auths-gateway/src/lib.rs | 2 + .../auths-gateway/src/native_crash_tests.rs | 22 +- .../src/native_disclosure_crash_testkit.rs | 392 ++++++ .../src/native_disclosure_crash_tests.rs | 774 +++++++++++ .../src/native_mutation_crash_tests.rs | 5 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 15 files changed, 3724 insertions(+), 20 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-process-crash-file.json create mode 100644 bindings/fixtures/gateway/native-disclosure-process-crash-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs create mode 100644 product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 4959f84ff..ead9cdb70 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -47,6 +47,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::native_file_mutation_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::postgres_native_mutation_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::native_file_disclosure_process_crash_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_native_disclosure_process_crash_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current diff --git a/bindings/fixtures/gateway/native-disclosure-process-crash-file.json b/bindings/fixtures/gateway/native-disclosure-process-crash-file.json new file mode 100644 index 000000000..c439da00c --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-process-crash-file.json @@ -0,0 +1,1210 @@ +{ + "schema": "auths.native-disclosure-process-crash/1", + "adapter": "file", + "scope": "full native read/release authorities and exact approvals; real HTTP source and separate gateway/recipient OS processes with native authenticated Unix protocol; test-only pause after actual native content prefix write; fixed public keys, maintained clock, same UID and trusted stores", + "excluded": [ + "distinct UID/hostile OS isolation", + "power loss and whole-store rollback", + "live-provider qualification and human presence", + "all remaining fault/concurrency/differential/performance gates" + ], + "cases": [ + { + "pause": "before-reservation-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-entry-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "during-delivery", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-disclosure-process-crash-postgres.json b/bindings/fixtures/gateway/native-disclosure-process-crash-postgres.json new file mode 100644 index 000000000..cc2309427 --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-process-crash-postgres.json @@ -0,0 +1,1210 @@ +{ + "schema": "auths.native-disclosure-process-crash/1", + "adapter": "postgres", + "scope": "full native read/release authorities and exact approvals; real HTTP source and separate gateway/recipient OS processes with native authenticated Unix protocol; test-only pause after actual native content prefix write; fixed public keys, maintained clock, same UID and trusted stores", + "excluded": [ + "distinct UID/hostile OS isolation", + "power loss and whole-store rollback", + "live-provider qualification and human presence", + "all remaining fault/concurrency/differential/performance gates" + ], + "cases": [ + { + "pause": "before-reservation-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": true, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-entry-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "during-delivery", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "current", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "approval-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "authority-expired", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "revoked", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-reservation-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-entry-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": false, + "code": "gateway.disclosure.read" + }, + "after_reopen": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": null, + "substituted_ack_fields_and_signature_refused": 0, + "final_history": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-delivery-before-ack", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": true, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "before-ack-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + }, + { + "pause": "after-ack-commit", + "current_gate": "configuration-replaced", + "sigkill_gateway": true, + "sigkill_recipient": false, + "original_recipient": { + "received_full": true, + "bytes": 21 + }, + "after_reopen": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "continued_only_after_fresh_authorization": false, + "late_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "substituted_ack_fields_and_signature_refused": 10, + "final_history": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "provider_reads": 1, + "source_allocation_calls": 1, + "source_allocation_bytes": 1024, + "disclosure_allocation_calls": 1, + "disclosure_allocation_bytes": 21, + "native_policy_count_slots": 1, + "native_policy_sum_bytes": 21, + "original_inputs_and_source_journal_unchanged": true, + "replays_do_not_authenticate_or_redeliver": true, + "late_ack_and_exact_ack_replay_preserve_charges": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index e3fdf01bc..9e2f45392 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1808,6 +1808,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_crash_tests.rs#postgres_native_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_crash_tests.rs#native_file_mutation_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_crash_tests.rs#postgres_native_mutation_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs#native_file_disclosure_process_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs#postgres_native_disclosure_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#native_file_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 1c670ed44..af1a53b06 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2417,6 +2417,70 @@ closure regeneration passed after that correction (one artifact-generation test) identity and existing native fixture bytes remain unchanged. AP074 is not complete and no acceptance gate is waived by this source repair. +## Native disclosure/ACK process crash checkpoint + +- `native_disclosure_crash_tests.rs` and its private testkit run separate native + gateway/recipient OS processes over real authenticated Unix sockets. The source + is acquired by the real native engine through local HTTP and retained privately. + Release uses an independent native proof, exact approval, recipient key/channel + and native fixed-window count/byte commitments. No verifier result, entry + decision, durable acknowledgement, live channel or permit is substituted. +- Each adapter has 28 histories: eight reservation/entry/partial-delivery/receipt/ + ACK-commit interruptions, plus twenty expiry/revocation/configuration controls + around reserved continuation and genuine late ACKs. The gateway is SIGKILLed at + every selected point. Five histories per adapter also SIGKILL the recipient + after full native receipt but before ACK transmission; its exact private ACK + was retained before death. Native receipt returns no partial plaintext/ACK when + the gateway dies after a content prefix. +- The partial-send selector is compiled only into the native unit-test executable + with loopback/testkit features. It pauses after an actual native prefix write, + preserving frame bytes, deadlines and the real consumed permit. Ordinary + binaries, including installed testkit binaries, have no selector/branch. The + shared test adapter observer has a distinct ACK phase; response and ACK facts + remain typed separately in the sole shipping journal/reducer. +- Durable grants reopen as Unknown with no new challenge or plaintext. An absent + or reserved operation continues only with current native authority and approval + through the original writer fence and a new real recipient handshake. Expired + approval, expired resource authority, native revocation and changed native + configuration retain the original reservation/revision without authenticating + another recipient, fetching a provider response or recharging capacity. +- Both source and release lifetime allocations, native fixed-window count/sum + slot 0 rows and absence of slot 1 are checked. A source acquisition remains one + invocation/1024 response bytes; disclosure holds one delivery/full projected + byte amount even on partial/unknown delivery. Original signed bytes, source + journal and charge rows remain byte-identical throughout replay and late ACK. + Exact repeated ACKs preserve the journal revision. Current expiry/revocation/ + configuration cannot erase a valid assertion for a previously granted delivery. +- Thirty histories actually submit genuine late ACKs (including exact replay of + already committed ACKs). Before the positive ACK, each exercises ten native + historical API substitutions: effect, source, protected content, channel, + instance, projection, byte limit, acknowledged length, an independently signed + different recipient, and damaged signature. All 300 negative controls leave + history and charges unchanged. A valid recipient signature without any durable + grant also cannot manufacture ACK history. Public snapshots contain no content. +- Required construction passed 6/6, zero ignored, in 33.33 seconds, covering all + 130 existing/new acquisition, mutation and disclosure process histories over + real file/TLS PostgreSQL. The two new matrices contain 56 histories. All older + acquisition/mutation crash artifacts stayed byte-identical after sharing the + observer. Combined strict all-feature gateway library/test Clippy passed in + 11.47 seconds; only equivalent future boxing/reference fixes were needed, with + no new lint allowances or weakened assertions. +- Both new cases are explicitly registered in the PostgreSQL workflow and + compliance inventory. These local source/artifact results do not close all + A05/A06/A08/A09 gates: actual remaining I/O-error/ambiguous-ACK-commit races, + guarded-provider/prerequisite, concurrent native histories, independent + differential, installed authenticated human UI, retention/rollback and + performance/formal integration evidence remain required. Fixed public keys, + maintained clock, same UID, trusted host/stores and local provider are explicit; + no live-provider, distinct-UID isolation or human-presence claim follows. + +- Source identities are regenerated under freeze 405 (only generator-reported + protocol 149, SDK 146 and public surface 405 subjects advanced). Journal schema + remains `/16`; no normal transport, grant, ACK, clock or provider-retry contract + changes. Publication is deliberately held while the actual authoritative Lean + job `123512213089` and final evidence for published `9913d4c7` remain live; do not + cancel that work merely to publish another test fixture batch. + ## Phase gates | Phase | State | Outstanding gate | @@ -2442,8 +2506,8 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / socket-file, daemon/recipient process and native file/TLS PostgreSQL history corpora / both peers killed before ACK in the process corpus; native lost-ACK history retained across expiry, revocation, configuration replacement and engine reopen on both stores | Remaining crash/persistence boundaries and complete late-ACK PostgreSQL schedules pending | -| A09 | ACK substitution in every dimension | Partial / native signed ACK corpus / exact dimension and re-signed substitutions executed | Live Unix handshake now exercised; independent-process and complete delivery integration pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient and full native file/TLS PostgreSQL crash corpora / fifty-six release histories include partial sends, both peers killed before ACK, caller loss after ACK commit, current-authority gates, late and repeated ACKs with conserved allocations/slots | Remaining I/O-error/ambiguous-commit races and full installed boundary evidence pending | +| A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate plus full native acquisition worker/operator histories / sixteen file/TLS PostgreSQL histories executed | Complete mutation/disclosure races remain required | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index b08877f1f..839383ce4 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"b948c52c728b5636bdb051a55b8132cd7b53af4752942bc08e9b3464e4d3d0d8"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"a209660efb8a740b432c5b1435014636e030373f6e5eafed04474aed0161fde5"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"83b87911250271617eea04f2929802d1f97010f0112eee287be52ab1f5354f00"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"80def71554fbacf4b930602341c0f398c4af48529c7354119340f698af268079"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b2337a0b2d9ec4b00a123dd222eaa1f151130f0452adc90614f82eb93a7e4e3e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"8783cb42b051211ae26ec7186cff2106c2d001d6b53b8c2eba203fde056cad7f"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/disclosure_transport.rs b/product/runtime/auths-gateway/src/disclosure_transport.rs index c43ff234e..e296a2e98 100644 --- a/product/runtime/auths-gateway/src/disclosure_transport.rs +++ b/product/runtime/auths-gateway/src/disclosure_transport.rs @@ -18,6 +18,20 @@ const MAX_CONTENT_BYTES: usize = 65_536; const AUTH_SECONDS: u64 = 5; const SESSION_SECONDS: u64 = 15; +// Only the native test executable can arm this transparent I/O pause. The +// normal binary, including installed testkit builds, has no selector or branch. +#[cfg(all(test, feature = "loopback-provider", feature = "testkit-harness"))] +static DELIVERY_PREFIX_PAUSE: std::sync::atomic::AtomicU16 = std::sync::atomic::AtomicU16::new(0); + +#[cfg(all(test, feature = "loopback-provider", feature = "testkit-harness"))] +pub(crate) fn arm_delivery_prefix_pause(port: u16) { + assert_ne!(port, 0); + assert_eq!( + DELIVERY_PREFIX_PAUSE.swap(port, std::sync::atomic::Ordering::SeqCst), + 0 + ); +} + impl UnixDisclosurePolicy { fn server_peer(&self, stream: &UnixStream) -> Result<(), &'static str> { Self::peer(stream, self.gateway_uid(), self.recipient_uid()) @@ -298,6 +312,23 @@ async fn write_frame( .write_u32(u32::try_from(bytes.len()).map_err(|_| "gateway.disclosure.frame")?) .await .map_err(|_| "gateway.disclosure.write")?; + #[cfg(all(test, feature = "loopback-provider", feature = "testkit-harness"))] + if maximum == MAX_CONTENT_BYTES && !bytes.is_empty() { + let port = DELIVERY_PREFIX_PAUSE.swap(0, std::sync::atomic::Ordering::SeqCst); + if port != 0 { + stream + .write_all(&bytes[..1]) + .await + .map_err(|_| "gateway.disclosure.write")?; + tokio::task::spawn_blocking(move || crate::native_crash_tests::pause_at(port)) + .await + .map_err(|_| "gateway.disclosure.write")?; + return stream + .write_all(&bytes[1..]) + .await + .map_err(|_| "gateway.disclosure.write"); + } + } stream .write_all(bytes) .await diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 57e86f1b3..0693e3381 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -161,6 +161,8 @@ mod native_process_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_crash_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_disclosure_crash_tests; +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_mutation_crash_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs index 64252cd53..b02a39c02 100644 --- a/product/runtime/auths-gateway/src/native_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -39,6 +39,8 @@ pub(super) enum Point { DuringResponse, BeforeResponseCommit, AfterResponseCommit, + BeforeAcknowledgementCommit, + AfterAcknowledgementCommit, } impl Point { pub(super) const ALL: [Self; 7] = [ @@ -64,6 +66,9 @@ impl Point { Some("entry-granted") } Self::AfterResponseCommit => Some("content-response-recorded"), + Self::BeforeAcknowledgementCommit | Self::AfterAcknowledgementCommit => { + panic!("ACK points require disclosure fixture") + } } } pub(super) const fn provider_calls(self) -> usize { @@ -89,6 +94,8 @@ impl Point { true, "content-response-recorded" | "response-recorded" ) + | (Self::BeforeAcknowledgementCommit, false, "acknowledged") + | (Self::AfterAcknowledgementCommit, true, "acknowledged") ) } } @@ -120,6 +127,7 @@ pub(super) fn pause_at(port: u16) { pub(super) enum CrashProtocol { Acquisition, Mutation, + Disclosure, } pub(super) struct PausedStore { @@ -127,7 +135,7 @@ pub(super) struct PausedStore { protocol: CrashProtocol, inner: Arc, key: GatewayAttemptKey, - point: Point, + point: Option, port: u16, fired: AtomicBool, } @@ -137,7 +145,7 @@ impl PausedStore { key: GatewayAttemptKey, operation: &'static str, protocol: CrashProtocol, - point: Point, + point: Option, port: u16, ) -> Self { Self { @@ -169,11 +177,17 @@ impl PausedStore { assert_eq!(value["state"]["protocol"], "mutation"); &value["state"]["facts"]["stage"] } + CrashProtocol::Disclosure => { + assert_eq!(value["state"]["protocol"], "disclosure"); + &value["state"]["facts"]["phase"]["stage"] + } }; stage.as_str().expect("native phase").to_owned() } fn pause(&self, after: bool, phase: &str) { - if self.point.matches(after, phase) && !self.fired.swap(true, Ordering::SeqCst) { + if self.point.is_some_and(|point| point.matches(after, phase)) + && !self.fired.swap(true, Ordering::SeqCst) + { pause_at(self.port); } } @@ -294,7 +308,7 @@ fn native_crash_peer() { operation_key(), OPERATION, CrashProtocol::Acquisition, - setup.point, + Some(setup.point), setup.installation.barrier_port, )); let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs new file mode 100644 index 000000000..18fc88599 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs @@ -0,0 +1,392 @@ +//! Private setup and real process roles for the native disclosure crash corpus. +use super::{Gate, Point, RELEASE, SOURCE}; +use crate::disclosure_transport::{DisclosureConnection, receive_disclosure}; +use crate::effect::{ + CONTENT_READ_TOOL, DISCLOSURE_TOOL, DisclosureTarget, EffectBinding, ExactEffectApproval, + UnixDisclosurePolicy, +}; +use crate::harness::authoring::{tool_fixture_in_window, tools_context}; +use crate::native_crash_tests::{CrashProtocol, PausedStore, pause_at}; +use crate::native_process_tests::{ + CONTENT, EngineControls, NOW, Setup, load_controlled_engine, private, recipe, runtime, +}; +use crate::store_testkit::{Backend, TestAttempts}; +use crate::{ + ArgumentCeilingPolicy, GatewayAttemptKey, GatewayAttempts, GatewayEngine, LogicalOperationId, +}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde::{Deserialize, Serialize}; +use serde_json::json; +use std::{ + io::Read as _, + os::unix::process::ExitStatusExt as _, + path::Path, + process::{Child, Command, Stdio}, + sync::Arc, + thread, + time::{Duration, Instant}, +}; +use tokio::net::{UnixListener, UnixStream}; + +pub(super) const ENVIRONMENT: &str = "AUTHS_AP074_DISCLOSURE_CRASH_PEER"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +pub(super) enum Role { + Gateway, + Recipient, + ResumeRecipient, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub(super) struct CrashSetup { + pub(super) installation: Setup, + pub(super) point: Point, + pub(super) gate: Gate, + pub(super) channel: UnixDisclosurePolicy, + pub(super) role: Role, +} + +pub(super) fn controls(gate: Gate) -> EngineControls { + let recipe = recipe(); + let calls = [CONTENT_READ_TOOL, DISCLOSURE_TOOL].map(|name| { + McpToolCall::new(recipe.review().service(), name, serde_json::Map::new()).expect("tool") + }); + let mut controls = EngineControls::baseline(); + controls.trust = Some(tools_context(&calls, NOW).expect("native installed trust")); + controls.clock.set(gate.clock()); + if matches!(gate, Gate::ConfigurationReplaced) { + controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 1, + SigningKey::from_bytes(&[30; 32]).verifying_key().to_bytes(), + ) + .expect("replacement policy"); + } + controls +} + +pub(super) fn key(operation: &str) -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key") +} + +pub(super) struct Input { + pub(super) proof: Vec, + pub(super) action: Vec, + pub(super) approval: ExactEffectApproval, +} +impl Input { + pub(super) fn read(root: &Path) -> Self { + Self { + proof: std::fs::read(root.join("release.proof")).expect("proof"), + action: std::fs::read(root.join("release.action")).expect("action"), + approval: ExactEffectApproval::from_private_bytes( + &std::fs::read(root.join("release.approval")).expect("approval"), + ) + .expect("approval data"), + } + } + fn approve(effect: &crate::effect::BoundEffect, until: u64) -> ExactEffectApproval { + let request = effect.approval_request(NOW, until).expect("native review"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + request.with_signature(signature) + } +} + +pub(super) async fn target(engine: &GatewayEngine, setup: &CrashSetup) -> DisclosureTarget { + engine + .disclosure_target( + SOURCE, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + setup.channel.commitment().expect("channel"), + [52; 32], + ) + .await + .expect("retained source") +} + +pub(super) async fn authorize_source(engine: &GatewayEngine) -> EffectBinding { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, SOURCE) + .await + .expect("source call"); + let signed = tool_fixture_in_window(&call, NOW, NOW - 10, NOW + 3600, None) + .expect("native source authority"); + let effect = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("native source effect"); + let approval = Input::approve(&effect, NOW + 300); + let binding = effect.binding().clone(); + let snapshot = engine + .acquire_content_action(&signed.proof, &signed.action, approval) + .await + .expect("actual source acquisition"); + assert_eq!(snapshot.stage, crate::AcquisitionStage::ResponseRecorded); + assert_eq!( + (snapshot.reserved_calls, snapshot.reserved_bytes), + (1, 1024) + ); + binding +} + +pub(super) async fn authorize_release(engine: &GatewayEngine, setup: &CrashSetup) -> EffectBinding { + let target = target(engine, setup).await; + let call = target + .authorization_call( + &recipe(), + &LogicalOperationId::parse(RELEASE).expect("operation"), + ) + .expect("independent release call"); + let policy = + ArgumentCeilingPolicy::new("maximum_disclosure_bytes", CONTENT.len() as u64, 3600, 2) + .expect("native disclosure count") + .with_sum(CONTENT.len() as u64 * 2, None) + .expect("native disclosure bytes"); + let until = if matches!(setup.gate, Gate::AuthorityExpired) { + NOW + 5 + } else { + NOW + 3600 + }; + let signed = tool_fixture_in_window(&call, NOW, NOW - 10, until, Some(&policy)) + .expect("independent native release proof"); + let effect = engine + .compile_disclosure_effect(&target, &signed.proof, &signed.action) + .await + .expect("native release effect"); + let until = if matches!(setup.gate, Gate::ApprovalExpired) { + NOW + 5 + } else { + NOW + 300 + }; + let approval = Input::approve(&effect, until); + for (name, bytes) in [ + ("release.proof", signed.proof), + ("release.action", signed.action), + ( + "release.approval", + approval + .to_private_bytes() + .expect("approval bytes") + .to_vec(), + ), + ( + "release.binding", + effect + .binding() + .to_private_bytes() + .expect("private recipient expectation") + .to_vec(), + ), + ] { + private(&setup.installation.root.join(name), &bytes); + } + effect.binding().clone() +} + +pub(super) async fn gateway(setup: &CrashSetup) { + let attached = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let wrapped = Arc::new(PausedStore::new( + attached.raw(), + key(RELEASE), + RELEASE, + CrashProtocol::Disclosure, + setup.point.store_pause(), + setup.installation.barrier_port, + )); + let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let (engine, _) = load_controlled_engine( + &setup.installation, + "disclosure-crash-gateway", + attempts, + controls(Gate::Current), + ) + .await; + let listener = + UnixListener::bind(setup.installation.root.join("release.sock")).expect("recipient socket"); + private(&setup.installation.root.join("gateway-ready"), b"ready"); + let (stream, _) = listener.accept().await.expect("recipient"); + if matches!(setup.point, Point::DuringDelivery) { + crate::disclosure_transport::arm_delivery_prefix_pause(setup.installation.barrier_port); + } + let input = Input::read(&setup.installation.root); + let target = target(&engine, setup).await; + let result = engine + .disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(stream, setup.channel.clone()), + ) + .await; + private( + &setup.installation.root.join("caller-result.json"), + &serde_json::to_vec(&result).expect("result"), + ); + let recipient = + std::fs::read_to_string(setup.installation.root.join("recipient-result.json")).ok(); + panic!("gateway completed before the selected SIGKILL: {result:?}; recipient {recipient:?}"); +} + +pub(super) async fn recipient(setup: &CrashSetup, resume: bool) { + let root = &setup.installation.root; + let socket = root.join(if resume { + "resume.sock" + } else { + "release.sock" + }); + let start = Instant::now(); + let stream = loop { + match UnixStream::connect(&socket).await { + Ok(stream) => break stream, + Err(error) if start.elapsed() < Duration::from_secs(10) => { + assert!(matches!( + error.kind(), + std::io::ErrorKind::NotFound | std::io::ErrorKind::ConnectionRefused + )); + tokio::time::sleep(Duration::from_millis(2)).await; + } + Err(error) => panic!("recipient connection: {error}"), + } + }; + let binding = EffectBinding::from_private_bytes( + &std::fs::read(root.join("release.binding")).expect("reviewed binding"), + ) + .expect("binding"); + let key = SigningKey::from_bytes(&[47; 32]); + let received = receive_disclosure( + DisclosureConnection::new(stream, setup.channel.clone()), + &binding, + CONTENT.len() as u64, + &key, + ) + .await; + let prefix = if resume { + "resumed-recipient" + } else { + "recipient" + }; + let received = match received { + Ok(received) => received, + Err(code) => { + private( + &root.join(format!("{prefix}-result.json")), + &serde_json::to_vec(&json!({"received_full":false,"code":code})).expect("result"), + ); + return; + } + }; + assert_eq!(received.content(), CONTENT); + let ack = received + .acknowledgement(&key) + .expect("actual native received ACK"); + private( + &root.join(format!("{prefix}.ack")), + &ack.to_private_bytes().expect("private ACK"), + ); + private( + &root.join(format!("{prefix}-result.json")), + &serde_json::to_vec(&json!({"received_full":true,"bytes":CONTENT.len()})).expect("result"), + ); + if !resume && matches!(setup.point, Point::AfterDeliveryBeforeAck) { + let port = setup.installation.barrier_port; + tokio::task::spawn_blocking(move || pause_at(port)) + .await + .expect("controlled recipient pause"); + } + received.acknowledge(&key).await.expect("native ACK send"); +} + +pub(super) struct Recipient(Child); +impl Recipient { + pub(super) fn start(setup: &CrashSetup, resume: bool) -> Self { + let path = setup.installation.root.join(if resume { + "resume-recipient-setup.json" + } else { + "recipient-setup.json" + }); + let role = if resume { + Role::ResumeRecipient + } else { + Role::Recipient + }; + let value = json!({"installation":setup.installation,"point":setup.point,"gate":setup.gate,"channel":setup.channel,"role":role}); + private(&path, &serde_json::to_vec(&value).expect("setup")); + Self( + Command::new(std::env::current_exe().expect("native executable")) + .args([ + "--exact", + "native_disclosure_crash_tests::native_disclosure_crash_peer", + "--nocapture", + ]) + .env(ENVIRONMENT, path) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("native recipient process"), + ) + } + pub(super) fn finish(&mut self, killed: bool) { + if killed { + self.0.kill().expect("recipient SIGKILL"); + assert_eq!(self.0.wait().expect("recipient exit").signal(), Some(9)); + return; + } + let start = Instant::now(); + loop { + if let Some(status) = self.0.try_wait().expect("recipient status") { + let mut diagnostic = String::new(); + self.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "recipient: {status}: {diagnostic}"); + return; + } + assert!( + start.elapsed() < Duration::from_secs(12), + "recipient shutdown" + ); + thread::sleep(Duration::from_millis(2)); + } + } +} +impl Drop for Recipient { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } +} + +pub(super) fn peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: CrashSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("typed setup"); + let runtime = runtime(); + runtime.block_on(async { + match setup.role { + Role::Gateway => Box::pin(gateway(&setup)).await, + Role::Recipient => recipient(&setup, false).await, + Role::ResumeRecipient => recipient(&setup, true).await, + } + }); +} diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs new file mode 100644 index 000000000..2e75ed5ea --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs @@ -0,0 +1,774 @@ +//! Native gateway/recipient SIGKILL histories with real authenticated local +//! delivery, original signed inputs and late ACKs over both maintained stores. +use crate::disclosure_transport::DisclosureConnection; +use crate::effect::{ + DisclosureAcknowledgement, DisclosureAcknowledgementRequest, DisclosureTarget, EffectBinding, + UnixDisclosurePolicy, +}; +use crate::native_crash_tests::{CrashProtocol, PausedStore, Peer, Point as StorePoint}; +use crate::native_process_tests::{ + CONTENT, NOW, Provider, Setup, load_controlled_engine, private, runtime, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + ContentHistory, DisclosureSnapshot, DisclosureStage, GatewayAttemptKey, GatewayAttempts, + GatewayEngine, GatewayRecordKind, SharedConnection, +}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use ed25519_dalek::{Signer as _, SigningKey}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + collections::BTreeMap, + net::TcpListener, + os::unix::fs::{MetadataExt as _, PermissionsExt as _}, + path::Path, + sync::atomic::Ordering, +}; +use tokio::{ + io::AsyncReadExt as _, + net::{UnixListener, UnixStream}, +}; + +#[path = "native_disclosure_crash_testkit.rs"] +mod kit; +use kit::{CrashSetup, Input, Recipient, Role, controls, key}; + +const SOURCE: &str = "crash-release-source"; +const RELEASE: &str = "crash-release"; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Point { + BeforeReservationCommit, + AfterReservationCommit, + BeforeEntryCommit, + AfterEntryCommit, + DuringDelivery, + AfterDeliveryBeforeAck, + BeforeAckCommit, + AfterAckCommit, +} +impl Point { + const ALL: [Self; 8] = [ + Self::BeforeReservationCommit, + Self::AfterReservationCommit, + Self::BeforeEntryCommit, + Self::AfterEntryCommit, + Self::DuringDelivery, + Self::AfterDeliveryBeforeAck, + Self::BeforeAckCommit, + Self::AfterAckCommit, + ]; + const fn store_pause(self) -> Option { + match self { + Self::BeforeReservationCommit => Some(StorePoint::BeforeReservationCommit), + Self::AfterReservationCommit => Some(StorePoint::AfterReservationCommit), + Self::BeforeEntryCommit => Some(StorePoint::BeforeEntryCommit), + Self::AfterEntryCommit => Some(StorePoint::AfterEntryCommit), + Self::BeforeAckCommit => Some(StorePoint::BeforeAcknowledgementCommit), + Self::AfterAckCommit => Some(StorePoint::AfterAcknowledgementCommit), + Self::DuringDelivery | Self::AfterDeliveryBeforeAck => None, + } + } + const fn resumable(self) -> bool { + matches!( + self, + Self::BeforeReservationCommit | Self::AfterReservationCommit | Self::BeforeEntryCommit + ) + } + const fn received_full(self) -> bool { + matches!( + self, + Self::AfterDeliveryBeforeAck | Self::BeforeAckCommit | Self::AfterAckCommit + ) + } + const fn raw_phase(self) -> Option<&'static str> { + match self { + Self::BeforeReservationCommit => None, + Self::AfterReservationCommit | Self::BeforeEntryCommit => Some("reserved"), + Self::AfterAckCommit => Some("acknowledged"), + _ => Some("entry-granted"), + } + } +} + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Gate { + Current, + ApprovalExpired, + AuthorityExpired, + Revoked, + ConfigurationReplaced, +} +impl Gate { + const CHANGES: [Self; 4] = [ + Self::ApprovalExpired, + Self::AuthorityExpired, + Self::Revoked, + Self::ConfigurationReplaced, + ]; + const fn current(self) -> bool { + matches!(self, Self::Current) + } + const fn clock(self) -> u64 { + if matches!(self, Self::ApprovalExpired | Self::AuthorityExpired) { + NOW + 6 + } else { + NOW + } + } +} + +#[test] +fn native_disclosure_crash_peer() { + kit::peer(); +} + +struct Charges { + lifetime: [u8; 32], + fixed: Vec<(GatewayRecordKind, [u8; 32])>, + bytes: u64, + operation: &'static str, +} +impl Charges { + fn native( + binding: &EffectBinding, + operation: &'static str, + count: &str, + sum: &str, + bytes: u64, + ) -> Self { + let wire: Value = serde_json::from_slice(&binding.to_private_bytes().expect("binding")) + .expect("native binding"); + let reservations = wire["reservations"].as_array().expect("reservations"); + let mut lifetime = None; + let mut fixed = Vec::new(); + for reservation in reservations { + let unit = reservation["unit"].as_str().expect("unit"); + if reservation["window"]["kind"] == "source-lifetime" && unit == count { + assert!(lifetime.is_none()); + lifetime = + Some(serde_json::from_value(reservation["key"].clone()).expect("count digest")); + } else if reservation["window"]["kind"] == "fixed" { + let kind = if unit == count { + GatewayRecordKind::CountSlot + } else { + assert_eq!(unit, sum); + GatewayRecordKind::SumSlot + }; + fixed.push(( + kind, + serde_json::from_value(reservation["key"].clone()).expect("counter digest"), + )); + } + } + Self { + lifetime: lifetime.expect("native source count"), + fixed, + bytes, + operation, + } + } + fn records(&self, store: &TestAttempts, present: bool) -> BTreeMap> { + let raw = store.raw(); + let mut keys = vec![( + GatewayRecordKind::EffectAllocation, + GatewayAttemptKey::from_bytes(crate::bounds::count_slot_key(&self.lifetime, 0)), + )]; + assert!( + raw.load( + GatewayRecordKind::EffectAllocation, + &GatewayAttemptKey::from_bytes(crate::bounds::count_slot_key(&self.lifetime, 1)) + ) + .expect("no duplicate allocation") + .is_none() + ); + for (kind, digest) in &self.fixed { + let derive = if *kind == GatewayRecordKind::CountSlot { + crate::bounds::count_slot_key + } else { + crate::bounds::sum_slot_key + }; + keys.push((*kind, GatewayAttemptKey::from_bytes(derive(digest, 0)))); + assert!( + raw.load(*kind, &GatewayAttemptKey::from_bytes(derive(digest, 1))) + .expect("no duplicate counter") + .is_none() + ); + } + keys.into_iter() + .filter_map(|(kind, row)| { + let bytes = raw.load(kind, &row).expect("charge row"); + assert_eq!( + bytes.is_some(), + present, + "attempt and all charges commit together" + ); + bytes.map(|bytes| { + let value: Value = serde_json::from_slice(&bytes).expect("charge"); + assert_eq!(value["slot"], 0); + if kind == GatewayRecordKind::EffectAllocation { + assert_eq!(value["calls"], 1); + assert_eq!(value["bytes"], self.bytes); + } else { + assert_eq!(value["operation_id"], self.operation); + assert_eq!(value["window_seconds"], 3600); + assert_eq!(value["window_index"], NOW / 3600); + if kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], self.bytes); + assert_eq!(value["cumulative"], self.bytes); + } + } + (hex::encode(row.as_bytes()), bytes) + }) + }) + .collect() + } +} + +struct Case { + _directory: tempfile::TempDir, + setup: CrashSetup, + store: TestAttempts, + provider: Provider, + listener: TcpListener, + runtime: tokio::runtime::Runtime, + source: Vec, + source_charges: Charges, + release_charges: Charges, + binding: EffectBinding, + signed_inputs: [Vec; 3], +} +impl Case { + fn new(backend: Backend, point: Point, gate: Gate) -> Self { + let directory = tempfile::tempdir().expect("private directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let uid = std::fs::metadata(&root).expect("UID").uid(); + let store = TestAttempts::open(backend); + let provider = Provider::controlled(None); + let listener = TcpListener::bind("127.0.0.1:0").expect("control"); + listener.set_nonblocking(true).expect("poll"); + let setup = CrashSetup { + point, + gate, + role: Role::Gateway, + channel: UnixDisclosurePolicy::new(uid, uid, [51; 32]), + installation: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: listener.local_addr().expect("port").port(), + }, + }; + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup.installation, + "source-parent", + store.attempts().clone(), + controls(Gate::Current), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let source_binding = runtime.block_on(kit::authorize_source(&engine)); + let binding = runtime.block_on(kit::authorize_release(&engine, &setup)); + let source = store + .raw() + .load(GatewayRecordKind::Attempt, &key(SOURCE)) + .expect("source") + .expect("source"); + let source_charges = Charges::native( + &source_binding, + SOURCE, + "acquisition-count", + "response-bytes", + 1024, + ); + let release_charges = Charges::native( + &binding, + RELEASE, + "disclosure-count", + "disclosure-bytes", + CONTENT.len() as u64, + ); + assert_eq!(release_charges.fixed.len(), 2); + let signed_inputs = ["release.proof", "release.action", "release.approval"].map(|name| { + std::fs::read(setup.installation.root.join(name)).expect("original signed input") + }); + assert_eq!(provider.calls.load(Ordering::SeqCst), 1); + Self { + _directory: directory, + setup, + store, + provider, + listener, + runtime, + source, + source_charges, + release_charges, + binding, + signed_inputs, + } + } + fn raw(&self) -> Option> { + self.store + .raw() + .load(GatewayRecordKind::Attempt, &key(RELEASE)) + .expect("release record") + } + fn crash(&self) -> Value { + let path = self + .setup + .installation + .root + .join("gateway-crash-setup.json"); + private(&path, &serde_json::to_vec(&self.setup).expect("setup")); + let mut gateway = Peer::start( + &path, + "native_disclosure_crash_tests::native_disclosure_crash_peer", + kit::ENVIRONMENT, + ); + let mut recipient = Recipient::start(&self.setup, false); + let _paused = gateway.await_pause(&self.listener); + assert!( + !self + .setup + .installation + .root + .join("caller-result.json") + .exists() + ); + gateway.kill(); + recipient.finish(matches!(self.setup.point, Point::AfterDeliveryBeforeAck)); + let result: Value = serde_json::from_slice( + &std::fs::read(self.setup.installation.root.join("recipient-result.json")) + .expect("recipient outcome"), + ) + .expect("result"); + assert_eq!(result["received_full"], self.setup.point.received_full()); + assert_eq!( + self.setup.installation.root.join("recipient.ack").exists(), + self.setup.point.received_full() + ); + result + } + fn snapshot(&self, engine: &GatewayEngine) -> Option { + let result = self.runtime.block_on(engine.content_history(RELEASE)); + if self.raw().is_none() { + assert!(result.is_err()); + return None; + } + let ContentHistory::Disclosure(snapshot) = result.expect("retained release") else { + panic!("wrong protocol") + }; + assert_eq!( + (snapshot.reserved_deliveries, snapshot.reserved_bytes), + (1, CONTENT.len() as u64) + ); + assert_eq!( + ( + snapshot.policy_count_counters, + snapshot.policy_byte_counters + ), + (1, 1) + ); + Some(snapshot) + } + fn reopen_engine(&self) -> GatewayEngine { + let controls = controls(self.setup.gate); + let attempts = GatewayAttempts::new(self.store.reopen().store(), controls.policy.clone()) + .expect("policy"); + let (engine, _) = self.runtime.block_on(load_controlled_engine( + &self.setup.installation, + "reopened", + attempts, + controls, + )); + match self.setup.gate { + Gate::Revoked => { + self.runtime + .block_on(engine.revoke_connection()) + .expect("native revocation"); + } + Gate::ConfigurationReplaced => { + let revision = engine.effect_configuration_revision().expect("review"); + engine + .activate_effect_configuration(revision) + .expect("native activation"); + } + _ => {} + } + engine + } + fn replay( + &self, + engine: &GatewayEngine, + target: &DisclosureTarget, + input: &Input, + ) -> DisclosureSnapshot { + self.runtime.block_on(async { + let (server, mut client) = UnixStream::pair().expect("replay connection"); + let result = engine + .disclose( + target, + &input.proof, + &input.action, + input.approval.clone(), + DisclosureConnection::new(server, self.setup.channel.clone()), + ) + .await + .expect("native retained projection"); + let mut byte = [0]; + assert_eq!( + client + .read(&mut byte) + .await + .expect("closed history channel"), + 0, + "history must send neither authentication challenge nor plaintext" + ); + result + }) + } + fn resume( + &self, + engine: &GatewayEngine, + target: &DisclosureTarget, + input: &Input, + ) -> DisclosureSnapshot { + self.runtime.block_on(async { + let listener = UnixListener::bind(self.setup.installation.root.join("resume.sock")) + .expect("resume channel"); + let mut recipient = Recipient::start(&self.setup, true); + let (server, _) = listener.accept().await.expect("real resumed recipient"); + let result = engine + .disclose( + target, + &input.proof, + &input.action, + input.approval.clone(), + DisclosureConnection::new(server, self.setup.channel.clone()), + ) + .await + .expect("fresh native continuation"); + tokio::task::spawn_blocking(move || recipient.finish(false)) + .await + .expect("recipient task"); + result + }) + } + fn assert_source(&self, charges: &BTreeMap>) { + assert_eq!( + self.store + .raw() + .load(GatewayRecordKind::Attempt, &key(SOURCE)) + .expect("source") + .as_deref(), + Some(self.source.as_slice()) + ); + assert_eq!(&self.source_charges.records(&self.store, true), charges); + assert_eq!( + self.provider.calls.load(Ordering::SeqCst), + 1, + "no implicit source refetch" + ); + for (name, expected) in ["release.proof", "release.action", "release.approval"] + .iter() + .zip(&self.signed_inputs) + { + assert_eq!( + &std::fs::read(self.setup.installation.root.join(name)).expect("signed input"), + expected + ); + } + } + fn before(&self, bytes: Option<&[u8]>, snapshot: Option<&DisclosureSnapshot>) { + let phase = + bytes.map(|bytes| PausedStore::phase_for(CrashProtocol::Disclosure, RELEASE, bytes)); + assert_eq!(phase.as_deref(), self.setup.point.raw_phase()); + assert_eq!( + self.store.raw().attempt_keys(8).expect("keys").len(), + 1 + usize::from(bytes.is_some()) + ); + if let Some(snapshot) = snapshot { + assert_eq!( + snapshot.stage, + match self.setup.point { + Point::AfterReservationCommit | Point::BeforeEntryCommit => + DisclosureStage::Reserved, + Point::AfterAckCommit => DisclosureStage::Acknowledged, + _ => DisclosureStage::Unknown, + } + ); + } else { + assert!(matches!(self.setup.point, Point::BeforeReservationCommit)); + } + } + fn unauthorized_ack(&self, engine: &GatewayEngine) { + let request = DisclosureAcknowledgementRequest::for_delivery( + &self.binding, + CONTENT.len() as u64, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + ) + .expect("hypothetical assertion"); + let signature = SigningKey::from_bytes(&[47; 32]) + .sign(&request.signing_message().expect("message")) + .to_bytes(); + assert!( + self.runtime + .block_on( + engine.acknowledge_disclosure(RELEASE, &request.with_signature(signature)) + ) + .is_err(), + "a signature without a durable grant cannot manufacture delivery history" + ); + } + fn substituted_acks(&self, engine: &GatewayEngine, ack: &DisclosureAcknowledgement) -> usize { + let original: Value = + serde_json::from_slice(&ack.to_private_bytes().expect("original ACK")) + .expect("ACK data"); + let mut statements = Vec::new(); + let signer = SigningKey::from_bytes(&[47; 32]); + for name in [ + "effect", + "source_effect", + "protected_content", + "channel", + "delivery_instance", + "projection", + ] { + let mut changed = original["request"].clone(); + changed[name][0] = json!(changed[name][0].as_u64().expect("digest byte") ^ 1); + statements.push((changed, signer.clone())); + } + for (name, value) in [ + ("maximum_bytes", CONTENT.len() + 1), + ("acknowledged_bytes", CONTENT.len() - 1), + ] { + let mut changed = original["request"].clone(); + changed[name] = json!(value); + statements.push((changed, signer.clone())); + } + let other = SigningKey::from_bytes(&[48; 32]); + let principal = auths_raw_key::RawKeyDescriptor::new( + auths_raw_key::RawKeyType::Ed25519, + other.verifying_key().to_bytes().to_vec(), + ) + .expect("descriptor") + .principal() + .expect("recipient"); + let mut changed = original["request"].clone(); + changed["recipient_key"] = json!(other.verifying_key().to_bytes()); + changed["recipient"] = json!(principal.as_str()); + statements.push((changed, other)); + let mut altered = statements + .into_iter() + .map(|(value, key)| { + let request = DisclosureAcknowledgementRequest::from_private_bytes( + &serde_json_canonicalizer::to_vec(&value).expect("canonical statement"), + ) + .expect("well-shaped independent statement"); + let signature = key + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + request.with_signature(signature) + }) + .collect::>(); + let mut damaged = original; + let mut signature = + Base64UrlUnpadded::decode_vec(damaged["signature_b64"].as_str().expect("signature")) + .expect("base64"); + signature[0] ^= 1; + damaged["signature_b64"] = json!(Base64UrlUnpadded::encode_string(&signature)); + altered.push( + DisclosureAcknowledgement::from_private_bytes( + &serde_json_canonicalizer::to_vec(&damaged).expect("canonical ACK"), + ) + .expect("signature bytes are data"), + ); + let count = altered.len(); + assert_eq!(count, 10); + let before = self.raw(); + let charges = self.release_charges.records(&self.store, true); + for changed in altered { + assert!( + self.runtime + .block_on(engine.acknowledge_disclosure(RELEASE, &changed)) + .is_err(), + "a substituted assertion cannot refine an actual retained grant" + ); + assert_eq!(self.raw(), before); + assert_eq!(self.release_charges.records(&self.store, true), charges); + } + count + } + fn late_ack( + &self, + engine: &GatewayEngine, + before: &DisclosureSnapshot, + ) -> (DisclosureSnapshot, usize) { + let ack = DisclosureAcknowledgement::from_private_bytes( + &std::fs::read(self.setup.installation.root.join("recipient.ack")) + .expect("actual received ACK retained before crash"), + ) + .expect("canonical ACK"); + ack.verify(&self.binding, CONTENT.len() as u64) + .expect("positive original recipient assertion"); + let substitutions = self.substituted_acks(engine, &ack); + let result = self + .runtime + .block_on(engine.acknowledge_disclosure(RELEASE, &ack)) + .expect("late exact ACK despite current gate"); + assert_eq!(result.stage, DisclosureStage::Acknowledged); + assert_eq!( + result.revision, + before.revision + u64::from(before.stage != DisclosureStage::Acknowledged) + ); + let bytes = self.raw(); + assert_eq!( + self.runtime + .block_on(engine.acknowledge_disclosure(RELEASE, &ack)) + .expect("exact ACK replay"), + result + ); + assert_eq!( + self.raw(), + bytes, + "exact repeated ACK does not change revision or journal" + ); + (result, substitutions) + } + fn reopen(&self, recipient: &Value) -> Value { + let before = self.raw(); + let source_charges = self.source_charges.records(&self.store, true); + let release_charges = self.release_charges.records(&self.store, before.is_some()); + let engine = self.reopen_engine(); + let snapshot = self.snapshot(&engine); + self.before(before.as_deref(), snapshot.as_ref()); + let target = self.runtime.block_on(kit::target(&engine, &self.setup)); + let input = Input::read(&self.setup.installation.root); + let witness = engine.execution_witness(); + if self.setup.point.resumable() { + self.unauthorized_ack(&engine); + assert_eq!(self.raw(), before); + } + let continued = self.setup.point.resumable() && self.setup.gate.current(); + let result = if continued { + self.resume(&engine, &target, &input) + } else { + self.replay(&engine, &target, &input) + }; + assert_eq!( + engine.execution_witness(), + witness, + "neither recipient delivery nor history needs provider custody/refetch" + ); + assert_eq!( + result.stage, + if continued { + DisclosureStage::Acknowledged + } else { + snapshot.as_ref().expect("retained reservation/grant").stage + } + ); + if !continued { + assert_eq!( + self.raw(), + before, + "reopening does not change retained facts" + ); + assert_eq!(Some(&result), snapshot.as_ref()); + } + let after = self.raw(); + let after_charges = self.release_charges.records(&self.store, true); + if before.is_some() { + assert_eq!(after_charges, release_charges); + } + assert_eq!(self.replay(&engine, &target, &input), result); + assert_eq!(self.raw(), after); + self.assert_source(&source_charges); + let (late, substitutions) = if self.setup.point.received_full() { + let (snapshot, count) = self.late_ack(&engine, &result); + (Some(snapshot), count) + } else { + (None, 0) + }; + assert_eq!( + self.release_charges.records(&self.store, true), + after_charges + ); + self.assert_source(&source_charges); + assert_eq!(engine.execution_witness(), witness); + let final_snapshot = self.snapshot(&engine).expect("history"); + let final_bytes = self.raw(); + assert_eq!(self.replay(&engine, &target, &input), final_snapshot); + assert_eq!(self.raw(), final_bytes); + json!({"pause":self.setup.point, "current_gate":self.setup.gate, "sigkill_gateway":true, + "sigkill_recipient":matches!(self.setup.point, Point::AfterDeliveryBeforeAck), "original_recipient":recipient, + "after_reopen":result, "continued_only_after_fresh_authorization":continued, "late_ack":late, "substituted_ack_fields_and_signature_refused":substitutions, + "final_history":final_snapshot, "provider_reads":1, "source_allocation_calls":1,"source_allocation_bytes":1024, + "disclosure_allocation_calls":1,"disclosure_allocation_bytes":CONTENT.len(),"native_policy_count_slots":1,"native_policy_sum_bytes":CONTENT.len(), + "original_inputs_and_source_journal_unchanged":true,"replays_do_not_authenticate_or_redeliver":true, + "late_ack_and_exact_ack_replay_preserve_charges":true}) + } +} + +fn matrix(backend: Backend) { + let mut cases = Vec::new(); + for point in Point::ALL { + eprintln!("native disclosure SIGKILL: {}/{point:?}", backend.label()); + let case = Case::new(backend, point, Gate::Current); + let receipt = case.crash(); + cases.push(case.reopen(&receipt)); + } + for gate in Gate::CHANGES { + for point in [ + Point::AfterReservationCommit, + Point::BeforeEntryCommit, + Point::AfterDeliveryBeforeAck, + Point::BeforeAckCommit, + Point::AfterAckCommit, + ] { + eprintln!( + "native disclosure SIGKILL and current gate: {}/{point:?}/{gate:?}", + backend.label() + ); + let case = Case::new(backend, point, gate); + let receipt = case.crash(); + cases.push(case.reopen(&receipt)); + } + } + let bytes = serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-process-crash/1","adapter":backend.label(), + "scope":"full native read/release authorities and exact approvals; real HTTP source and separate gateway/recipient OS processes with native authenticated Unix protocol; test-only pause after actual native content prefix write; fixed public keys, maintained clock, same UID and trusted stores", + "excluded":["distinct UID/hostile OS isolation", "power loss and whole-store rollback", "live-provider qualification and human presence", "all remaining fault/concurrency/differential/performance gates"], "cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-disclosure-process-crash-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} +#[test] +fn native_file_disclosure_process_crash_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_disclosure_process_crash_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs index d059abebe..9ecba1209 100644 --- a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs @@ -292,7 +292,7 @@ fn native_mutation_crash_peer() { key(setup.flavor), OPERATION, CrashProtocol::Mutation, - setup.point, + Some(setup.point), setup.installation.barrier_port, )); let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) @@ -547,6 +547,9 @@ impl Case { Some("entry-granted") } Point::AfterResponseCommit => Some("response-recorded"), + Point::BeforeAcknowledgementCommit | Point::AfterAcknowledgementCommit => { + panic!("ACK points are not mutation crash schedules") + } }; let phase = bytes.map(|bytes| PausedStore::phase_for(CrashProtocol::Mutation, OPERATION, bytes)); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 8b3125d6e..1af886e7a 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "beea897df3864ec1d793a2918572ffbec2a9e8e437ce63097624001696e32d6e"; + "0edb6b61543b3cc6119e18e17ee7dee21048de9957a990f4d4d556ef60ca6d6d"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 4790fdc98..6bdbb04db 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 404 +freeze_version = 405 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 404 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 148 +"auths.identity.protocol" = 149 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 404 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 145 +"auths.product.public-sdk-contract" = 146 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 404 +"auths.release.public-surface" = 405 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index b39e40a11..8aa9d4088 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 404, + "freezeVersion": 405, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 148, + "version": 149, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "5a9bc25de4b7273faa232d4dc84167ceed54a472bd89871235ec4c8d5e2cd3a7" + "sha256": "5cbd4e106caab2804145ecc9e908bb17691306def9fdf58b910c81fa5c29018a" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 145, + "version": 146, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "6f1da74d98c1a7ef124eea91880b59901a614d551f68a3702d4d1230978165e6" + "sha256": "8c7fb65eeecf35b9b4dfc28b06abb856b7fa8953b0bb036a2c62a8a4a70fe6ca" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 404, + "version": 405, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "328e0693e8cb8133916f31ffd003601e90197ae1b15b6481763e93f05fd2edce" + "sha256": "22363da70034870154c3e81ca8fe5bf4ded61af1dd9ff304e8d378b26384a8c1" } ] } From ce9d6cf551af226d1a13d28f2de027ae5b81cbab Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 15:13:46 +0000 Subject: [PATCH 085/136] docs(gateway): retain qualified AP074 hosted evidence --- docs/plans/0074-hosted-evidence-9913d4c7.md | 108 ++++++++++++++++++++ docs/plans/0074-implementation-status.md | 25 ++++- 2 files changed, 130 insertions(+), 3 deletions(-) create mode 100644 docs/plans/0074-hosted-evidence-9913d4c7.md diff --git a/docs/plans/0074-hosted-evidence-9913d4c7.md b/docs/plans/0074-hosted-evidence-9913d4c7.md new file mode 100644 index 000000000..96b6d4e12 --- /dev/null +++ b/docs/plans/0074-hosted-evidence-9913d4c7.md @@ -0,0 +1,108 @@ +# AP074 hosted evidence: 9913d4c7 + +Observed terminal state: 29 October 2026, 15:07 UTC. +[PR #213](https://github.com/auths-dev/auths-proof/pull/213) source revision: +`9913d4c702451c19de2b601cd634e397db20f951`. + +All 96 check records finished: **88 success, eight conditional skips, zero +failures**. All fourteen workflows finished: thirteen success, one conditional +skip. This revision is CI-qualified. This is evidence for this published source +only, not for subsequent disclosure tests or complete AP074 acceptance. + +## Workflow results + +| Workflow | Run | Result | +| --- | --- | --- | +| CI | [40889129833](https://github.com/auths-dev/auths-proof/actions/runs/40889129833) | Success, including CI-qualified | +| PostgreSQL lifecycle | [40889129739](https://github.com/auths-dev/auths-proof/actions/runs/40889129739) | Success; all 18 explicit native cases executed | +| Python SDK | [40889129804](https://github.com/auths-dev/auths-proof/actions/runs/40889129804) | Success; wheel producers, installed consumers and gateway harnesses | +| TypeScript SDK | [40889129810](https://github.com/auths-dev/auths-proof/actions/runs/40889129810) | Success; packed Node/Chromium and gateway harnesses | +| SDK outcome recipes | [40889129755](https://github.com/auths-dev/auths-proof/actions/runs/40889129755) | Success; installed examples, scaffold and recipes | +| Gateway operator package | [40889129870](https://github.com/auths-dev/auths-proof/actions/runs/40889129870) | Success; source-free extraction/simulation | +| Recipe qualification | [40889129736](https://github.com/auths-dev/auths-proof/actions/runs/40889129736) | Success for simulation/candidate/offline paths; conditional live/release jobs skipped | +| Gateway isolation | [40889129561](https://github.com/auths-dev/auths-proof/actions/runs/40889129561) | Success with distinct UIDs | +| Airtable Docker demo | [40889129895](https://github.com/auths-dev/auths-proof/actions/runs/40889129895) | 36 cases passed; production qualification false | +| Stripe Docker demo | [40889130083](https://github.com/auths-dev/auths-proof/actions/runs/40889130083) | 23 cases passed; production qualification false | +| Google installed images | [40889129830](https://github.com/auths-dev/auths-proof/actions/runs/40889129830) | Success for independent application-owned reference | +| Git signing protocol | [40889129499](https://github.com/auths-dev/auths-proof/actions/runs/40889129499) | Success | +| Git signing branch protection | [40889129611](https://github.com/auths-dev/auths-proof/actions/runs/40889129611) | Success | +| Gateway custody live | [40889129882](https://github.com/auths-dev/auths-proof/actions/runs/40889129882) | Conditional skip; no qualification evidence | + +The eight skipped jobs concern the production credential-store journey, Stripe +test-mode journey, custody store contract, independent first qualification +signer, independent finite commissioning reviewer, retained production operator, +complete cleaned-release signing and gateway release verification. No skipped +job is counted as a pass or live-provider/human-review evidence. + +## Formal and implementation results + +- [Authoritative implementation](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123506132526) + and its rollup passed. Its repeated configurations report 3,008 passed, + zero failed and 97 ignored across 609 result suites; these are not unique-test + counts. Feature-gated native cases executed separately below. +- [Compliance](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123506132619), + dependency/secrets checks and all three live-reference implementations + (OpenTofu, PostgreSQL and records API) and their rollups passed. +- [Kani](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123506132424) + passed with 49 actual successful verification results. +- [Authoritative Lean](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123512213089) + completed a clean 3,270-job build, 329 compiled statements and transitive-axiom + audit, four reviewed external links with zero compiled external axioms, four + Rust refinement tests and the 49-harness inventory. Fast Lean is separate + feedback and is not substituted for this result. +- [Final formal evidence](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123528105291) + passed with translation, clean Lean and Kani (artifact `12907997775`). The + formal-translation rollup and + [CI-qualified](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123533062348) + also passed. + +### Translation provenance + +[Pinned translation](https://github.com/auths-dev/auths-proof/actions/runs/40889129833/job/123506132456) +passed by validated same-PR reuse, not a fresh translation. Artifact +`12905565623` records current head `9913d4c7`, run `40889129833`, attempt 1, +`execution=reused-pr-run`, reproduction count 2, and reuse from run +`40867724155`, attempt 1, source head +`ab36e4b76420a37912d00b2c5b1fac1ad6c556c5`. + +The source closure is +`a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825`. +The translation phase closure is +`a5a98c9c76bde8f03021fd572008961e2c425d11a8eb9ba2080b270b4a65c519`. +The toolchain closure is +`baff1cabbf9c83ffca0f4bdb1b8dda685a5ac59638e95d6d12e57f5d5bda9633`. +The evidence closure is +`cbc4400d316703bd0a0af4136f65c580047835a03144353343d051214233269f`. + +## Native durable execution and producer identity + +[PostgreSQL job](https://github.com/auths-dev/auths-proof/actions/runs/40889129739/job/123500802885) +ran all eighteen explicit cases with one pass and zero ignored each: CLI content +capacity; file/PostgreSQL process capacity, acquisition crash, mutation crash, +dependency ordering and fixed-window budgets; file I/O failures; PostgreSQL +partial-batch rollback and COMMIT reply loss; file/PostgreSQL mutation and +information retained replay. Mutation crash cases took 1.98 seconds on file and +10.16 seconds on PostgreSQL. Thirty existing gateway PostgreSQL cases, lifecycle +and operator-plane tests also passed. + +Physical/WAL restore retained before-target and excluded after-target state. +`replay_continuity_claim=false` remains explicit: a restored database does not +establish its own freshness. + +The actual Linux wheel/PostgreSQL producer checkout was PR merge commit +`16eb79e57fde2b82fca5550c8e2b4c5596a79046`, with verified tree +`b8913649cbe69cbe2b4aac8339f5c9fedf708a77`, identical to the published source +tree. Preserve that producer identity; it is not literally the source commit. +Demo producers separately checked out the source head. + +Both installed Docker demos passed the original substituted-challenge assertion +unchanged. Neither claims production qualification. Google remains the +independent AP070 reference and receives no managed-native guarantee here. + +## Limits + +No CI repair or rerun was needed for this revision. Its final formal run finished +before the next publication. Later commits require fresh exact-head hosted +checks. The [implementation ledger](0074-implementation-status.md) remains +authoritative for the open AP074 acceptance gates; this report closes no +unexecuted human UI, differential, concurrency, retention or performance claim. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index af1a53b06..465fe857b 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2477,9 +2477,28 @@ closure regeneration passed after that correction (one artifact-generation test) - Source identities are regenerated under freeze 405 (only generator-reported protocol 149, SDK 146 and public surface 405 subjects advanced). Journal schema remains `/16`; no normal transport, grant, ACK, clock or provider-retry contract - changes. Publication is deliberately held while the actual authoritative Lean - job `123512213089` and final evidence for published `9913d4c7` remain live; do not - cancel that work merely to publish another test fixture batch. + changes. Publication was held until the actual authoritative Lean job + `123512213089` and final evidence for published `9913d4c7` finished; no live + formal run was cancelled to publish another test fixture batch. + +## Published 9913d4c7 hosted verification checkpoint + +- Source `9913d4c702451c19de2b601cd634e397db20f951` is CI-qualified: all 96 + checks finished, with 88 successful, eight conditional skips and zero failures. + All fourteen workflows are terminal: thirteen successful and custody-live + conditionally skipped. No repair or rerun was needed for this revision. +- Authoritative clean Lean, 329-statement audit, four Rust refinement checks, + 49 Kani harnesses, final formal evidence and CI-qualified passed. Pinned + translation used validated same-PR evidence reuse from `ab36e4b7`; it was not + freshly translated. All eighteen explicit native PostgreSQL workflow cases + actually ran with zero ignored; installed packages, demos and isolation passed. +- The [durable hosted evidence report](0074-hosted-evidence-9913d4c7.md) records + every workflow, exact jobs, reused translation provenance and the actual PR + merge producer identity with a verified identical source tree. Conditional + skips do not establish live-provider, production or human-review qualification. +- This closes the CI blocker for `9913d4c7` only. The following disclosure test + commit `a81943a7` and later revisions still need exact-head hosted checks. Full + AP074 acceptance remains open; the separate reference AP070 is not migrated. ## Phase gates From 0e20c5f8675a21a4b0f65e8f349152385e31f8b6 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 15:24:21 +0000 Subject: [PATCH 086/136] test(gateway): pin threshold evidence after writer-fence waits --- .../gateway/native-dependency-order-file.json | 165 ++++++++++- .../native-dependency-order-postgres.json | 165 ++++++++++- docs/plans/0074-implementation-status.md | 41 ++- ...ound-effects-and-recovery-state-machine.md | 21 +- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_dependency_tests.rs | 88 +++++- .../src/native_threshold_testkit.rs | 260 ++++++++++++++++++ .../auths-gateway/src/observed_tests.rs | 4 + .../auths-gateway/src/semantic_closure.rs | 2 +- 9 files changed, 725 insertions(+), 23 deletions(-) create mode 100644 product/runtime/auths-gateway/src/native_threshold_testkit.rs diff --git a/bindings/fixtures/gateway/native-dependency-order-file.json b/bindings/fixtures/gateway/native-dependency-order-file.json index ea43302b6..63dab3167 100644 --- a/bindings/fixtures/gateway/native-dependency-order-file.json +++ b/bindings/fixtures/gateway/native-dependency-order-file.json @@ -3,8 +3,8 @@ "adapter": "file", "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", "excluded": [ - "observer-evidence aging and threshold-selection changes", "mutation/disclosure races", + "installed language and human UI journeys", "fixed-window budget contention", "production commissioning", "hostile OS containment", @@ -194,6 +194,169 @@ "admission_time": 1790000000, "clock_after_wait": 1790000006, "history_inspection_did_not_change_journal": true + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 1 + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 0 + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 1 + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + }, + "actual_credential_leases": 1, + "actual_read_entries": 0 } ] } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-dependency-order-postgres.json b/bindings/fixtures/gateway/native-dependency-order-postgres.json index 6fb8fc7e1..57a23c6b9 100644 --- a/bindings/fixtures/gateway/native-dependency-order-postgres.json +++ b/bindings/fixtures/gateway/native-dependency-order-postgres.json @@ -3,8 +3,8 @@ "adapter": "postgres", "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", "excluded": [ - "observer-evidence aging and threshold-selection changes", "mutation/disclosure races", + "installed language and human UI journeys", "fixed-window budget contention", "production commissioning", "hostile OS containment", @@ -194,6 +194,169 @@ "admission_time": 1790000000, "clock_after_wait": 1790000006, "history_inspection_did_not_change_journal": true + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 1 + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 0 + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + }, + "actual_credential_leases": 1, + "actual_read_entries": 1 + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "history_inspection_did_not_change_journal": true, + "evidence_selection": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + }, + "actual_credential_leases": 1, + "actual_read_entries": 0 } ] } \ No newline at end of file diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 465fe857b..c810e1091 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2500,6 +2500,43 @@ closure regeneration passed after that correction (one artifact-generation test) commit `a81943a7` and later revisions still need exact-head hosted checks. Full AP074 acceptance remains open; the separate reference AP070 is not migrated. +## Native observer-expiry and threshold-selection checkpoint + +- The existing dependency matrix now has twelve histories per adapter (24 total). + Its original eight histories remain identical. New independent worker/operator + histories advance the maintained clock while entry waits behind the actual + file/TLS PostgreSQL connection-record writer fence. No verifier result, + admission/entry decision, signed event time or store snapshot is substituted. +- Two signed-observation controls exercise the inclusive five-second freshness + boundary and stale evidence at six seconds. The latter retains Reserved with + one call/1024 bytes and no provider request. Two 1-of-2 threshold controls use + the same complete proof/action/observation bytes: both branches authorize at + five seconds; at six, the proof remains Authorized through the longer-lived + branch. Actual selected branch/observation counts and native authority + commitments are checked, and only the authority field of the compiled binding + changes. The old exact approval remains in time but cannot approve that effect. +- The installed worker repeats the complete native check inside the actual + final writer fence. The changed selection yields no grant, HTTP entry or new + allocation; unchanged selection enters exactly once. These final-fence + schedules occur after initially authorized admission/custody. All four new + cases measure one earlier credential lease; refusals correctly measure zero + HTTP reads. No claim that a later refusal reverses an earlier lease is made. +- Original signed inputs stay byte-identical, admission remains at the original + time, positive entry uses the post-wait time, and reopened history leaves the + journal unchanged. Fixed public keys, maintained test clock, trusted host/ + stores, local HTTP and same-UID process assumptions remain explicit. +- Required artifact generation passed both adapter generators (2/2, zero + ignored, 5.02 seconds). Final refactored source passed no-update generation + verification (2/2, zero ignored, 5.03 seconds) and the previously failed strict + gateway all-feature library/test lint (7.74 seconds). These are construction + and focused reproduction results, not exact new-head hosted qualification. + A13/A14 installed surfaces and full mutation/disclosure races remain open. +- Gateway source closure was regenerated and its rebuilt no-update check passed. + Semantic-freeze generation reports no changed release subjects, so freeze 405 + and every existing semantic version remain unchanged. This batch changes only + native test authoring/evidence and documentation, with no shipping behavior, + journal schema, clock rule, approval rule or verification limit change. + ## Phase gates | Phase | State | Outstanding gate | @@ -2530,8 +2567,8 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate plus full native acquisition worker/operator histories / sixteen file/TLS PostgreSQL histories executed | Complete mutation/disclosure races remain required | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, signed-observation cases and native independent-process approval/authority lock-wait cases / file/TLS PostgreSQL lock-wait controls executed | Observer expiry, threshold changes and full installed/adverse evidence remain required | -| A14 | Valid threshold selection changes | Pending / no / no | Pin selected evidence | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native independent-process approval/authority/observer lock-wait cases / file/TLS PostgreSQL positive/stale observer controls executed at the exact freshness boundary and one second beyond | Full mutation/disclosure and installed/adverse evidence remain required | +| A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | | A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 88fc9c5ae..4e5b3ad42 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -694,15 +694,26 @@ These transaction-boundary process deaths do not establish actual sync/rename failure, partial-batch failure, ambiguous database commit delivery or the complete mutation/disclosure crash matrix. -`native-dependency-order-{file,postgres}.json` adds eight independent worker/ +`native-dependency-order-{file,postgres}.json` adds twelve independent worker/ operator histories per adapter. Connection revocation and configuration activation race the actual grant fence in both orders. Separate positive/expired controls advance the maintained test clock while entry waits behind a physically distinct connection record's writer fence, independently checking human approval and -native resource authority. Signed inputs and admission time remain unchanged; -valid entry records the time after waiting. These cases establish acquisition -ordering under the stated test deployment, not observer-evidence expiry, -threshold-selection changes or complete mutation/disclosure dependency races. +native resource authority. Four additional histories per adapter independently +age a signed observation and change the selected evidence in a real 1-of-2 proof. +At the inclusive five-second freshness boundary, both positive controls enter. +At six seconds, single-branch observation evidence is stale; the threshold proof +remains natively authorized through its longer-lived branch, but only its bound +native authority projection changes. The original exact approval remains current +and cannot approve that changed effect. Actual final fenced re-verification +refuses entry and retains the original reservation and charges. Signed proof, +action, observation and approval bytes and admission time remain unchanged; +valid entry records the time after waiting. The schedule occurs after initially +authorized admission and a custody lease; the final refusal prevents any HTTP +entry and does not claim to undo that prior lease. These cases establish native +acquisition ordering under the stated test deployment. Complete mutation/ +disclosure dependency races and installed language/human UI evidence remain +separate requirements. `native-window-capacity-{file,postgres}.json` separately exercises native bounded resource grants and exact approvals across independent worker processes. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 839383ce4..fd1f524e7 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b2337a0b2d9ec4b00a123dd222eaa1f151130f0452adc90614f82eb93a7e4e3e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"8783cb42b051211ae26ec7186cff2106c2d001d6b53b8c2eba203fde056cad7f"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"842339136783446333468f837c7ecbfd7015d33a84bb3e1e89c013e06f1c5eac"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"e562555103518190c07965ba2fe329e21eaecf2233b74e6cf3fbeb37e1f67a65"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b2337a0b2d9ec4b00a123dd222eaa1f151130f0452adc90614f82eb93a7e4e3e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"8783cb42b051211ae26ec7186cff2106c2d001d6b53b8c2eba203fde056cad7f"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"3bb937b5499bc8d762a015d7a616d7c258dd680b93288b368e4cfb3f9064448f"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_dependency_tests.rs b/product/runtime/auths-gateway/src/native_dependency_tests.rs index e6d8c3bae..07d7cb76b 100644 --- a/product/runtime/auths-gateway/src/native_dependency_tests.rs +++ b/product/runtime/auths-gateway/src/native_dependency_tests.rs @@ -39,11 +39,16 @@ enum Scenario { ApprovalExpired, AuthorityValid, AuthorityExpired, + ObserverValid, + ObserverExpired, + ThresholdValid, + ThresholdChanged, } impl Scenario { const fn time_shift(self) -> u64 { match self { Self::ApprovalValid | Self::AuthorityValid => 4, + Self::ObserverValid | Self::ThresholdValid => 5, _ => 6, } } @@ -82,7 +87,10 @@ impl Race { matches!(self.order, Order::GrantFirst) || matches!( self.scenario, - Scenario::ApprovalValid | Scenario::AuthorityValid + Scenario::ApprovalValid + | Scenario::AuthorityValid + | Scenario::ObserverValid + | Scenario::ThresholdValid ) } fn key() -> GatewayAttemptKey { @@ -268,6 +276,10 @@ fn run_worker(race: &Race, store: &TestAttempts) { &race.installation.root.join("worker-result"), &serde_json::to_vec(&result).expect("result"), ); + private( + &race.installation.root.join("worker-witness"), + &serde_json::to_vec(&engine.execution_witness()).expect("witness"), + ); } fn hold_connection(race: &Race, store: &TestAttempts, channel: &mut TcpStream) { let record = crate::harness::fixture_connection(&recipe()).expect("connection template"); @@ -473,6 +485,7 @@ struct Case { operator_listener: TcpListener, provider: Provider, signed_inputs: Vec>, + evidence: Option, } impl Case { fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { @@ -497,10 +510,13 @@ impl Case { }, }; let runtime = runtime(); - let (engine, record) = runtime.block_on(load_engine( + let controls = EngineControls::baseline(); + let clock = controls.clock.clone(); + let (engine, record) = runtime.block_on(load_controlled_engine( &race.installation, "parent", store.attempts().clone(), + controls, )); let shared = SharedConnection::new( store.raw(), @@ -513,13 +529,36 @@ impl Case { engine .initialize_effect_configuration() .expect("configuration"); - runtime.block_on(authorize_bounded( - &engine, - &race.installation.root, - OPERATION, - scenario.authority_until(), - scenario.approval_until(), - )); + let evidence = if matches!( + scenario, + Scenario::ObserverValid + | Scenario::ObserverExpired + | Scenario::ThresholdValid + | Scenario::ThresholdChanged + ) { + Some( + runtime.block_on(crate::observed_tests::threshold_testkit::authorize( + &engine, + &clock, + &race.installation.root, + OPERATION, + matches!( + scenario, + Scenario::ThresholdValid | Scenario::ThresholdChanged + ), + NOW + scenario.time_shift(), + )), + ) + } else { + runtime.block_on(authorize_bounded( + &engine, + &race.installation.root, + OPERATION, + scenario.authority_until(), + scenario.approval_until(), + )); + None + }; let signed_inputs = Self::inputs(&race); Self { _directory: directory, @@ -529,6 +568,7 @@ impl Case { operator_listener, provider, signed_inputs, + evidence, } } fn inputs(race: &Race) -> Vec> { @@ -649,11 +689,31 @@ impl Case { .expect("replay") .expect("record") ); - json!({ "scenario": self.race.scenario, "order": self.race.order, + let mut result = json!({ "scenario": self.race.scenario, "order": self.race.order, "actual_provider_reads": self.provider.calls.load(Ordering::SeqCst), "native_history": snapshot, "separate_operator_completed": true, "signed_inputs_unchanged": true, "admission_time": NOW, "clock_after_wait": matches!(self.race.order, Order::LockWait).then(|| NOW + self.race.scenario.time_shift()), - "history_inspection_did_not_change_journal": true }) + "history_inspection_did_not_change_journal": true }); + if let Some(evidence) = &self.evidence { + let witness: crate::GatewayExecutionWitness = serde_json::from_slice( + &std::fs::read(self.race.installation.root.join("worker-witness")) + .expect("witness"), + ) + .expect("native witness"); + // This schedule pauses at the final fence after an initially + // authorized admission and custody lease. Refusing that grant + // must prevent HTTP entry; it does not undo the earlier lease. + assert_eq!(witness.credential_lease_calls, 1); + assert_eq!( + witness.read_transport_entries, + u64::from(self.race.enters()) + ); + assert_eq!(witness.write_transport_entries, 0); + result["evidence_selection"] = evidence.clone(); + result["actual_credential_leases"] = json!(witness.credential_lease_calls); + result["actual_read_entries"] = json!(witness.read_transport_entries); + } + result } } fn dependency_matrix(backend: Backend) { @@ -666,6 +726,10 @@ fn dependency_matrix(backend: Backend) { (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), (Scenario::AuthorityExpired, Order::LockWait), + (Scenario::ObserverValid, Order::LockWait), + (Scenario::ObserverExpired, Order::LockWait), + (Scenario::ThresholdValid, Order::LockWait), + (Scenario::ThresholdChanged, Order::LockWait), ]; let cases: Vec<_> = pairs .into_iter() @@ -677,7 +741,7 @@ fn dependency_matrix(backend: Backend) { .collect(); let artifact = serde_json::to_vec_pretty(&json!({ "schema": "auths.native-dependency-order/1", "adapter": backend.label(), "scope": "full native acquisition engine; independent worker/operator OS processes; maintained file or TLS PostgreSQL common writer fence; changed dependencies in physically distinct records; fixed public test trust/keys and controlled maintained test clock; real local HTTP", - "excluded": ["observer-evidence aging and threshold-selection changes", "mutation/disclosure races", "fixed-window budget contention", "production commissioning", "hostile OS containment", "power loss and whole-store rollback"], "cases": cases })).expect("artifact"); + "excluded": ["mutation/disclosure races", "installed language and human UI journeys", "fixed-window budget contention", "production commissioning", "hostile OS containment", "power loss and whole-store rollback"], "cases": cases })).expect("artifact"); let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( "../../../bindings/fixtures/gateway/native-dependency-order-{}.json", backend.label() diff --git a/product/runtime/auths-gateway/src/native_threshold_testkit.rs b/product/runtime/auths-gateway/src/native_threshold_testkit.rs new file mode 100644 index 000000000..b4ae03c00 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_threshold_testkit.rs @@ -0,0 +1,260 @@ +//! Signed observation aging and threshold witnesses for real entry-fence races. +//! Authoring changes no verifier, approval, clock or adapter decision. +use super::*; +use crate::harness::authoring::ToolFixture; +use ed25519_dalek::{Signer as _, SigningKey}; + +fn requirement(maximum_age: u32) -> ObservationRequirement { + ObservationRequirement::new( + ObserverAnchorId::parse(ANCHOR).expect("anchor"), + ObservationSchemaId::parse(READ_BACK_SCHEMA).expect("schema"), + ObservationSubject::Resource( + ResourceId::parse(&read_back_subject(RECORD)).expect("subject"), + ), + maximum_age, + vec![ObservationCondition::new( + name("value"), + ConditionTest::EqLiteral(text("Pending")), + )], + ) + .expect("observation requirement") +} + +fn signed(call: &McpToolCall, threshold: bool) -> ToolFixture { + let root = signer(h::ROOT_SEED); + let actor = signer(0x22); + let observer = signer(h::OBSERVER_SEED); + let context = h::context_for_tool(&root, &observer.principal, NOW, call).expect("trust"); + let observation = forged_read_back(&observer, &observer.principal, RECORD, "Pending"); + let (descriptors, detached) = attachments(&[observation]); + let canonical = McpProfile + .canonicalize(&call.canonical_bytes().expect("call")) + .expect("canonical action") + .with_detached_attachments(detached) + .expect("attachments"); + let references = [ProofRef::new([0x40; 32]), ProofRef::new([0x41; 32])]; + let plan = if threshold { + AuthorizationPlan::k_of_n( + 1, + references + .into_iter() + .map(AuthorizationPlan::proof) + .collect(), + ) + .expect("one-of-two threshold") + } else { + AuthorizationPlan::proof(references[0]) + }; + let mut grants = Vec::new(); + let mut actions = Vec::new(); + let mut bindings = Vec::new(); + for (index, maximum_age) in [5, 300] + .into_iter() + .enumerate() + .take(if threshold { 2 } else { 1 }) + { + let grant = h::grant_for_tool( + &root, + &actor.principal, + Some(requirement(maximum_age)), + window(NOW - 3_600, NOW + 3_600), + call, + ) + .expect("signed grant"); + let action = sign_action( + &actor, + envelope( + &actor, + &canonical, + &grant, + &plan, + references[index], + descriptors.clone(), + ), + ); + bindings.push( + ControlBinding::new( + StatementRef::Grant(grant_id(grant.statement()).expect("grant ID")), + vec![root.evidence().id()], + ) + .expect("grant control"), + ); + bindings.push( + ControlBinding::new( + StatementRef::Action(action_id(action.envelope()).expect("action ID")), + vec![actor.evidence().id()], + ) + .expect("action control"), + ); + grants.push(grant); + actions.push(action); + } + let mut evidence = vec![root.evidence(), actor.evidence()]; + evidence.sort_by_key(EvidenceObject::id); + let bundle = ProofBundle::new( + BundleHeader::v1(), + grants, + actions, + plan, + evidence, + bindings, + Vec::new(), + Vec::new(), + descriptors, + Some(canonical.body().to_vec()), + ) + .expect("native bundle"); + ToolFixture { + context: auths_codec::encode_verifier_context(&context).expect("context bytes"), + proof: encode_bundle(&bundle).expect("proof"), + action: encode_canonical_action(&canonical).expect("action bytes"), + } +} + +fn selection_witness(signed: &ToolFixture, threshold: bool, after: u64) -> Value { + let context = auths_codec::decode_verifier_context(&signed.context).expect("context"); + let before = crate::engine::verify_native(&context, NOW, &signed.proof, &signed.action) + .expect("native authority before wait"); + let later = crate::engine::verify_native(&context, after, &signed.proof, &signed.action); + let changed = after > NOW + 5; + let mut witness = json!({ + "threshold": threshold, + "observed_at": NOW, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": after, + "authorized_before_wait": true, + "authorized_after_wait": later.is_ok(), + "signed_inputs_reused": true, + }); + assert_eq!( + before.portable().authorized_branches().len(), + if threshold { 2 } else { 1 } + ); + if threshold || !changed { + let later = later.expect("proof remains authorized"); + let before_authority = + crate::effect::NativeAuthority::verified(before.portable(), &context) + .expect("authority"); + let after_authority = crate::effect::NativeAuthority::verified(later.portable(), &context) + .expect("authority"); + assert_eq!( + before_authority.commitment() == after_authority.commitment(), + !changed + ); + assert_eq!( + later.portable().authorized_branches().len(), + if threshold && !changed { 2 } else { 1 } + ); + assert_eq!( + later.portable().observation_satisfactions().len(), + if threshold && !changed { 2 } else { 1 } + ); + witness["selected_branches_before"] = json!( + before + .portable() + .authorized_branches() + .iter() + .map(|r| hex::encode(r.as_bytes())) + .collect::>() + ); + witness["selected_branches_after"] = json!( + later + .portable() + .authorized_branches() + .iter() + .map(|r| hex::encode(r.as_bytes())) + .collect::>() + ); + witness["authority_commitment_changed"] = json!(changed); + } else { + assert_eq!( + later.expect_err("single branch observation is stale"), + indeterminate("observation-missing") + ); + } + witness +} + +fn verify_binding( + before: &crate::effect::EffectBinding, + fresh: Result, + approval: crate::effect::ExactEffectApproval, + threshold: bool, + after: u64, +) { + let changed = after > NOW + 5; + if !threshold && changed { + assert_eq!( + fresh.expect_err("stale evidence cannot compile an effect"), + indeterminate("observation-missing") + ); + return; + } + let fresh = fresh.expect("native effect remains compilable"); + assert_eq!(before == fresh.binding(), !changed); + let mut before_json: Value = + serde_json::from_slice(&before.to_private_bytes().expect("binding")).expect("binding JSON"); + let mut after_json: Value = + serde_json::from_slice(&fresh.binding().to_private_bytes().expect("binding")) + .expect("binding JSON"); + before_json["native_authority"] = Value::Null; + after_json["native_authority"] = Value::Null; + assert_eq!(before_json, after_json, "only selected authority changes"); + let key = SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(); + assert_eq!(fresh.approve(approval, &key, after).is_err(), changed); +} + +/// Compile identical signed bytes on both sides of the future lock wait. +/// A threshold change remains authorized but invalidates the old exact approval; +/// a single-branch observation control actually becomes stale instead. +pub(crate) async fn authorize( + engine: &crate::GatewayEngine, + clock: &crate::FixedClock, + root: &std::path::Path, + operation: &str, + threshold: bool, + after: u64, +) -> Value { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) + .await + .expect("native call"); + let signed = signed(&call, threshold); + let mut witness = selection_witness(&signed, threshold, after); + let first = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("initial native effect"); + let request = first + .approval_request(NOW, NOW + 300) + .expect("approval request"); + let key = SigningKey::from_bytes(&[29; 32]); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + let approval = request.with_signature(signature); + let before_binding = first.binding().clone(); + first + .approve(approval.clone(), &key.verifying_key().to_bytes(), after) + .expect("original exact approval remains current after waiting"); + clock.set(after); + let fresh = engine + .compile_content_action(&signed.proof, &signed.action) + .await; + clock.set(NOW); + verify_binding(&before_binding, fresh, approval.clone(), threshold, after); + if threshold || after <= NOW + 5 { + witness["old_approval_accepts_current_effect"] = json!(after <= NOW + 5); + } + for (suffix, bytes) in [ + ("proof", signed.proof), + ("action", signed.action), + ( + "approval", + approval.to_private_bytes().expect("approval").to_vec(), + ), + ] { + crate::native_process_tests::private(&root.join(format!("{operation}.{suffix}")), &bytes); + } + witness +} diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 773cc32b1..5ed056923 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -54,6 +54,10 @@ const NOW: u64 = 1_790_000_000; #[path = "effect_native_tests.rs"] mod effect_native_tests; +#[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] +#[path = "native_threshold_testkit.rs"] +pub(crate) mod threshold_testkit; + fn window(from: u64, until: u64) -> ValidityWindow { h::window(from, until).expect("window") } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 1af886e7a..5a7655911 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0edb6b61543b3cc6119e18e17ee7dee21048de9957a990f4d4d556ef60ca6d6d"; + "1017e09e1f4d36991355aed1b3ec14a546e3e6ca5ccc96f46454fa070f67502f"; #[cfg(test)] mod tests { From 5eb761d2594f159afb74bec3addca2cdc0e74b65 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 15:43:40 +0000 Subject: [PATCH 087/136] test(gateway): verify independent recovery after writer withdrawal --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-independent-recovery-file.json | 265 +++++++ .../native-independent-recovery-postgres.json | 265 +++++++ compliance.toml | 2 + docs/plans/0074-implementation-status.md | 58 +- ...ound-effects-and-recovery-state-machine.md | 24 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/harness.rs | 20 + product/runtime/auths-gateway/src/lib.rs | 3 + .../auths-gateway/src/native_crash_tests.rs | 18 + .../src/native_recovery_actor_tests.rs | 721 ++++++++++++++++++ .../src/native_recovery_authoring.rs | 83 ++ .../auths-gateway/src/observed_tests.rs | 4 + .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 16 files changed, 1476 insertions(+), 15 deletions(-) create mode 100644 bindings/fixtures/gateway/native-independent-recovery-file.json create mode 100644 bindings/fixtures/gateway/native-independent-recovery-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_recovery_actor_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_recovery_authoring.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index ead9cdb70..3251369ca 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -60,6 +60,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh diff --git a/bindings/fixtures/gateway/native-independent-recovery-file.json b/bindings/fixtures/gateway/native-independent-recovery-file.json new file mode 100644 index 000000000..473772d73 --- /dev/null +++ b/bindings/fixtures/gateway/native-independent-recovery-file.json @@ -0,0 +1,265 @@ +{ + "schema": "auths.native-independent-recovery/1", + "adapter": "file", + "scope": "real native writer and separate reader OS processes; exact approvals; operator trust activation withdraws writer root while retaining independent reader; maintained durable stores and local actual HTTP", + "assumptions": [ + "fixed public test keys and maintained clock", + "trusted operator/host/stores and same UID", + "provider double with no request deduplication" + ], + "excluded": [ + "signed principal/grant status service revocation", + "production provider or human-presence qualification", + "hostile OS containment and whole-store rollback" + ], + "cases": [ + { + "outcome": "response-echo", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "response-recorded", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": 200, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": 200, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed-by-provider", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "response-state", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "response-recorded", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed", + "revision": 4, + "response_status": 200, + "observation_match": true, + "provider_linked": false, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed", + "revision": 4, + "response_status": 200, + "observation_match": true, + "provider_linked": false, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "lost-echo", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "unknown", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed-by-provider", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "lost-state", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "unknown", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive" + }, + "historical_writer_replay_stage": "unknown", + "replay_journals_and_execution_unchanged": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-independent-recovery-postgres.json b/bindings/fixtures/gateway/native-independent-recovery-postgres.json new file mode 100644 index 000000000..4a57c38e8 --- /dev/null +++ b/bindings/fixtures/gateway/native-independent-recovery-postgres.json @@ -0,0 +1,265 @@ +{ + "schema": "auths.native-independent-recovery/1", + "adapter": "postgres", + "scope": "real native writer and separate reader OS processes; exact approvals; operator trust activation withdraws writer root while retaining independent reader; maintained durable stores and local actual HTTP", + "assumptions": [ + "fixed public test keys and maintained clock", + "trusted operator/host/stores and same UID", + "provider double with no request deduplication" + ], + "excluded": [ + "signed principal/grant status service revocation", + "production provider or human-presence qualification", + "hostile OS containment and whole-store rollback" + ], + "cases": [ + { + "outcome": "response-echo", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "response-recorded", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": 200, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": 200, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed-by-provider", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "response-state", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "response-recorded", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed", + "revision": 4, + "response_status": 200, + "observation_match": true, + "provider_linked": false, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed", + "revision": 4, + "response_status": 200, + "observation_match": true, + "provider_linked": false, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "lost-echo", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "unknown", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded" + }, + "historical_writer_replay_stage": "observed-by-provider", + "replay_journals_and_execution_unchanged": true + }, + { + "outcome": "lost-state", + "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": "unknown", + "writer_current_denial": "untrusted-root", + "writer_actor": "key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw", + "reader_actor": "key:sha256:kVKFu9-uSgReZDOOhTO53camoLea6CuzkC8igs2fTIE", + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, + "provider_writes": 1, + "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, + "original_signed_bytes_unchanged": true, + "recovery": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive" + }, + "replay": { + "schema": "auths.gateway-recovery/1", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive" + }, + "historical_writer_replay_stage": "unknown", + "replay_journals_and_execution_unchanged": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 9e2f45392..7c689768d 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1812,6 +1812,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs#postgres_native_disclosure_process_crash_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#native_file_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#native_file_independent_recovery_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#postgres_native_independent_recovery_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c810e1091..8dc4bde7a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2537,6 +2537,60 @@ closure regeneration passed after that correction (one artifact-generation test) native test authoring/evidence and documentation, with no shipping behavior, journal schema, clock rule, approval rule or verification limit change. +## Native independent recovery actor checkpoint + +- New `native-independent-recovery-{file,postgres}.json` contains four histories + per adapter, with actual native writer and separate recovery-reader OS + processes and real local PATCH/GET transport. The operator activates a native + trust configuration withdrawing the writer root while retaining an independent + reader root and actor. No post-verification oracle, substituted record, + provider response injection or reconstructed permit is used. +- The original writer proof and exact approval remain in time at the recovery + clock. Previously valid, exactly approved new write/read submissions are + refused with native `untrusted-root` after activation, without admission, + custody or HTTP entry. Their initial native positive controls passed before + withdrawal. The reader's distinct principal, native read proof, current exact + approval and binding to the original source effect are checked. Source write + approval is independently rejected as recovery consent. +- Four outcomes distinguish recorded/lost write response and state equality/ + declared echo linkage. The provider receives the exact reviewed PATCH body + once, records that state, and answers exactly one bodyless GET. A matching + value without a link leaves lost-response history Unknown/Inconclusive. A + supported link may add provider-linked evidence while original response status + remains absent. A recorded response with equality alone projects Observed + without provider linkage; these facts are never collapsed into one success. +- Recovery preserves every source field except the sole reducer's supported + recovery facts/revision, including original identity, actor/proof/approval, + connection/configuration attribution, entry audit and charges. Both signed + input sets stay unchanged. Recovery replay preserves source/read snapshots and + execution witnesses; reopened historical writer replay preserves both journals + with zero lease/read/write calls even after current authority is withdrawn. +- Required construction passed both adapter generators (2/2, zero ignored, + 2.36 seconds), and no-update verification passed (2/2, zero ignored, + 2.45 seconds). Combined strict all-feature gateway library/test Clippy passed + in 13.13 seconds without lint allowances or relaxed assertions. The provider + helper explicitly restores blocking mode on + accepted sockets; its existing three-second I/O deadlines remain unchanged. + This fixes inherited nonblocking behavior in the new test helper, without + changing any native deadline or assertion. Both explicit tests are registered + in the hosted PostgreSQL workflow and compliance inventory. +- This is operator root withdrawal, not signed principal/grant status-service + revocation evidence. Fixed public keys, simulated reviewer signatures, + maintained clock, trusted operator/host/stores, same UID and local provider + assumptions remain explicit. Installed authenticated UI/language paths, other + revocation scopes, isolation and live-provider qualification remain separate + gates. AP070 remains independent and AP073 remains untouched. +- The required gateway source closure is regenerated. Freeze 406 advances only + the generator-reported compliance-bound identity protocol 150, public SDK 147 + and public surface 406 subjects. Journal schema `/16`, effect schema `/3`, + compiler `/8`, all native clocks/deadlines and shipping semantics remain + unchanged. This batch and local threshold commit `0e20c5f8` require fresh + exact-head hosted verification after publication. The live authoritative Lean + job `123552204257` for published `ce9d6cf5` is preserved; its twenty explicit + native PostgreSQL workflow cases passed with none ignored, including the newly + published disclosure matrices. That evidence does not attest to these later + unpublished sources or close complete AP074 acceptance. + ## Phase gates | Phase | State | Outstanding gate | @@ -2564,12 +2618,12 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient and full native file/TLS PostgreSQL crash corpora / fifty-six release histories include partial sends, both peers killed before ACK, caller loss after ACK commit, current-authority gates, late and repeated ACKs with conserved allocations/slots | Remaining I/O-error/ambiguous-commit races and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | -| A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP histories / six local process histories | Complete mutation, observation and disclosure projections | +| A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | | A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate plus full native acquisition worker/operator histories / sixteen file/TLS PostgreSQL histories executed | Complete mutation/disclosure races remain required | | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native independent-process approval/authority/observer lock-wait cases / file/TLS PostgreSQL positive/stale observer controls executed at the exact freshness boundary and one second beyond | Full mutation/disclosure and installed/adverse evidence remain required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | -| A15 | Recovery actor differs; original authority revoked | Partial / native compiler and file refinement / synthetic entry only | Revocation and installed execution | +| A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 4e5b3ad42..7b912f0ff 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -715,6 +715,30 @@ acquisition ordering under the stated test deployment. Complete mutation/ disclosure dependency races and installed language/human UI evidence remain separate requirements. +`native-independent-recovery-{file,postgres}.json` exercises four outcomes per +adapter using separate native writer and recovery-reader OS processes. A real +operator configuration activation withdraws the writer root while retaining an +independent reader root/actor. Previously valid, exactly approved new write and +recovery-read submissions from the writer then fail native `untrusted-root` +verification without admission, custody or provider entry. The original proof +and approval remain within their signed validity windows; this is authority +withdrawal rather than expiry. The current reader obtains its own native read +proof and exact approval bound to the original source effect. Source approval +cannot stand in for recovery approval. + +Actual local PATCH/GET exchanges distinguish a recorded response, a lost response, +matching state and recipe-declared echo linkage. Matching state without that +link leaves a lost-response source Unknown and the recovery Inconclusive. A +supported echo link records provider-linked evidence with the original response +status still absent; it does not invent a write response. Recovery preserves +source identity, actor attribution, signed evidence, entry audit and charges. +Reopened replay preserves both journals and performs no new lease or HTTP call; +retained writer history remains readable after current authority is withdrawn. +These are native file/TLS PostgreSQL observations with public test keys, a +maintained clock and trusted host/operator/stores. Signed principal/grant status +service revocation, installed human UI/language paths, hostile-process isolation +and live-provider qualification remain separate evidence requirements. + `native-window-capacity-{file,postgres}.json` separately exercises native bounded resource grants and exact approvals across independent worker processes. After a prefix acquisition, two new operations contend for the last count slot, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index fd1f524e7..3765767eb 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"4bcd0d4333b9633d2b628136c6ca847067d4e06a77c2a7bc062b2d991c08ff55"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b2337a0b2d9ec4b00a123dd222eaa1f151130f0452adc90614f82eb93a7e4e3e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"8783cb42b051211ae26ec7186cff2106c2d001d6b53b8c2eba203fde056cad7f"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"3bb937b5499bc8d762a015d7a616d7c258dd680b93288b368e4cfb3f9064448f"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/harness.rs b/product/runtime/auths-gateway/src/harness.rs index fb3e9964e..edde8847a 100644 --- a/product/runtime/auths-gateway/src/harness.rs +++ b/product/runtime/auths-gateway/src/harness.rs @@ -425,6 +425,26 @@ pub(crate) fn context_for_tools( ) } +/// Native test trust for explicit independent roots and closed tool permissions. +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +pub(crate) fn context_for_tools_with_roots( + roots: &[&Signer], + observer: &PrincipalId, + now: u64, + tools: &[McpToolCall], +) -> Result { + context_for( + roots, + observer, + None, + now, + 1, + fixture(CompositionRequirement::new(None, 1, 1, 1), "composition")?, + &[RAW_KEY_V1], + tools, + ) +} + #[allow( clippy::too_many_arguments, reason = "test trust fixture keeps each explicit bound visible" diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 0693e3381..c207a7140 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -184,3 +184,6 @@ mod native_postgres_commit_tests; mod native_information_replay_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_mutation_replay_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_recovery_actor_tests; diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs index b02a39c02..e97367263 100644 --- a/product/runtime/auths-gateway/src/native_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -324,6 +324,24 @@ fn native_crash_peer() { pub(super) struct Peer(Child); impl Peer { + pub(super) fn finish(&mut self) { + let deadline = Instant::now() + Duration::from_secs(30); + loop { + if let Some(status) = self.0.try_wait().expect("child status") { + let mut diagnostic = String::new(); + self.0 + .stderr + .take() + .expect("stderr") + .read_to_string(&mut diagnostic) + .expect("diagnostic"); + assert!(status.success(), "native peer failed: {diagnostic}"); + return; + } + assert!(Instant::now() < deadline, "native peer completion timeout"); + thread::sleep(Duration::from_millis(2)); + } + } pub(super) fn start(input: &Path, selector: &str, environment: &str) -> Self { Self( Command::new(std::env::current_exe().expect("test executable")) diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs new file mode 100644 index 000000000..5b061d2fa --- /dev/null +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -0,0 +1,721 @@ +//! Independent native recovery after operator withdrawal of the writer's root. +//! Real OS workers, local HTTP, exact approvals and both durable adapters. +use crate::effect::ExactEffectApproval; +use crate::native_crash_tests::Peer; +use crate::native_process_tests::{ + EngineControls, NOW, Setup, load_controlled_engine, private, runtime, +}; +use crate::observed_tests::recovery_authoring as author; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{ + GatewayAttemptKey, GatewayEngine, GatewayRecordKind, GatewaySubmitResult, LogicalOperationId, + SharedConnection, +}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + io::{Read as _, Write as _}, + net::{TcpListener, TcpStream}, + os::unix::fs::PermissionsExt as _, + path::{Path, PathBuf}, + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + thread::{self, JoinHandle}, + time::Duration, +}; + +const SOURCE: &str = "retired-writer"; +const RECOVERY: &str = "independent-reader"; +const PEER_ENV: &str = "AUTHS_AP074_RECOVERY_ACTOR_PEER"; +const TARGET: &str = "/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Outcome { + ResponseEcho, + ResponseState, + LostEcho, + LostState, +} +impl Outcome { + const fn responds(self) -> bool { + matches!(self, Self::ResponseEcho | Self::ResponseState) + } + const fn echo(self) -> bool { + matches!(self, Self::ResponseEcho | Self::LostEcho) + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct RecoverySetup { + installation: Setup, + outcome: Outcome, + reader: bool, +} + +fn controls(reader: bool) -> EngineControls { + let mut value = EngineControls::baseline(); + value.trust = Some(author::trust(!reader)); + value.recipe = Some(author::recipe()); + value.clock.set(NOW + u64::from(reader)); + value +} +fn input(root: &Path, name: &str) -> (Vec, Vec, ExactEffectApproval) { + let load = |suffix| std::fs::read(root.join(format!("{name}.{suffix}"))).expect("signed input"); + ( + load("proof"), + load("action"), + ExactEffectApproval::from_private_bytes(&load("approval")).expect("approval"), + ) +} +fn retain( + root: &Path, + name: &str, + signed: &crate::harness::authoring::ToolFixture, + approval: &ExactEffectApproval, +) { + for (suffix, bytes) in [ + ("proof", signed.proof.as_slice()), + ("action", signed.action.as_slice()), + ( + "approval", + approval.to_private_bytes().expect("approval").as_slice(), + ), + ] { + private(&root.join(format!("{name}.{suffix}")), bytes); + } +} + +#[test] +fn native_recovery_actor_peer() { + let Some(path) = std::env::var_os(PEER_ENV) else { + return; + }; + let setup: RecoverySetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + if setup.reader { + "reader-peer" + } else { + "writer-peer" + }, + store.attempts().clone(), + controls(setup.reader), + )); + let (proof, action, approval) = input( + &setup.installation.root, + if setup.reader { RECOVERY } else { SOURCE }, + ); + let result = if setup.reader { + runtime.block_on(recover_twice(&engine, &store, &proof, &action, approval)) + } else { + let result = runtime.block_on(engine.submit(&proof, &action, approval)); + assert_eq!( + result, + if setup.outcome.responds() { + GatewaySubmitResult::ResponseRecorded { status: 200 } + } else { + GatewaySubmitResult::Unknown + } + ); + json!({"result": result, "execution": engine.execution_witness()}) + }; + private( + &setup.installation.root.join(if setup.reader { + "reader-result" + } else { + "writer-result" + }), + &serde_json::to_vec(&result).expect("result"), + ); +} +async fn recover_twice( + engine: &GatewayEngine, + store: &TestAttempts, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, +) -> Value { + let first = Box::pin(engine.recover(SOURCE, proof, action, approval.clone())) + .await + .expect("independent recovery"); + let before = engine.execution_witness(); + let retained = journals(store).await; + let replay = Box::pin(engine.recover(SOURCE, proof, action, approval)) + .await + .expect("recovery replay"); + assert_eq!(first.source, replay.source); + assert_eq!(first.acquisition, replay.acquisition); + assert_eq!( + retained, + journals(store).await, + "replay preserves exact source/read journal bytes" + ); + assert_eq!( + before, + engine.execution_witness(), + "replay adds no lease or HTTP call" + ); + json!({"first": first.report(), "replay": replay.report(), "execution": before}) +} + +async fn journals(store: &TestAttempts) -> Vec> { + let raw = store.raw(); + tokio::task::spawn_blocking(move || { + [SOURCE, RECOVERY] + .map(|operation| record_from(raw.as_ref(), operation)) + .to_vec() + }) + .await + .expect("journal reader") +} + +#[derive(Debug, Eq, PartialEq)] +struct Request { + line: String, + body: Vec, +} +struct Provider { + port: u16, + requests: Arc>>, + stop: Arc, + worker: Option>, +} +fn receive(stream: &mut TcpStream) -> (String, Vec) { + stream + .set_nonblocking(false) + .expect("blocking accepted socket"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut bytes = Vec::new(); + while !bytes.ends_with(b"\r\n\r\n") { + assert!(bytes.len() < 16_384); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + bytes.push(byte[0]); + } + let header = String::from_utf8(bytes).expect("header"); + assert!( + header + .to_ascii_lowercase() + .contains("authorization: bearer public-native-process-fixture\r\n") + ); + let length = header + .lines() + .find_map(|line| { + let (key, value) = line.split_once(':')?; + key.eq_ignore_ascii_case("content-length") + .then(|| value.trim().parse::().expect("length")) + }) + .unwrap_or(0); + assert!(length <= 65_536); + let mut body = vec![0; length]; + stream.read_exact(&mut body).expect("body"); + (header.lines().next().expect("request").to_owned(), body) +} +impl Provider { + fn start(outcome: Outcome) -> Self { + let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); + listener.set_nonblocking(true).expect("poll"); + let port = listener.local_addr().expect("address").port(); + let requests = Arc::new(Mutex::new(Vec::new())); + let captured = requests.clone(); + let stop = Arc::new(AtomicBool::new(false)); + let done = stop.clone(); + let worker = thread::spawn(move || { + let mut state = Value::Null; + while !done.load(Ordering::SeqCst) { + let (mut stream, _) = match listener.accept() { + Ok(pair) => pair, + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(2)); + continue; + } + Err(error) => panic!("provider accept: {error}"), + }; + let (line, body) = receive(&mut stream); + captured.lock().expect("capture").push(Request { + line: line.clone(), + body: body.clone(), + }); + if line == format!("PATCH {TARGET} HTTP/1.1") { + state = serde_json::from_slice(&body).expect("native write JSON"); + assert_eq!(state["fields"]["DemoStatus"], "Approved"); + if !outcome.responds() { + continue; + } + } else { + assert_eq!(line, format!("GET {TARGET} HTTP/1.1")); + assert!(body.is_empty()); + assert!(!state.is_null(), "read follows actual write"); + } + let mut response = state.clone(); + if !outcome.echo() { + response["fields"] + .as_object_mut() + .expect("fields") + .remove("auths_echo"); + } + let bytes = serde_json::to_vec(&response).expect("response"); + stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n", bytes.len()).as_bytes()).expect("response header"); + stream.write_all(&bytes).expect("response body"); + } + }); + Self { + port, + requests, + stop, + worker: Some(worker), + } + } +} +impl Drop for Provider { + fn drop(&mut self) { + self.stop.store(true, Ordering::SeqCst); + if let Some(worker) = self.worker.take() { + let result = worker.join(); + if !thread::panicking() { + result.expect("provider"); + } + } + } +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + setup: RecoverySetup, + provider: Provider, + signed_source: Vec>, + original: Vec, + source_review: Value, +} +fn record(store: &TestAttempts, operation: &str) -> Vec { + record_from(store.raw().as_ref(), operation) +} +fn record_from(store: &dyn crate::GatewayAttemptStore, operation: &str) -> Vec { + let key = GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + author::recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key"); + store + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("retained record") +} +fn signed_bytes(root: &Path, name: &str) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| std::fs::read(root.join(format!("{name}.{suffix}"))).expect("input")) + .to_vec() +} +async fn prepare_negatives(engine: &GatewayEngine, root: &Path) { + let write = author::signed(&author::write_call("forbidden-new-write"), false); + let effect = engine + .compile_effect(&write.proof, &write.action) + .await + .expect("writer initially authorized"); + retain( + root, + "forbidden-write", + &write, + &author::approval(&effect, NOW), + ); + let call = engine + .recovery_authorization_call(SOURCE, "forbidden-read") + .await + .expect("writer read call"); + let read = author::signed(&call, false); + let effect = engine + .compile_recovery_effect(SOURCE, &read.proof, &read.action) + .await + .expect("writer read initially authorized"); + retain( + root, + "forbidden-read", + &read, + &author::approval(&effect, NOW), + ); +} +async fn reject_withdrawn_writer(engine: &GatewayEngine, root: &Path) { + let denial = GatewaySubmitResult::Denied { + code: "untrusted-root".to_owned(), + }; + let (proof, action, approval) = input(root, "forbidden-write"); + assert_eq!(engine.submit(&proof, &action, approval).await, denial); + let (proof, action, approval) = input(root, "forbidden-read"); + assert_eq!( + Box::pin(engine.recover(SOURCE, &proof, &action, approval)) + .await + .expect_err("writer read withdrawn"), + denial + ); +} +impl Case { + fn start(backend: Backend, outcome: Outcome) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)) + .expect("private mode"); + let store = TestAttempts::open(backend); + let provider = Provider::start(outcome); + let setup = RecoverySetup { + installation: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }, + outcome, + reader: false, + }; + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup.installation, + "parent", + store.attempts().clone(), + controls(false), + )); + runtime + .block_on( + SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ) + .insert(&connection), + ) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("initial configuration"); + let signed = author::signed(&author::write_call(SOURCE), false); + let original_trust = auths_codec::decode_verifier_context(&signed.context).expect("trust"); + crate::engine::verify_native(&original_trust, NOW + 1, &signed.proof, &signed.action) + .expect("writer proof remains in time at the later recovery clock"); + let effect = runtime + .block_on(engine.compile_effect(&signed.proof, &signed.action)) + .expect("source compilation"); + let source_review = serde_json::from_slice( + &effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("review bytes"), + ) + .expect("JSON"); + let body = effect.private_request().expect("mutation").body().to_vec(); + let approval = author::approval(&effect, NOW); + retain(&setup.installation.root, SOURCE, &signed, &approval); + effect + .approve( + approval, + crate::effect::fixture_policy().expect("policy").approver(), + NOW + 1, + ) + .expect("writer approval remains current at the recovery clock"); + let signed_source = signed_bytes(&setup.installation.root, SOURCE); + Self::peer(&setup); + let original = record(&store, SOURCE); + runtime.block_on(prepare_negatives(&engine, &setup.installation.root)); + assert_eq!( + provider.requests.lock().expect("capture").as_slice(), + [Request { + line: format!("PATCH {TARGET} HTTP/1.1"), + body + }] + ); + Self { + _directory: directory, + store, + setup, + provider, + signed_source, + original, + source_review, + } + } + fn peer(setup: &RecoverySetup) { + let path = setup.installation.root.join("peer-setup"); + private(&path, &serde_json::to_vec(setup).expect("setup")); + Peer::start( + &path, + "native_recovery_actor_tests::native_recovery_actor_peer", + PEER_ENV, + ) + .finish(); + } + fn execute(mut self) -> Value { + let runtime = runtime(); + self.setup.reader = true; + let (engine, _) = runtime.block_on(load_controlled_engine( + &self.setup.installation, + "operator", + self.store.reopen(), + controls(true), + )); + let review = engine + .effect_configuration_revision() + .expect("operator review"); + engine + .activate_effect_configuration(review) + .expect("withdraw writer root"); + assert_ne!( + engine + .effect_configuration_revision() + .expect("current revision"), + review + ); + runtime.block_on(reject_withdrawn_writer( + &engine, + &self.setup.installation.root, + )); + assert_eq!( + self.store + .raw() + .attempt_keys(100) + .expect("attempt keys") + .len(), + 1, + "withdrawn writer creates no admission" + ); + let call = runtime + .block_on(engine.recovery_authorization_call(SOURCE, RECOVERY)) + .expect("read call"); + let writer_read = author::signed(&call, false); + assert_eq!( + runtime + .block_on(engine.compile_recovery_effect( + SOURCE, + &writer_read.proof, + &writer_read.action + )) + .expect_err("withdrawn writer cannot read"), + GatewaySubmitResult::Denied { + code: "untrusted-root".to_owned() + } + ); + let reader = author::signed(&call, true); + let effect = runtime + .block_on(engine.compile_recovery_effect(SOURCE, &reader.proof, &reader.action)) + .expect("different native reader"); + let recovery_review: Value = serde_json::from_slice( + &effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("bytes"), + ) + .expect("JSON"); + assert_eq!( + self.source_review["native"]["actors"], + json!([author::actor(false)]) + ); + assert_eq!( + recovery_review["native"]["actors"], + json!([author::actor(true)]) + ); + assert_ne!(author::actor(false), author::actor(true)); + assert_eq!( + recovery_review["native"]["recovery"]["source_effect"], + self.source_review["effect_id_hex"] + ); + let approval = author::approval(&effect, NOW + 1); + retain(&self.setup.installation.root, RECOVERY, &reader, &approval); + let (_, _, source_approval) = input(&self.setup.installation.root, SOURCE); + assert!( + effect + .approve( + source_approval, + crate::effect::fixture_policy().expect("policy").approver(), + NOW + 1 + ) + .is_err(), + "writer approval is not independent recovery consent" + ); + let signed_reader = signed_bytes(&self.setup.installation.root, RECOVERY); + assert_eq!( + engine.execution_witness().credential_lease_calls, + 0, + "operator compilation never leases" + ); + assert_eq!(self.provider.requests.lock().expect("capture").len(), 1); + Self::peer(&self.setup); + assert_eq!( + signed_bytes(&self.setup.installation.root, RECOVERY), + signed_reader + ); + self.verify(&engine, &runtime) + } + fn verify(&self, engine: &GatewayEngine, runtime: &tokio::runtime::Runtime) -> Value { + let load = |name| { + serde_json::from_slice::( + &std::fs::read(self.setup.installation.root.join(name)).expect("result"), + ) + .expect("JSON") + }; + let reader = load("reader-result"); + let first = &reader["first"]; + let expected = if self.setup.outcome.echo() { + "observed-by-provider" + } else if self.setup.outcome.responds() { + "observed" + } else { + "unknown" + }; + assert_eq!(first["source"]["stage"], expected); + assert_eq!( + first["source"]["provider_linked"], + self.setup.outcome.echo() + ); + assert_eq!( + first["disposition"], + if self.setup.outcome.echo() || self.setup.outcome.responds() { + "recorded" + } else { + "inconclusive" + } + ); + assert_eq!( + first["source"]["response_status"], + if self.setup.outcome.responds() { + json!(200) + } else { + Value::Null + } + ); + assert_eq!(first["acquisition"]["reserved_calls"], 1); + assert_eq!(first["acquisition"]["reserved_bytes"], 16_384); + assert_eq!(reader["execution"]["credential_lease_calls"], 1); + assert_eq!(reader["execution"]["read_transport_entries"], 1); + assert_eq!(reader["execution"]["write_transport_entries"], 0); + { + let requests = self.provider.requests.lock().expect("capture"); + assert_eq!(requests.len(), 2); + assert_eq!( + requests[1], + Request { + line: format!("GET {TARGET} HTTP/1.1"), + body: Vec::new() + } + ); + } + let after = record(&self.store, SOURCE); + assert_fixed_source(&self.original, &after); + let read = record(&self.store, RECOVERY); + let (proof, action, approval) = input(&self.setup.installation.root, SOURCE); + let result = runtime.block_on(engine.submit(&proof, &action, approval)); + match &result { + GatewaySubmitResult::ObservedByProvider { status, .. } => { + assert!(self.setup.outcome.echo()); + assert_eq!(*status, self.setup.outcome.responds().then_some(200)); + } + GatewaySubmitResult::Observed { status, matched } => { + assert!(self.setup.outcome.responds() && !self.setup.outcome.echo()); + assert_eq!((*status, *matched), (200, true)); + } + GatewaySubmitResult::Unknown => { + assert!(!self.setup.outcome.responds() && !self.setup.outcome.echo()); + } + other => panic!("incorrect historical source projection: {other:?}"), + } + assert_eq!(record(&self.store, SOURCE), after); + assert_eq!(record(&self.store, RECOVERY), read); + assert_eq!(engine.execution_witness().credential_lease_calls, 0); + assert_eq!(engine.execution_witness().read_transport_entries, 0); + assert_eq!(engine.execution_witness().write_transport_entries, 0); + assert_eq!(self.provider.requests.lock().expect("capture").len(), 2); + assert_eq!( + signed_bytes(&self.setup.installation.root, SOURCE), + self.signed_source + ); + let original: Value = serde_json::from_slice(&self.original).expect("original source"); + assert_eq!( + original["state"]["facts"]["stage"], + if self.setup.outcome.responds() { + "response-recorded" + } else { + "unknown" + } + ); + json!({"outcome": self.setup.outcome, "writer_root_withdrawn_by_operator": true, + "source_stage_before_recovery": original["state"]["facts"]["stage"], + "writer_current_denial": "untrusted-root", "writer_actor": author::actor(false), "reader_actor": author::actor(true), + "writer_proof_and_approval_still_in_time": true, + "exact_reviewed_write_received": true, "provider_writes": 1, "provider_reads": 1, + "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, + "recovery": first, "replay": reader["replay"], "historical_writer_replay_stage": expected, + "replay_journals_and_execution_unchanged": true}) + } +} +fn assert_fixed_source(before: &[u8], after: &[u8]) { + let decode = |bytes| serde_json::from_slice::(bytes).expect("record"); + let mut before = decode(before); + let mut after = decode(after); + for value in [&mut before, &mut after] { + value.as_object_mut().expect("record").remove("revision"); + for field in [ + "stage", + "observation_match", + "observation_fact", + "provider_evidence", + "recovery_evidence", + ] { + value["state"]["facts"] + .as_object_mut() + .expect("mutation facts") + .remove(field); + } + } + assert_eq!( + before, after, + "only the supported recovery facts/revision may change" + ); +} +fn recovery_matrix(backend: Backend) { + let cases: Vec<_> = [ + Outcome::ResponseEcho, + Outcome::ResponseState, + Outcome::LostEcho, + Outcome::LostState, + ] + .into_iter() + .map(|outcome| Case::start(backend, outcome).execute()) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-independent-recovery/1", "adapter": backend.label(), + "scope":"real native writer and separate reader OS processes; exact approvals; operator trust activation withdraws writer root while retaining independent reader; maintained durable stores and local actual HTTP", + "assumptions":["fixed public test keys and maintained clock", "trusted operator/host/stores and same UID", "provider double with no request deduplication"], + "excluded":["signed principal/grant status service revocation", "production provider or human-presence qualification", "hostile OS containment and whole-store rollback"], "cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-independent-recovery-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("artifact"), artifact); +} +#[test] +fn native_file_independent_recovery_fixture_is_current() { + recovery_matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_independent_recovery_fixture_is_current() { + assert!(postgres_configured()); + recovery_matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_recovery_authoring.rs b/product/runtime/auths-gateway/src/native_recovery_authoring.rs new file mode 100644 index 000000000..9650b9cd0 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_recovery_authoring.rs @@ -0,0 +1,83 @@ +//! Independent writer/reader authoring for actual native recovery journeys. +use super::*; +use crate::harness::authoring::ToolFixture; +use ed25519_dalek::{Signer as _, SigningKey}; + +pub(crate) fn recipe() -> CompiledRecipe { + CompiledRecipe::compile( + include_bytes!("../../../../bindings/fixtures/gateway/airtable/recipe.json"), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), + ) + .expect("maintained recipe") +} + +pub(crate) fn trust(writer_present: bool) -> Vec { + let recipe = recipe(); + let tools = [recipe.review().tool(), crate::effect::RECOVERY_READ_TOOL] + .map(|tool| McpToolCall::new(recipe.review().service(), tool, Map::new()).expect("tool")); + let writer_root = signer(0x11); + let reader_root = signer(0x12); + let observer = signer(h::OBSERVER_SEED); + let roots = if writer_present { + vec![&writer_root, &reader_root] + } else { + vec![&reader_root] + }; + let context = + h::context_for_tools_with_roots(&roots, &observer.principal, NOW, &tools).expect("trust"); + auths_codec::encode_verifier_context(&context).expect("context bytes") +} + +pub(crate) fn write_call(operation: &str) -> McpToolCall { + let recipe = recipe(); + let arguments = json!({ + "operator_namespace": recipe.namespace().as_str(), "recipe_digest": recipe.digest_hex(), + "operation_id": operation, "record_id": RECORD, "replacement": "Approved", + }); + McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + arguments.as_object().expect("args").clone(), + ) + .expect("write call") +} + +pub(crate) fn signed(call: &McpToolCall, reader: bool) -> ToolFixture { + let root = signer(if reader { 0x12 } else { 0x11 }); + let actor = signer(if reader { 0x44 } else { 0x22 }); + let grant = h::grant_for_tool( + &root, + &actor.principal, + None, + window(NOW - 3_600, NOW + 3_600), + call, + ) + .expect("grant"); + let submission = submission_for_call(&root, &actor, &grant, call, &[]); + ToolFixture { + context: trust(!reader), + proof: submission.proof, + action: submission.action, + } +} + +pub(crate) fn approval( + effect: &crate::effect::BoundEffect, + now: u64, +) -> crate::effect::ExactEffectApproval { + let request = effect + .approval_request(now, NOW + 300) + .expect("approval request"); + let key = SigningKey::from_bytes(&[29; 32]); + let signature = key + .sign(&request.signing_message().expect("message")) + .to_bytes(); + request.with_signature(signature) +} + +pub(crate) fn actor(reader: bool) -> String { + signer(if reader { 0x44 } else { 0x22 }) + .principal + .as_str() + .to_owned() +} diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 5ed056923..ac24cdb48 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -58,6 +58,10 @@ mod effect_native_tests; #[path = "native_threshold_testkit.rs"] pub(crate) mod threshold_testkit; +#[cfg(all(unix, feature = "loopback-provider", feature = "testkit-harness"))] +#[path = "native_recovery_authoring.rs"] +pub(crate) mod recovery_authoring; + fn window(from: u64, until: u64) -> ValidityWindow { h::window(from, until).expect("window") } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 5a7655911..b2a9bf7cd 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "1017e09e1f4d36991355aed1b3ec14a546e3e6ca5ccc96f46454fa070f67502f"; + "b6f448e0d800b06fbde7b4efe7e88edd8dffdb6e23f8f75bc53f4fc8d198c957"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 6bdbb04db..1d78b18ed 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 405 +freeze_version = 406 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 405 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 149 +"auths.identity.protocol" = 150 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 405 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 146 +"auths.product.public-sdk-contract" = 147 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 405 +"auths.release.public-surface" = 406 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 8aa9d4088..92b8fbcac 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 405, + "freezeVersion": 406, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 149, + "version": 150, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "5cbd4e106caab2804145ecc9e908bb17691306def9fdf58b910c81fa5c29018a" + "sha256": "12362fbbb7ca581e65ab1cd9eb3b683e3db51606eb493ed8f5318c6711182963" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 146, + "version": 147, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "8c7fb65eeecf35b9b4dfc28b06abb856b7fa8953b0bb036a2c62a8a4a70fe6ca" + "sha256": "cf125d87e29804351798da2b5b16df77ad2143f0aa5ba8bf9bc673466510d8b8" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 405, + "version": 406, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "22363da70034870154c3e81ca8fe5bf4ded61af1dd9ff304e8d378b26384a8c1" + "sha256": "5cacdf92020bee0a41c301411b7e27485093248ee0213bc71e19baf1f58d9bb4" } ] } From 37a218c9fa1072c221c38f71474cb80064950096 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 16:24:38 +0000 Subject: [PATCH 088/136] feat(demo): require authenticated owner consent for native effects --- .github/workflows/airtable-gateway-demo.yml | 18 +- compliance.toml | 13 +- demos/airtable-gateway/README.md | 46 ++++ demos/airtable-gateway/app.py | 34 ++- demos/airtable-gateway/launch.py | 12 +- demos/airtable-gateway/operate.py | 109 ++++++--- demos/airtable-gateway/owner_review.py | 217 ++++++++++++++++++ demos/airtable-gateway/tests/owner_browser.py | 133 +++++++++++ .../tests/test_owner_review.py | 144 ++++++++++++ demos/airtable-gateway/tools/package.py | 2 +- demos/airtable-gateway/web/owner.css | 1 + demos/airtable-gateway/web/owner.html | 14 ++ demos/airtable-gateway/web/owner.js | 70 ++++++ ...017-bound-effect-and-recovery-ownership.md | 12 + docs/plans/0074-implementation-status.md | 42 ++++ .../0009-bound-effect-and-recovery.md | 3 + ...ound-effects-and-recovery-state-machine.md | 30 +++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 19 files changed, 865 insertions(+), 57 deletions(-) create mode 100644 demos/airtable-gateway/owner_review.py create mode 100644 demos/airtable-gateway/tests/owner_browser.py create mode 100644 demos/airtable-gateway/tests/test_owner_review.py create mode 100644 demos/airtable-gateway/web/owner.css create mode 100644 demos/airtable-gateway/web/owner.html create mode 100644 demos/airtable-gateway/web/owner.js diff --git a/.github/workflows/airtable-gateway-demo.yml b/.github/workflows/airtable-gateway-demo.yml index 47773484d..1a92288aa 100644 --- a/.github/workflows/airtable-gateway-demo.yml +++ b/.github/workflows/airtable-gateway-demo.yml @@ -75,9 +75,12 @@ jobs: npm install --ignore-scripts --no-save --no-audit --no-fund "$GITHUB_WORKSPACE"/target/airtable-demo/auths-dev-sdk-*.tgz npm run build node --check web/app.js + node --check web/owner.js npm run test:web - name: Verify private live launcher boundaries - run: python demos/airtable-gateway/tests/test_launch.py + run: | + python demos/airtable-gateway/tests/test_launch.py + python demos/airtable-gateway/tests/test_owner_review.py - name: Construct the source-free demo handoff run: | python demos/airtable-gateway/tools/package.py \ @@ -138,10 +141,21 @@ jobs: sudo mkdir -p /evidence sudo chmod 777 /evidence python3 package/airtable-gateway-demo/tests/browser.py + docker run -d --init --name airtable-owner-workbench \ + -p 127.0.0.1:8181:8181 -p 127.0.0.1:8182:8182 \ + auths-airtable-gateway-demo --port 8181 --owner-ui-port 8182 + for attempt in $(seq 1 60); do + if curl -fsS http://localhost:8181/api/status >/dev/null; then break; fi + sleep 1 + done + python3 package/airtable-gateway-demo/tests/owner_browser.py cp /evidence/*.png evidence/ + cp /evidence/owner-journey.json evidence/ - name: Stop the packaged operator if: always() - run: docker stop --time 30 airtable-workbench || true + run: | + docker stop --time 30 airtable-workbench || true + docker stop --time 30 airtable-owner-workbench || true - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 if: always() with: diff --git a/compliance.toml b/compliance.toml index 7c689768d..29d3e5596 100644 --- a/compliance.toml +++ b/compliance.toml @@ -2170,15 +2170,15 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1", "auths.private-effect-review/2", "auths.private-effect-signing/2"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] signature_families = ["ed25519-v1"] profiles = ["auths.mcp/2", "airtable-record-update-v1"] -transports = ["unix", "http-local-demo", "https-provider-disposable-table"] -configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel"] -security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history"] +transports = ["unix", "http-local-demo", "https-provider-disposable-table", "owner-review-http-local"] +configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel", "owner-loopback-origin", "private-owner-login-file", "native-review-renderer"] +security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history", "authenticated-owner-session", "withheld-exact-approval", "pending-owner-review"] [packages.auths-airtable-gateway-demo.claims] demo-conformance-fixture = ["demos/airtable-gateway/selftest.py#test_native_refusals_replay_race_and_loss"] @@ -2186,6 +2186,11 @@ runtime-enforcement-boundary = [ "demos/airtable-gateway/selftest.py#test_application_isolation_and_native_audit", "demos/airtable-gateway/selftest.py#test_private_reviewer_refuses_unlisted_inputs", "demos/airtable-gateway/selftest.py#test_exact_operator_consent_binding", + "demos/airtable-gateway/tests/test_owner_review.py#test_owner_channel_refuses_unauthenticated_and_cross_origin_decisions", + "demos/airtable-gateway/tests/test_owner_review.py#test_complete_review_is_unchanged_and_only_its_decision_releases_the_waiter", + "demos/airtable-gateway/tests/test_owner_review.py#test_expired_replaced_and_cookie_only_sessions_cannot_read_private_reviews", + "demos/airtable-gateway/tests/test_owner_review.py#test_unsupported_truncated_and_mismatched_review_cannot_be_presented", + "demos/airtable-gateway/tests/owner_browser.py#test_installed_authenticated_owner_review_and_native_recovery", ] receipt-producer-consumer = ["demos/airtable-gateway/tests/browser.py#test_packaged_workbench_and_unsigned_evidence"] diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index 4b74da91b..7ac38e896 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -210,6 +210,52 @@ session. Do not overwrite a dirty journal or use forced kill as normal cleanup. ## Evidence boundaries +### Authenticated owner review in local simulation + +The optional owner interface withholds all application exact-effect approvals +until a separately authenticated owner reviews and approves the complete native +literal projection. The application keeps its own proposal interface; it cannot +read the owner login file or exact approver key. Native authorization, request +compilation, admission and recovery still run in the gateway. + +```sh +python launch.py --name airtable-owner-workbench --port 8181 --owner-ui-port 8182 +``` + +Open the application at `http://localhost:8181` and owner review at +`http://localhost:8182`. Retrieve `/run/demo/private/owner-login` through the +trusted container operator account and enter it only in the owner interface. +Choose a closed application experiment, inspect the entire native review on the +owner page, and approve or decline that exact pending effect. Recovery requires +its own review and approval. A cached approval permits only the same native +effect; replay remains subject to the gateway's conservative history rules. +Each closed mutation label permits one new consent attempt per fresh run. An +identical proof/action may retrieve its original signed approval after a client +restart; this neither refreshes consent nor recreates a native entry permit. + +The browser keeps its short-lived owner bearer only in the owner page's memory +and explicit same-origin headers. Cookies are deliberately absent: localhost +cookies cross ports and would reach the untrusted application. The private +credential file and approver key remain in the operator boundary. This assumes +a trusted operator, browser and host, with the application UID unable to read +operator state. Expose both Docker ports on host loopback only, as the launcher +does. This mode is available only for simulation; live consent retains its +existing private operator channel. + +Bounds are one pending review, eight HTTP handlers, a 1,024-byte command, +131,072-byte native review envelope, five-second HTTP I/O, fifteen-minute owner +session and ten-minute consent wait. Session/consent limits do not refresh native +proofs, approvals or evidence. Native deadlines and final authority checks still +apply. Initial simulation commissioning and organizational proof approvals stay +explicitly scripted; the owner interface controls application exact effects. + +The hosted installed browser test exercises authenticated decline, refusal of a +substituted review, unchanged full native presentation, one exact write, +separately approved recovery and replay without further execution. Browser +actions simulate the owner; no human-attention or production qualification claim +follows. Complete managed content acquisition/disclosure through the installed +UI and the remaining AP074 acceptance evidence are still required. + The workflow packages and verifies exact payload digests outside the checkout, installs both SDK artifacts, measures native verification/replay/race/recovery, independent wire/read-back, competing-writer traffic, error bounds, UID isolation, diff --git a/demos/airtable-gateway/app.py b/demos/airtable-gateway/app.py index 841457936..5c5531fe0 100644 --- a/demos/airtable-gateway/app.py +++ b/demos/airtable-gateway/app.py @@ -80,6 +80,7 @@ def __init__(self, directory, sockets): 'demo.app-credential-environment') self.lock = threading.Lock() self.packets = {} + self.owner_approvals = {} self.records = [] self.entries = {} self.approval_responses = [] @@ -165,7 +166,20 @@ async def packet(self, label, *, fresh=False): async def exchange(self, packet, host=0, *, typescript=False): proof, action, operation = packet - approval = unb64(self.plan['effect_approvals'][operation]) + if self.plan['effect_review']['mode'] == 'authenticated owner review required': + key = (proof, action) + if key not in self.owner_approvals: + reviewed = await self.request_review({'mutation': operation, 'proof': b64(proof), 'action': b64(action)}) + if set(reviewed) == {'code'}: + return {'operation_id': operation, 'language': 'python', 'result': { + 'outcome': 'not-submitted', 'code': 'demo.operator-effect-review-refused'}} + require(set(reviewed) == {'proof', 'action', 'approval', 'literal_review'} + and unb64(reviewed['proof']) == proof and unb64(reviewed['action']) == action, + 'demo.operator-effect-review-mismatch') + self.owner_approvals[key] = unb64(reviewed['approval']) + approval = self.owner_approvals[key] + else: + approval = unb64(self.plan['effect_approvals'][operation]) if typescript: completed = await asyncio.create_subprocess_exec( '/usr/local/bin/node', str(HERE / 'submit.mjs'), @@ -211,14 +225,13 @@ async def remember(self, packet, record): self.approval_responses.append({'operation_id': operation, 'response': response}) recorded.add((operation, response)) - async def recover(self, source): - """Request independent operator consent, then submit its native read proof.""" - require(source in self.plan['cases'], 'demo.unknown-recovery-source') + async def request_review(self, request): + """Carry closed proposals to the separate operator; never sign consent.""" def request_review(): with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as channel: - channel.settimeout(660 if self.plan['mode'] == 'live' else 90) - channel.connect(str(self.sockets[0].parent / 'review.sock')) - payload = canonical({'source': source}) + channel.settimeout(660 if self.plan['mode'] == 'live' or self.plan['effect_review']['mode'] == 'authenticated owner review required' else 90) + channel.connect(str(self.sockets[0].parent / ('owner-review.sock' if 'mutation' in request else 'review.sock'))) + payload = canonical(request) channel.sendall(struct.pack('>I', len(payload)) + payload) def receive(length): output = b'' @@ -230,7 +243,12 @@ def receive(length): length = struct.unpack('>I', receive(4))[0] require(0 < length <= 4 * 1024 * 1024, 'demo.review-response-bound') return decode(receive(length)) - approved = await asyncio.to_thread(request_review) + return await asyncio.to_thread(request_review) + + async def recover(self, source): + """Request independent operator consent, then submit its native read proof.""" + require(source in self.plan['cases'], 'demo.unknown-recovery-source') + approved = await self.request_review({'source': source}) if set(approved) == {'code'}: return {'operation_id': source, 'language': 'python', 'result': { 'outcome': 'not-submitted', 'code': 'demo.operator-recovery-review-refused'}} diff --git a/demos/airtable-gateway/launch.py b/demos/airtable-gateway/launch.py index f2916b3c7..4dae566b7 100644 --- a/demos/airtable-gateway/launch.py +++ b/demos/airtable-gateway/launch.py @@ -50,10 +50,13 @@ def main(): parser.add_argument('--name', default='auths-' + PLATFORM + '-gateway-demo') parser.add_argument('--port', type=int, default=PORT) parser.add_argument('--cleanup', action='store_true') + parser.add_argument('--owner-ui-port', type=int, help='Separate owner approval UI in simulation') args = parser.parse_args() if (args.live != (args.env_file is not None) or args.cleanup and not args.live or not 1024 <= args.port <= 65535 or not re.fullmatch(r'[a-z][a-z0-9-]{0,62}', args.name) - or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._/:@-]{0,255}', args.image)): + or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._/:@-]{0,255}', args.image) + or (args.owner_ui_port is not None and (args.live or args.cleanup + or not 1024 <= args.owner_ui_port <= 65535 or args.owner_ui_port == args.port))): parser.error('live requires an operator env file; cleanup requires live; name/image/port must be bounded') docker = shutil.which('docker') if docker is None: @@ -69,14 +72,21 @@ def main(): command.extend(['-v', args.name + '-journal:/run']) if not args.cleanup: command.extend(['-p', f'127.0.0.1:{args.port}:{args.port}']) + if args.owner_ui_port is not None: + command.extend(['-p', f'127.0.0.1:{args.owner_ui_port}:{args.owner_ui_port}']) command.extend([args.image, '--port', str(args.port)]) if args.live: command.append('--live') if args.cleanup: command.append('--cleanup') + if args.owner_ui_port is not None: + command.extend(['--owner-ui-port', str(args.owner_ui_port)]) payload = credentials(args.env_file) if args.live else b'' print(('LIVE PROVIDER · DEVELOPMENT CUSTODY' if args.live else 'SIMULATION') + (' · CLEANUP' if args.cleanup else ' · http://localhost:' + str(args.port)), flush=True) + if args.owner_ui_port is not None: + print('Private owner review · http://localhost:' + str(args.owner_ui_port) + + ' · login file: /run/demo/private/owner-login in the operator container', flush=True) # No shell, credential arguments, environment export or app mount. raise SystemExit(subprocess.run(command, input=payload).returncode) diff --git a/demos/airtable-gateway/operate.py b/demos/airtable-gateway/operate.py index 6fd0ba04b..84ba44175 100644 --- a/demos/airtable-gateway/operate.py +++ b/demos/airtable-gateway/operate.py @@ -278,7 +278,7 @@ def operator_consent(directory, name): class Operator: - def __init__(self, mode): + def __init__(self, mode, owner_ui_port=None): require(os.getuid() == 0, 'demo.operator-root-required') require(not HOME.exists(), 'demo.fresh-container-required') HOME.mkdir(mode=0o755) @@ -290,6 +290,10 @@ def __init__(self, mode): os.chown(self.sockets, 0, APP_GID) self.port = None self.effect_reviewer = development_ed25519_identity_key() + self.owner_review = None + if owner_ui_port is not None: + from owner_review import OwnerReviewServer + self.owner_review = OwnerReviewServer(PRIVATE, owner_ui_port) def start_gateway(self, host): socket_path = self.sockets / ('app' + str(host) + '.sock') @@ -431,8 +435,8 @@ async def read_packet(self, call, plan): for signer in managers: await signer.aclose() - def exact_approval(self, state, name, proof, action, *mode): - """Scripted reviewer over complete native literal output; no human-trial claim.""" + def exact_approval(self, state, name, proof, action, *mode, review_only=False, owner_consent=False): + """Native review plus explicit owner consent, or the labeled simulator.""" directory = PRIVATE / name directory.mkdir(mode=0o700) proof_path, action_path = directory / 'proof', directory / 'action' @@ -453,7 +457,12 @@ def exact_approval(self, state, name, proof, action, *mode): 'demo.native-effect-review-required') write(directory / 'literal-review.json', output.stdout, new=True) write(directory / 'literal-review.txt', review['literal_review'].encode('utf-8'), new=True) - if self.mode == 'live': + if review_only: + return proof_path, action_path, None + if owner_consent: + require(self.owner_review is not None, 'demo.owner-review-unavailable') + self.owner_review.request(review) + elif self.mode == 'live': operator_consent(directory, name) signature = self.effect_reviewer.sign(bytes.fromhex(review['signing_message_hex'])) write(approval, gateway(self.binary, 'effect-approval', '--request', request, @@ -467,20 +476,25 @@ def prepare_exact_approvals(self, plan): values, reviews = {}, {} for label in LABELS: proof, action, _ = asyncio.run(application.packet(label)) - result = self.exact_approval(HOME / 'gateway0', 'effect-' + label, proof, action) + result = self.exact_approval(HOME / 'gateway0', 'effect-' + label, proof, action, + review_only=self.owner_review is not None) if result is not None: - values[label] = b64(read(result[2])) - review = decode(read(result[2].parent / 'literal-review.json')) + if result[2] is not None: + values[label] = b64(read(result[2])) + review = decode(read(result[0].parent / 'literal-review.json')) reviews[label] = review['literal_review'] - require('exact' in values, 'demo.exact-effect-approval-unavailable') - for label in LABELS: - # A malformed/unauthorized action cannot be reviewed. Sending an - # approval for another effect is an adversarial binding substitution, - # never an application-created authority or a bypass. - values.setdefault(label, values['exact']) - values['exact:fresh'] = values['exact'] + if self.owner_review is None: + require('exact' in values, 'demo.exact-effect-approval-unavailable') + for label in LABELS: + # An approval for another effect is an adversarial substitution, + # never an application-created authority or a bypass. + values.setdefault(label, values['exact']) + values['exact:fresh'] = values['exact'] + else: + require('exact' in reviews, 'demo.exact-effect-review-unavailable') plan['effect_approvals'] = values - plan['effect_review'] = {'mode': ('scripted operator reviewer; not an independent human trial' + plan['effect_review'] = {'mode': ('authenticated owner review required' if self.owner_review is not None + else 'scripted operator reviewer; not an independent human trial' if self.mode == 'simulation' else 'separate private operator consent; development signing custody'), 'renderer': 'auths.literal-complete-review/1', 'reviews': reviews} write(HOME / 'app/application.json', canonical(plan)) @@ -494,7 +508,7 @@ def prepare_recovery(self, source, sequence, plan): '--source-operation', source, '--recovery-operation', operation)) proof, action = asyncio.run(self.read_packet(call, plan)) approved = self.exact_approval(HOME / 'gateway0', operation, proof, action, - '--recovery-of', source) + '--recovery-of', source, owner_consent=self.owner_review is not None) require(approved is not None, 'demo.recovery-review-refused') return {'proof': b64(proof), 'action': b64(action), 'approval': b64(read(approved[2])), 'literal_review': decode(read(approved[2].parent / 'literal-review.json'))['literal_review']} @@ -510,7 +524,7 @@ def start_recovery_reviews(self, plan): class Handler(socketserver.BaseRequestHandler): def handle(self): - self.request.settimeout(660 if operator.mode == 'live' else 30) + self.request.settimeout(660 if operator.mode == 'live' or operator.owner_review is not None else 30) def receive(length): output = b'' while len(output) < length: @@ -520,8 +534,34 @@ def receive(length): return output try: length = struct.unpack('>I', receive(4))[0] - require(0 < length <= 1024, 'demo.review-request-bound') + maximum = 4 * 1024 * 1024 if self.server.mutation_route else 1024 + require(0 < length <= maximum, 'demo.review-request-bound') request = decode(receive(length)) + require(type(request) is dict, 'demo.review-request-refused') + if self.server.mutation_route: + require(set(request) == {'mutation', 'proof', 'action'}, 'demo.review-request-refused') + label = request['mutation'] + require(type(label) is str and label in plan['cases'], 'demo.review-source-refused') + proof, action = unb64(request['proof']), unb64(request['action']) + if counts.get('mutation:' + label, 0): + directory = PRIVATE / ('owner-mutation-' + label) + require((directory / 'approval').is_file() + and read(directory / 'proof') == proof and read(directory / 'action') == action, + 'demo.review-attempt-limit') + # Redeliver only the original signed envelope. This + # creates no new consent/signature or native permit. + approved = directory / 'proof', directory / 'action', directory / 'approval' + else: + counts['mutation:' + label] = 1 + approved = operator.exact_approval(HOME / 'gateway0', 'owner-mutation-' + label, + proof, action, owner_consent=True) + require(approved is not None, 'demo.owner-review-refused') + response = {'proof': b64(proof), 'action': b64(action), 'approval': b64(read(approved[2])), + 'literal_review': decode(read(approved[2].parent / 'literal-review.json'))['literal_review']} + raw = canonical(response) + require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') + self.request.sendall(struct.pack('>I', len(raw)) + raw) + return require(type(request) is dict and set(request) == {'source'} and type(request['source']) is str and request['source'] in plan['cases'], 'demo.review-source-refused') @@ -536,13 +576,16 @@ def receive(length): require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') self.request.sendall(struct.pack('>I', len(raw)) + raw) - path = self.sockets / 'review.sock' - server = socketserver.UnixStreamServer(str(path), Handler) - os.chown(path, 0, APP_GID) - os.chmod(path, 0o660) - thread = threading.Thread(target=server.serve_forever, daemon=True) - thread.start() - self.review_server, self.review_thread = server, thread + self.review_servers = [] + for mutation_route in ([False, True] if self.owner_review is not None else [False]): + path = self.sockets / ('owner-review.sock' if mutation_route else 'review.sock') + server = socketserver.UnixStreamServer(str(path), Handler) + server.mutation_route = mutation_route + os.chown(path, 0, APP_GID) + os.chmod(path, 0o660) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + self.review_servers.append((server, thread)) def application(self, *arguments): return subprocess.run(['/opt/consumer/bin/python', str(HERE / 'app.py'), *arguments], @@ -559,10 +602,12 @@ def witnesses(self): return values def stop(self): - if hasattr(self, 'review_server'): - self.review_server.shutdown() - self.review_server.server_close() - self.review_thread.join(timeout=5) + if self.owner_review is not None: + self.owner_review.stop() + for server, thread in getattr(self, 'review_servers', []): + server.shutdown() + server.server_close() + thread.join(timeout=5) for process, log, _ in self.processes: if process.poll() is None: process.terminate() @@ -585,13 +630,17 @@ def main(): parser.add_argument('--port', type=int, default=8081) parser.add_argument('--selftest', action='store_true') parser.add_argument('--cleanup', action='store_true') + parser.add_argument('--owner-ui-port', type=int, help='Separate authenticated owner UI for local simulation') args = parser.parse_args() + require(args.owner_ui_port is None or (not args.live and not args.selftest and not args.cleanup + and 1024 <= args.owner_ui_port <= 65535 and args.owner_ui_port != args.port), + 'demo.owner-ui-simulation-and-separate-port-required') if args.cleanup: require(args.live and not args.selftest, 'demo.live-cleanup-required') cleanup_existing() return require(not args.selftest or not args.live, 'demo.selftest-simulation-only') - operator = Operator('live' if args.live else 'simulation') + operator = Operator('live' if args.live else 'simulation', args.owner_ui_port) def interrupted(*_): raise Refusal('demo.interrupted') signal.signal(signal.SIGTERM, interrupted) diff --git a/demos/airtable-gateway/owner_review.py b/demos/airtable-gateway/owner_review.py new file mode 100644 index 000000000..d3360ca44 --- /dev/null +++ b/demos/airtable-gateway/owner_review.py @@ -0,0 +1,217 @@ +"""Private owner consent transport over complete native review output. + +This demo service holds no signing key and constructs no effect or approval. +The operator signs the retained native request only after authenticated consent. +""" +from dataclasses import dataclass, field +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +import os +import secrets +import threading +import time + +from demo_common import canonical, decode, require, write + +RENDERER = 'auths.literal-complete-review/1' +MAX_REVIEW = 131072 # Native MAX_PRIVATE_EFFECT_REVIEW_BYTES, including envelope. +MAX_COMMAND = 1024 +SESSION_SECONDS = 900 +CONSENT_SECONDS = 600 + + +def native_review(packet): + """Preserve native presentation; refuse an unsupported/incomplete envelope.""" + require(type(packet) is dict, 'demo.owner-review-envelope-refused') + raw = canonical(packet) + require(len(raw) <= MAX_REVIEW and set(packet) == { + 'schema', 'renderer', 'literal_review', 'approval_request', 'signing_message_hex'}, + 'demo.owner-review-envelope-refused') + require(packet['schema'] == 'auths.private-effect-signing/2' + and packet['renderer'] == RENDERER + and type(packet['literal_review']) is str and packet['literal_review'].isascii(), + 'demo.owner-review-renderer-refused') + literal = decode(packet['literal_review'].encode('ascii')) + require(type(literal) is dict and literal.get('schema') == 'auths.private-effect-review/2' + and all(key in literal for key in ('effect_id_hex', 'binding_canonical', 'native', 'semantic')), + 'demo.owner-review-incomplete') + request = packet['approval_request'] + require(type(request) is dict and set(request) == {'schema', 'effect', 'approver', 'not_before', 'expires_at'} + and request['schema'] == 'auths.exact-effect-approval/1' + and type(request['not_before']) is int and type(request['expires_at']) is int + and type(request['approver']) is list and len(request['approver']) == 32 + and type(request.get('effect')) is list + and len(request['effect']) == 32 + and all(type(value) is int and 0 <= value <= 255 for value in request['effect']) + and literal['effect_id_hex'] == bytes(request['effect']).hex(), + 'demo.owner-review-effect-mismatch') + # This is native output correlation, not a second effect hash/signing codec. + return decode(raw) + + +@dataclass +class Pending: + packet: dict + identifier: str = field(default_factory=lambda: secrets.token_urlsafe(32)) + event: threading.Event = field(default_factory=threading.Event) + accepted: bool = False + + +class OwnerReviewServer: + def __init__(self, directory, port): + directory = Path(directory) + require(directory.is_dir() and not directory.is_symlink() + and directory.stat().st_uid == os.getuid() + and directory.stat().st_mode & 0o077 == 0, 'demo.owner-private-directory-required') + self.credential = secrets.token_urlsafe(32) + write(directory / 'owner-login', self.credential.encode('ascii'), new=True) + self.lock = threading.Lock() + self.pending = None + self.session = None + self.assets = Path(__file__).resolve().parent / 'web' + owner = self + + class Handler(BaseHTTPRequestHandler): + def log_message(self, *_): + pass # Login, bearer, native private review and decisions stay private. + + def setup(self): + self.request.settimeout(5) + super().setup() + + def reply(self, status, value, *, kind='application/json'): + raw = value if isinstance(value, bytes) else canonical(value) + self.send_response(status) + self.send_header('Content-Type', kind) + self.send_header('Content-Length', str(len(raw))) + self.send_header('Cache-Control', 'no-store') + self.send_header('X-Content-Type-Options', 'nosniff') + self.send_header('Referrer-Policy', 'no-referrer') + self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; frame-ancestors 'none'; form-action 'self'; base-uri 'none'") + self.end_headers() + self.wfile.write(raw) + + def host(self): + return self.headers.get('Host') in owner.hosts + + def authenticated(self): + offered = self.headers.get('Authorization', '') + session = owner.session + return (session is not None and offered.isascii() and len(offered) <= 80 + and time.monotonic() < session['until'] + and secrets.compare_digest(offered, 'Bearer ' + session['bearer'])) + + def do_GET(self): + if not self.host(): + return self.reply(403, {'code': 'demo.owner-host-refused'}) + assets = {'/': ('owner.html', 'text/html; charset=utf-8'), + '/owner.js': ('owner.js', 'text/javascript; charset=utf-8'), + '/owner.css': ('owner.css', 'text/css; charset=utf-8')} + if self.path in assets: + name, kind = assets[self.path] + return self.reply(200, (owner.assets / name).read_bytes(), kind=kind) + with owner.lock: + if not self.authenticated(): + return self.reply(401, {'code': 'demo.owner-authentication-required'}) + if self.path == '/api/session': + return self.reply(200, {'renderer': RENDERER, 'csrf': owner.session['csrf']}) + if self.path == '/api/review': + pending = owner.pending + return self.reply(200, None if pending is None or pending.event.is_set() else { + 'review_id': pending.identifier, 'native': pending.packet}) + return self.reply(404, {'code': 'demo.owner-route-unavailable'}) + + def do_POST(self): + self.connection.settimeout(5) + if (not self.host() or self.headers.get('Origin') not in owner.origins + or self.headers.get('Content-Type') != 'application/json' + or self.headers.get('Transfer-Encoding') is not None): + return self.reply(403, {'code': 'demo.owner-channel-refused'}) + try: + require(len(self.headers.get_all('Content-Length', [])) == 1, + 'demo.owner-command-framing') + length = int(self.headers.get('Content-Length', '0')) + require(0 < length <= MAX_COMMAND, 'demo.owner-command-bound') + raw = self.rfile.read(length) + require(len(raw) == length, 'demo.owner-command-incomplete') + value = decode(raw) + require(type(value) is dict, 'demo.owner-command-refused') + except (ValueError, OSError): + return self.reply(400, {'code': 'demo.owner-command-refused'}) + with owner.lock: + if self.path == '/api/login': + valid = (set(value) == {'credential'} and type(value['credential']) is str + and value['credential'].isascii() and len(value['credential']) <= 64 + and secrets.compare_digest(value['credential'], owner.credential)) + if not valid: + return self.reply(403, {'code': 'demo.owner-login-refused'}) + owner.session = {'bearer': secrets.token_urlsafe(32), 'csrf': secrets.token_urlsafe(32), + 'until': time.monotonic() + SESSION_SECONDS} + # Cookies ignore ports and would leak to the untrusted + # application on the same localhost hostname. This bearer + # stays in owner-page memory and explicit same-origin headers. + return self.reply(200, {'bearer': owner.session['bearer'], + 'csrf': owner.session['csrf'], 'renderer': RENDERER}) + csrf = self.headers.get('X-Owner-CSRF', '') + if (not self.authenticated() or not csrf.isascii() or len(csrf) > 64 + or not secrets.compare_digest(csrf, owner.session['csrf'])): + return self.reply(403, {'code': 'demo.owner-session-refused'}) + if self.path != '/api/decision': + return self.reply(404, {'code': 'demo.owner-route-unavailable'}) + pending = owner.pending + if (set(value) != {'review_id', 'decision', 'renderer'} or pending is None + or pending.event.is_set() or value['review_id'] != pending.identifier + or value['decision'] not in ('approve', 'decline') or value['renderer'] != RENDERER): + return self.reply(409, {'code': 'demo.owner-review-changed'}) + pending.accepted = value['decision'] == 'approve' + pending.event.set() + return self.reply(200, {'decision': value['decision']}) + + class BoundedServer(ThreadingHTTPServer): + daemon_threads = True + request_queue_size = 8 + capacity = threading.BoundedSemaphore(8) + + def process_request(self, request, address): + if not self.capacity.acquire(blocking=False): + self.shutdown_request(request) + return + try: + super().process_request(request, address) + except Exception: + self.capacity.release() + raise + + def process_request_thread(self, request, address): + try: + super().process_request_thread(request, address) + finally: + self.capacity.release() + + self.server = BoundedServer(('0.0.0.0', port), Handler) + actual = self.server.server_address[1] + self.hosts = {f'localhost:{actual}', f'127.0.0.1:{actual}'} + self.origins = {'http://' + host for host in self.hosts} + self.thread = threading.Thread(target=self.server.serve_forever, daemon=True) + self.thread.start() + + def request(self, packet): + pending = Pending(native_review(packet)) + with self.lock: + require(self.pending is None, 'demo.owner-review-busy') + self.pending = pending + try: + require(pending.event.wait(CONSENT_SECONDS) and pending.accepted, + 'demo.owner-review-declined-or-expired') + finally: + with self.lock: + if self.pending is pending: + self.pending = None + + def stop(self): + with self.lock: + if self.pending: + self.pending.event.set() + self.server.shutdown() + self.server.server_close() + self.thread.join(timeout=5) diff --git a/demos/airtable-gateway/tests/owner_browser.py b/demos/airtable-gateway/tests/owner_browser.py new file mode 100644 index 000000000..33a18a35e --- /dev/null +++ b/demos/airtable-gateway/tests/owner_browser.py @@ -0,0 +1,133 @@ +"""Installed native owner-consent journey with a real browser and local provider. + +The browser actions simulate the owner; no human-attention/live-provider claim. +""" +import json +from pathlib import Path +import subprocess +import urllib.error +import urllib.request +from playwright.sync_api import expect, sync_playwright + +CONTAINER = 'airtable-owner-workbench' +APP = 'http://localhost:8181' +OWNER = 'http://localhost:8182' + + +def private_file(path): + return subprocess.check_output(['docker', 'exec', CONTAINER, 'cat', path]) + + +def witness(): + value = subprocess.check_output(['docker', 'exec', CONTAINER, + '/opt/demo/bin/auths-gateway-simulation', 'execution-witness', '--state-dir', '/run/demo/gateway0']) + return json.loads(value)['execution_witness'] + + +def native_review(name): + return json.loads(private_file('/run/demo/private/' + name + '/literal-review.json')) + + +def test_installed_authenticated_owner_review_and_native_recovery(): + # Read through the trusted operator account, never an application endpoint. + credential = private_file('/run/demo/private/owner-login').decode() + denied = subprocess.run(['docker', 'exec', '--user', '62004:62005', CONTAINER, + 'cat', '/run/demo/private/owner-login'], capture_output=True) + assert denied.returncode != 0 and not denied.stdout + plan = json.loads(private_file('/run/demo/app/application.json')) + assert plan['effect_approvals'] == {}, 'the agent received a preapproved effect' + try: + urllib.request.urlopen(OWNER + '/api/review') + raise AssertionError('anonymous private review disclosure') + except urllib.error.HTTPError as error: + assert error.code == 401 + before = witness() + with sync_playwright() as playwright: + browser = playwright.chromium.launch() + context = browser.new_context() + owner, agent = context.new_page(), context.new_page() + owner.goto(OWNER) + owner.locator('#credential').fill(credential) + owner.locator('#login button').click() + expect(owner.locator('#login')).to_be_hidden() + assert owner.evaluate('document.cookie === "" && localStorage.length === 0 && sessionStorage.length === 0') + # Both pages share browser state. Cookie auth would leak across these + # localhost ports; explicit owner-origin memory/headers must not. + app_headers = [] + agent.on('request', lambda request: app_headers.append(request.all_headers()) + if request.url.startswith(APP) else None) + agent.goto(APP) + expect(agent.locator('#submit')).to_be_enabled() + assert all('authorization' not in h and 'cookie' not in h for h in app_headers) + assert agent.evaluate('typeof bearer === "undefined"') + + agent.locator('#experiment').select_option('pending') + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + expect(owner.locator('#literal')).to_contain_text('"replacement": "Pending"') + assert witness() == before, 'review entered custody or provider transport' + owner.locator('#decline').click() + expect(agent.locator('#outcome')).to_have_text('NOT-SUBMITTED', timeout=45000) + assert witness() == before, 'declined effect entered the native runtime' + + agent.locator('#experiment').select_option('exact') + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + expect(owner.locator('#literal')).to_contain_text('"replacement": "Approved"') + native = native_review('owner-mutation-exact') + assert owner.locator('#literal').text_content() == native['literal_review'], 'review changed or truncated' + effect_id = json.loads(native['literal_review'])['effect_id_hex'] + assert witness() == before + status = owner.evaluate('''async () => (await fetch('/api/decision', { + method:'POST',headers:{'Content-Type':'application/json', + 'Authorization':'Bearer '+bearer,'X-Owner-CSRF':csrf}, + body:JSON.stringify({review_id:'substituted',decision:'approve',renderer})})).status''') + assert status == 409 and witness() == before + Path('/evidence').mkdir(exist_ok=True) + owner.screenshot(path='/evidence/owner-review.png', full_page=True) + owner.locator('#approve').click() + expect(agent.locator('#outcome')).to_have_text('RESPONSE-RECORDED', timeout=45000) + after_write = witness() + assert after_write['scope'] == before['scope'] + assert after_write['write_transport_entries'] == before['write_transport_entries'] + 1 + + agent.locator('#experiment').select_option('recover-exact') + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + expect(owner.locator('#literal')).to_contain_text('auths_gateway_recovery_read_v1') + native_read = native_review('read-exact-1') + assert owner.locator('#literal').text_content() == native_read['literal_review'] + assert json.loads(native_read['literal_review'])['native']['recovery']['source_effect'] == effect_id + assert witness() == after_write + owner.locator('#approve').click() + expect(agent.locator('#outcome')).to_have_text('RECOVERY-REPORT', timeout=45000) + after_read = witness() + assert after_read['write_transport_entries'] == after_write['write_transport_entries'] + assert after_read['read_transport_entries'] == after_write['read_transport_entries'] + 1 + agent.locator('#experiment').select_option('replay') + agent.locator('#submit').click() + expect(agent.locator('#outcome')).to_have_text('OBSERVED-BY-PROVIDER', timeout=45000) + assert witness() == after_read + fresh = subprocess.check_output(['docker', 'exec', '--user', '62004:62005', CONTAINER, + '/opt/consumer/bin/python', '/opt/demo/app.py', 'submit', '--experiment', 'replay']) + assert json.loads(fresh)['records'][0]['result']['outcome'] == 'observed-by-provider' + assert witness() == after_read, 'fresh client replay recreated execution' + agent.screenshot(path='/evidence/owner-journey.png', full_page=True) + assert all('authorization' not in h and 'cookie' not in h for h in app_headers) + browser.close() + manifest = json.loads(private_file('/opt/demo/manifest.json')) + Path('/evidence/owner-journey.json').write_text(json.dumps({ + 'schema': 'auths.authenticated-owner-review-journey/1', 'source_commit': manifest['source_commit'], + 'production_qualification': False, 'native_renderer_unchanged': True, + 'withheld_approvals_before_consent': True, 'decline_no_native_entry': True, + 'substituted_review_refused': True, 'application_cannot_read_owner_credential': True, + 'owner_auth_not_sent_to_application': True, 'one_exact_write': True, + 'independent_exact_read': True, 'replay_no_extra_execution': True, + 'fresh_process_replay_no_new_consent_or_execution': True, + 'scope': 'installed packages and native runtime; browser-simulated authenticated owner; local provider', + 'excluded': ['content acquisition/disclosure journey', 'human attention', 'production custody', + 'live provider qualification', 'hostile operating system']}, indent=2)) + + +if __name__ == '__main__': + test_installed_authenticated_owner_review_and_native_recovery() diff --git a/demos/airtable-gateway/tests/test_owner_review.py b/demos/airtable-gateway/tests/test_owner_review.py new file mode 100644 index 000000000..9972ae469 --- /dev/null +++ b/demos/airtable-gateway/tests/test_owner_review.py @@ -0,0 +1,144 @@ +"""HTTP authentication/display-correlation tests; no native authority claim. + +The installed browser journey separately exercises actual native review/signing. +""" +import copy +import json +from pathlib import Path +import sys +import tempfile +import threading +import time +import unittest +import urllib.error +import urllib.request + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from demo_common import Refusal +from owner_review import OwnerReviewServer, RENDERER, native_review + + +def packet(): + return {'schema': 'auths.private-effect-signing/2', 'renderer': RENDERER, + 'literal_review': json.dumps({'schema': 'auths.private-effect-review/2', + 'effect_id_hex': '00' * 32, 'binding_canonical': '{}', + 'native': {'body': '' + 'x' * 20000 + 'END-OF-REVIEW'}, + 'semantic': {}}), 'approval_request': {'schema': 'auths.exact-effect-approval/1', + 'effect': [0] * 32, 'approver': [0] * 32, 'not_before': 0, 'expires_at': 1}, + 'signing_message_hex': '00'} + + +class OwnerChannel(unittest.TestCase): + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + Path(self.directory.name).chmod(0o700) + self.owner = OwnerReviewServer(self.directory.name, 0) + self.origin = 'http://127.0.0.1:' + str(self.owner.server.server_address[1]) + self.headers = {} + + def tearDown(self): + self.owner.stop() + self.directory.cleanup() + + def call(self, path, value=None, *, headers=None, raw=None): + body = raw if raw is not None else None if value is None else json.dumps(value).encode() + selected = dict(self.headers) + if body is not None: + selected.update({'Origin': self.origin, 'Content-Type': 'application/json'}) + selected.update(headers or {}) + request = urllib.request.Request(self.origin + path, data=body, headers=selected) + try: + response = urllib.request.urlopen(request, timeout=5) + except urllib.error.HTTPError as error: + response = error + with response: + return response.status, json.load(response), response.headers + + def login(self): + status, result, headers = self.call('/api/login', {'credential': self.owner.credential}) + self.assertEqual(status, 200) + self.assertIsNone(headers.get('Set-Cookie'), 'cookies would cross localhost ports') + self.headers = {'Authorization': 'Bearer ' + result['bearer'], 'X-Owner-CSRF': result['csrf']} + + def pending(self): + failures = [] + def request(): + try: + self.owner.request(packet()) + except Refusal as error: + failures.append(str(error)) + thread = threading.Thread(target=request) + thread.start() + deadline = time.monotonic() + 3 + while self.owner.pending is None: + self.assertLess(time.monotonic(), deadline) + time.sleep(.002) + return thread, failures + + def test_owner_channel_refuses_unauthenticated_and_cross_origin_decisions(self): + self.assertEqual(self.call('/api/review')[0], 401) + self.assertEqual(self.call('/api/login', {'credential': self.owner.credential}, + headers={'Origin': 'http://attacker.invalid'})[0], 403) + self.login() + self.assertEqual(self.call('/api/review', headers={'Host': 'attacker.invalid'})[0], 403) + thread, failures = self.pending() + identifier = self.owner.pending.identifier + decision = {'review_id': identifier, 'decision': 'approve', 'renderer': RENDERER} + self.assertEqual(self.call('/api/decision', decision, headers={'Authorization': ''})[0], 403) + self.assertEqual(self.call('/api/decision', decision, headers={'X-Owner-CSRF': ''})[0], 403) + self.assertEqual(self.call('/api/decision', decision, headers={'Origin': 'http://attacker.invalid'})[0], 403) + self.assertEqual(self.call('/api/decision', {**decision, 'review_id': 'substituted'})[0], 409) + self.assertEqual(self.call('/api/decision', {**decision, 'renderer': 'unsupported'})[0], 409) + self.assertFalse(self.owner.pending.event.is_set()) + self.assertEqual(self.call('/api/decision', {**decision, 'decision': 'decline'})[0], 200) + thread.join(timeout=3) + self.assertFalse(thread.is_alive()) + self.assertEqual(failures, ['demo.owner-review-declined-or-expired']) + + def test_complete_review_is_unchanged_and_only_its_decision_releases_the_waiter(self): + self.login() + thread, failures = self.pending() + status, value, _ = self.call('/api/review') + self.assertEqual(status, 200) + self.assertEqual(value['native'], packet()) + self.assertIn('END-OF-REVIEW', value['native']['literal_review']) + self.assertTrue(thread.is_alive()) + self.assertEqual(self.call('/api/decision', {'review_id': value['review_id'], + 'decision': 'approve', 'renderer': RENDERER})[0], 200) + thread.join(timeout=3) + self.assertFalse(thread.is_alive()) + self.assertEqual(failures, []) + self.assertEqual(self.call('/api/decision', {'review_id': value['review_id'], + 'decision': 'approve', 'renderer': RENDERER})[0], 409) + + def test_expired_replaced_and_cookie_only_sessions_cannot_read_private_reviews(self): + self.login() + original = dict(self.headers) + self.login() + self.assertEqual(self.call('/api/review', headers=original)[0], 401) + self.assertEqual(self.call('/api/review', headers={'Authorization': '', + 'Cookie': 'auths_owner=' + self.headers['Authorization'][7:]})[0], 401) + with self.owner.lock: + self.owner.session['until'] = time.monotonic() - 1 + self.assertEqual(self.call('/api/review')[0], 401) + + def test_malformed_duplicate_and_oversized_commands_are_refused(self): + self.login() + for raw in [b'{"decision":"approve","decision":"decline"}', b'[]', b'x' * 1025]: + self.assertEqual(self.call('/api/decision', raw=raw)[0], 400) + self.assertIsNone(self.owner.pending) + + def test_unsupported_truncated_and_mismatched_review_cannot_be_presented(self): + for change in [lambda p: p.update(renderer='unsupported'), + lambda p: p.update(literal_review=p['literal_review'][:-1]), + lambda p: p['approval_request'].update(effect=[1] * 32), + lambda p: p['approval_request'].pop('expires_at'), + lambda p: p.update(literal_review='x' * 131073)]: + value = copy.deepcopy(packet()) + change(value) + with self.assertRaises(Refusal): + native_review(value) + + +if __name__ == '__main__': + unittest.main() diff --git a/demos/airtable-gateway/tools/package.py b/demos/airtable-gateway/tools/package.py index b0318f0a7..5d866e6b8 100644 --- a/demos/airtable-gateway/tools/package.py +++ b/demos/airtable-gateway/tools/package.py @@ -21,7 +21,7 @@ def main(): source = Path(__file__).resolve().parents[1] repository = source.parents[1] files = {} - for name in ['app.py', 'operate.py', 'demo_common.py', 'double.py', 'selftest.py', 'generated.py', + for name in ['app.py', 'operate.py', 'owner_review.py', 'demo_common.py', 'double.py', 'selftest.py', 'generated.py', 'profile.toml', 'profile.lock.json', 'recipe.json', 'vectors.json', 'Dockerfile', 'README.md', 'package.json', 'contract.json', 'launch.py']: files[name] = ((source / name).read_bytes(), 0o644) diff --git a/demos/airtable-gateway/web/owner.css b/demos/airtable-gateway/web/owner.css new file mode 100644 index 000000000..a879c3d82 --- /dev/null +++ b/demos/airtable-gateway/web/owner.css @@ -0,0 +1 @@ +:root{font-family:ui-sans-serif,system-ui,sans-serif;color:#172c34;background:#f4f3ed}*{box-sizing:border-box}body{margin:0}main{max-width:1040px;margin:3rem auto;padding:0 1.5rem}h1{font-size:clamp(2rem,5vw,3.8rem);letter-spacing:-.045em}p{line-height:1.65;max-width:78ch}.eyebrow{text-transform:uppercase;letter-spacing:.14em;font-size:.8rem}form,section{padding:1.5rem;background:#fff;border:1px solid #c3cbc7;border-radius:.65rem;margin:1.5rem 0}label{display:block}input{display:block;width:min(100%,32rem);padding:.8rem;margin:1rem 0;font:inherit}button{background:#174e45;color:white;border:0;border-radius:.35rem;padding:.85rem 1.2rem;font:inherit;cursor:pointer}button:disabled{opacity:.45;cursor:wait}#decline{background:#594146}.actions{display:flex;gap:1rem;flex-wrap:wrap;margin-top:1rem}pre{white-space:pre-wrap;overflow-wrap:anywhere;background:#f3f5f3;padding:1rem;font: .85rem/1.6 ui-monospace,monospace}details{margin:1rem 0}.limits{font-size:.85rem;color:#4c605c}[hidden]{display:none!important} diff --git a/demos/airtable-gateway/web/owner.html b/demos/airtable-gateway/web/owner.html new file mode 100644 index 000000000..670134b00 --- /dev/null +++ b/demos/airtable-gateway/web/owner.html @@ -0,0 +1,14 @@ + + +Owner review · Auths +

Private operator channel

Review the exact effect.

+

The agent proposes. Your authenticated decision permits the operator to sign the native request shown here. It does not supply missing resource authority or establish a provider outcome.

+
+
+

Authentication required. Private reviews are unavailable to the agent.

+ +

Local development custody. Authentication maps this owner session to the installed exact approver. This UI makes no claim about human attention, production qualification or exclusive provider causation.

diff --git a/demos/airtable-gateway/web/owner.js b/demos/airtable-gateway/web/owner.js new file mode 100644 index 000000000..836131602 --- /dev/null +++ b/demos/airtable-gateway/web/owner.js @@ -0,0 +1,70 @@ +'use strict'; +const element = id => document.getElementById(id); +const renderer = 'auths.literal-complete-review/1'; +let bearer, csrf, pending, busy = false; +const headers = () => bearer ? {'Authorization': 'Bearer ' + bearer} : {}; +async function post(path, value) { + const response = await fetch(path, {method: 'POST', headers: { + 'Content-Type': 'application/json', ...headers(), ...(csrf ? {'X-Owner-CSRF': csrf} : {}) + }, body: JSON.stringify(value)}); + if (!response.ok) throw new Error('The owner channel refused this request. Sign in again or inspect the current review.'); + return response.json(); +} +function clear() { + pending = null; + element('approve').disabled = true; + element('decline').disabled = true; + element('review').hidden = true; + element('literal').textContent = ''; + element('signing').textContent = ''; +} +async function refresh() { + if (!csrf || busy) return; + try { + const response = await fetch('/api/review', {cache: 'no-store', headers: headers()}); + if (!response.ok) throw new Error('Owner session expired. Sign in again.'); + const value = await response.json(); + if (!value) { clear(); element('status').textContent = 'Signed in. Waiting for an exact native review.'; return; } + if (value.native.schema !== 'auths.private-effect-signing/2' || value.native.renderer !== renderer + || typeof value.native.literal_review !== 'string' || !value.native.literal_review) { + throw new Error('Unsupported native review. Approval is unavailable.'); + } + element('literal').textContent = value.native.literal_review; + element('signing').textContent = JSON.stringify(value.native.approval_request, null, 2) + + '\nNative signing message:\n' + value.native.signing_message_hex; + pending = value.review_id; + element('review').hidden = false; + element('approve').disabled = false; + element('decline').disabled = false; + element('status').textContent = 'Review the full native value before deciding.'; + } catch (error) { clear(); bearer = csrf = null; element('login').hidden = false; element('status').textContent = error.message; } +} +element('login').addEventListener('submit', async event => { + event.preventDefault(); + const credential = element('credential').value; + element('credential').value = ''; + try { + const session = await post('/api/login', {credential}); + if (session.renderer !== renderer) throw new Error('Unsupported review renderer.'); + csrf = session.csrf; + bearer = session.bearer; + element('login').hidden = true; + await refresh(); + } catch (error) { element('status').textContent = error.message; } +}); +for (const decision of ['approve', 'decline']) element(decision).addEventListener('click', async () => { + if (!pending || busy) return; + const review_id = pending; + busy = true; + element('approve').disabled = true; + element('decline').disabled = true; + try { + await post('/api/decision', {review_id, decision, renderer}); + clear(); + element('status').textContent = decision === 'approve' + ? 'Consent recorded for that exact native request. Inspect the gateway outcome separately.' + : 'Declined. No exact approval was issued.'; + } catch (error) { clear(); element('status').textContent = error.message; } + finally { busy = false; } +}); +setInterval(refresh, 1000); diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index a70ca7ac8..84ee4ee86 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -119,6 +119,18 @@ an effect digest alone does not establish complete presentation. Domain profiles own the meanings and units of mandatory fields. Faithful presentation makes no claim about human comprehension. +The managed Airtable demo's optional owner HTTP interface is consent transport, +not a second semantic owner. The operator retains the complete native review and +request, authenticates the owner through a private bootstrap credential, and +signs only after an exact pending-review decision. The application receives no +preissued exact approvals in this mode. Native code still owns approval bytes, +resource authority, the immutable effect and every durable transition. Owner +authentication stays in explicit origin-bound headers rather than cookies that +cross localhost ports. Session/consent time limits never refresh native signed +times or create an entry permit. This remains a simulation demonstration with +hosted tests authored; complete installed acquisition/disclosure UI, broader +containment and exact-head evidence remain required. + Recovery exposes bounded observation work, retained charges and escalation. Administrative annotations are not provider evidence; no administrative path can convert post-grant uncertainty into non-entry or silently release capacity. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 8dc4bde7a..10f084656 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2591,6 +2591,48 @@ closure regeneration passed after that correction (one artifact-generation test) published disclosure matrices. That evidence does not attest to these later unpublished sources or close complete AP074 acceptance. +## Authenticated owner review UI checkpoint (authored; hosted execution pending) + +- The managed Airtable demo has an opt-in simulation-only owner origin. It + withholds all application exact approvals at startup, renders the complete + native literal output and signing request, and requires authenticated explicit + approve/decline before the operator signs that exact pending native request. + Native code still owns identity, verification, approval encoding, admission, + execution and recovery. No presenter hashes, reconstructs or authorizes effects. +- A root-private per-run login file maps the owner to the installed approver. + The approver key remains in operator memory outside the application's UID. + Owner bearer/CSRF values stay only in owner-page memory and explicit same-origin + headers. Cookies are absent because localhost cookies cross ports and would + reach the untrusted application. No private authentication value enters URLs, + logs, application status, browser storage or source-controlled evidence. +- The new channel fails closed on host/origin/session/CSRF mismatch, stale or + substituted pending IDs, unsupported renderer/envelope, truncated/mismatched + native projection, duplicate/malformed/oversized commands and declined/expired + consent. One pending review, eight HTTP handlers, bounded input/complete native + output, HTTP deadlines and separate session/consent limits are explicit. + Existing 1,024-byte recovery-source RPCs retain that bound; mutation proof/action + proposals use a separate bounded socket. Native clocks and final checks do not + change. Default simulation/live channels retain their previous behavior/claims. +- Unit transport tests and a source-free installed browser/native journey are + authored and registered in hosted CI/compliance. The latter checks application + UID denial on the owner login file, empty startup exact approvals, no owner + authentication on the app origin in a shared browser context, exact complete + native display, decline/substitution with no entry, one approved write, + independently approved recovery and replay with unchanged execution witnesses. + Screenshots and a bounded manifest-linked JSON report are hosted outputs. +- Per GitHub-first policy, new local unit/browser/build/lint gates have not run. + This is authored implementation and CI coverage, not passed hosted evidence. + Resource-proof manager approvals and initial simulation commissioning remain + labeled scripted setup; browser owner actions simulate consent and establish + no human-attention/production claim. Full managed acquisition/disclosure through + installed UI/language consumers, broader isolation/negative parity and all + other A01–A22 requirements remain open. AP070 remains independent. +- P0's owner/consumer and finite-bound inventories include this demo consent + transport. Required release generation updates freeze 407 and only its reported + identity protocol 151, public SDK 148 and public surface 407 subjects. No Rust + runtime, gateway source closure, native schemas, formal predicates or tool pins + change in this UI batch. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 710f3b0d3..1c4034993 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -19,6 +19,7 @@ Owner: product gateway/kernel, per [ADR 0017](../../../adr/0017-bound-effect-and | AP070 `AdmissionStore` / `ProviderAttemptLedger` | Application-owned SQLite task counters, challenge/release decisions, per-GET records | Retain independent reference and narrower claims; never authorize managed gateway effects | | AP070 `execute_read` / `ReceiptStore` | Application-owned fetch, release orchestration and receipt claims | Preserve broker/reference; do not promote its facts to managed entry/recovery evidence | | TS `gateway.ts`, Python native runtime, gateway app/admin | Socket/binding routes and views | Expose native construction and state; no local effect hashes | +| Managed Airtable owner interface | Authenticated complete native presentation and exact pending consent; separate operator/app origins and UIDs | Demo-only consent transport; no effect hash, signature codec, native decision or lifecycle owner. Exact signing remains operator-held and native admission remains mandatory | | AP070 Drive adapter | Application-owned metadata/content GETs and provenance checks | Retain independent reference; any future managed Google integration needs separately reviewed native capabilities | | Gateway observer / audit / harness / commissioning | Signed observations, audit facts, local fixtures, bounded operator authority | Update identities and stages atomically; do not bypass commissioning bounds | @@ -77,6 +78,8 @@ that lookup. Optional task-free scope has an explicit tag distinct from task sco | Exact human approval | 4,096 canonical bytes; at most 3,600 seconds, with exclusive expiry | | Installed effect policy | `MAX_EFFECT_POLICY_BYTES`: 4,096 canonical bytes before decoding; partition at most 512 bytes; explicit nonzero safe-integer epoch; valid nonweak Ed25519 approver | | Private human review | 131,072 bytes including exact request and binding; never a public receipt | +| Demo owner HTTP interface | One pending review; eight handlers; 1,024-byte commands; native 131,072-byte envelope; five-second I/O, 900-second session and 600-second consent wait; no native expiry extension | +| Demo private review sockets | Existing source-only requests remain 1,024 bytes; separate mutation proof/action frame at most 4 MiB, followed by native proof/action limits; finite closed labels/attempt counts | | Observation attempts | At most 16 explicitly admitted linked operations | | Transaction lock deadline | 5 seconds; sample time after lock; refuse on deadline | | Native verification work | Native configured work-unit limit plus transaction deadline | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 7b912f0ff..c70bfe5af 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -252,6 +252,36 @@ must preserve that contract and associate its displayed result with the exact signing request. Native fixture parity alone does not close the installed approval-channel or human-journey acceptance gate. +The managed Airtable demo now has an optional simulation-only owner interface +on a separate loopback origin. In this mode the application receives no exact +effect approvals at startup. A private operator login file authenticates the +owner to the installed approver boundary. One opaque pending-review identity +links the complete native literal projection and signing request to the owner's +approve/decline decision; unsupported, truncated or mismatched review envelopes +cannot enter that channel. Only the operator then signs the retained native +request. The application cannot supply review text, signing bytes or a consent +decision. Native proof, binding, approval, admission and recovery checks remain +the sole execution authority. + +The owner page uses explicit same-origin bearer headers held only in page +memory. It uses no cookies or browser storage: cookies would cross localhost +ports and reach the application's origin. Host/origin, session and CSRF checks, +one pending review, eight handlers, 1,024-byte commands, the native 131,072-byte +review envelope, five-second HTTP I/O, fifteen-minute session and ten-minute +consent bounds are explicit. These UI limits never refresh native signed times +or evidence. Existing source-only review RPCs retain their 1,024-byte bound; +new proof/action proposals use a separate bounded operator socket. + +Hosted tests are authored for authentication/refusal, complete unmodified +presentation, withheld approvals, declined effects with no native entry, a +substituted review, one exact write, separately approved recovery and replay +without new execution. The source-free installed browser journey simulates owner +actions and retains screenshots/provenance. It does not establish human +attention, live-provider qualification, the complete content acquisition/ +disclosure UI or hostile-host containment. The default simulator and live +operator channel keep their existing narrower claims. A22 remains open until +the complete installed journey and required exact-head evidence pass. + ### 4.3 Closed transport and custody The private bound value contains the exact method, origin/path/query, noncredential headers, media type, body and closed observation plan. Transport accepts a stage-sealed effect capability, not a second set of URL/body/recipient parameters. Credential injection may fill only the approved credential slot for the bound connection/account/generation. Credentials themselves never enter effect serialization, public commitments, receipts, bindings or agent memory. diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 1d78b18ed..87e053a76 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 406 +freeze_version = 407 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 406 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 150 +"auths.identity.protocol" = 151 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 406 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 147 +"auths.product.public-sdk-contract" = 148 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 406 +"auths.release.public-surface" = 407 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 92b8fbcac..fb06eb4e1 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 406, + "freezeVersion": 407, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 150, + "version": 151, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "12362fbbb7ca581e65ab1cd9eb3b683e3db51606eb493ed8f5318c6711182963" + "sha256": "c836df56e0071e3c352859075ff84cf3361d9eb4a8b5fb40d7fd823ac5efbe97" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 147, + "version": 148, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "cf125d87e29804351798da2b5b16df77ad2143f0aa5ba8bf9bc673466510d8b8" + "sha256": "83a319c6061d2dc631768c0560e2841c56da37fb3004d678d304cd9f3ffdb2b5" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 406, + "version": 407, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "5cacdf92020bee0a41c301411b7e27485093248ee0213bc71e19baf1f58d9bb4" + "sha256": "0b82dab279a92e5e531372cbaf8e12eedf5d0814d755106ac55ae90609f8ff7f" } ] } From cb1ee6d15a8f728b2f6f9ce01021de69b67ac966 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 16:26:50 +0000 Subject: [PATCH 089/136] docs(gateway): retain terminal formal and runner-capacity evidence --- docs/plans/0074-hosted-evidence-ce9d6cf5.md | 84 +++++++++++++++++++++ docs/plans/0074-implementation-status.md | 27 ++++++- 2 files changed, 109 insertions(+), 2 deletions(-) create mode 100644 docs/plans/0074-hosted-evidence-ce9d6cf5.md diff --git a/docs/plans/0074-hosted-evidence-ce9d6cf5.md b/docs/plans/0074-hosted-evidence-ce9d6cf5.md new file mode 100644 index 000000000..872e7b6af --- /dev/null +++ b/docs/plans/0074-hosted-evidence-ce9d6cf5.md @@ -0,0 +1,84 @@ +# AP074 final hosted evidence — ce9d6cf5 + +Observed terminal state: **2026-10-29 16:13 UTC**. [PR213](https://github.com/auths-dev/auths-proof/pull/213). + +Published source head: **`ce9d6cf551af226d1a13d28f2de027ae5b81cbab`**. Main CI is qualified, but the complete PR matrix is **not all green**: two macOS Python consumers never acquired hosted runners, including their one authorized recovery attempt. + +All 96 latest check records are terminal: **86 success, 2 cancelled, 8 conditional skips**. All 14 workflows are terminal: **12 success, 1 failure (Python infrastructure), 1 conditional skip (custody live)**. No source/test defect was identified. Isolated checkout `/private/tmp/auths-ap074-ci-c80902ab` is clean at the published head; no source edits, local gates, commits or pushes this round. Parent's unpublished A13/A14, A15 and owner UI work is outside this evidence. Main/AP073/AP070 source untouched. + +## Complete workflow matrix + +| Workflow | Run | Result | +|---|---|---| +| Main CI | [40899439849](https://github.com/auths-dev/auths-proof/actions/runs/40899439849) | Success, including final formal evidence and CI-qualified | +| PostgreSQL lifecycle | [40899439948](https://github.com/auths-dev/auths-proof/actions/runs/40899439948) | Success; all 20 selected native cases actually ran | +| Python SDK | [40899439869](https://github.com/auths-dev/auths-proof/actions/runs/40899439869) | Attempt 2 failed solely on two runner-acquisition cancellations; 24 other jobs successful | +| TypeScript SDK | [40899439801](https://github.com/auths-dev/auths-proof/actions/runs/40899439801) | Success; packed Node/Chromium and both native harnesses | +| SDK outcome recipes | [40899439802](https://github.com/auths-dev/auths-proof/actions/runs/40899439802) | Success; installed Python/TS examples, scaffold and recipes | +| Gateway operator package | [40899439793](https://github.com/auths-dev/auths-proof/actions/runs/40899439793) | Success; source-free extraction and simulation | +| Recipe qualification | [40899439949](https://github.com/auths-dev/auths-proof/actions/runs/40899439949) | Simulation/candidate/offline success; conditional live/release reviewer jobs skipped | +| Gateway isolation | [40899439954](https://github.com/auths-dev/auths-proof/actions/runs/40899439954) | Distinct-UID success | +| Airtable Docker demo | [40899439876](https://github.com/auths-dev/auths-proof/actions/runs/40899439876) | 36 cases passed; production_qualification=false | +| Stripe Docker demo | [40899439762](https://github.com/auths-dev/auths-proof/actions/runs/40899439762) | 23 cases passed; production_qualification=false | +| Google installed images | [40899440046](https://github.com/auths-dev/auths-proof/actions/runs/40899440046) | Independent application-owned reference passed; no AP070 managed-native claim | +| Git signing protocol | [40899439950](https://github.com/auths-dev/auths-proof/actions/runs/40899439950) | Success | +| Git signing branch protection | [40899439930](https://github.com/auths-dev/auths-proof/actions/runs/40899439930) | Success | +| Gateway custody live | [40899439846](https://github.com/auths-dev/auths-proof/actions/runs/40899439846) | Conditional skipped; no evidence | + +The eight skipped jobs are production credential-store journey, Stripe test-mode journey, custody store-contract, independent first qualification signer, independent finite commissioning reviewer, retained production operator, complete cleaned-release signing and gateway release verification. None counted as passed. All required main CI implementations and formal phases passed; none were preflight-skipped. + +## Sole remaining root: macOS hosted-runner capacity + +Python attempt 1 finished with 24 successful jobs and exactly two cancelled consumers: + +- [CPython 3.10 macOS, job123543596333](https://github.com/auths-dev/auths-proof/actions/runs/40899439869/job/123543596333). +- [CPython 3.11 macOS, job123543596002](https://github.com/auths-dev/auths-proof/actions/runs/40899439869/job/123543596002). + +Both had no runner and no steps. GitHub's failure annotation says: **“The job was not acquired by Runner of type hosted even after multiple attempts”**, accompanied by macOS ARM capacity notices. This is not a test or source failure. + +After the complete Python matrix settled, the parent explicitly authorized one grouped recovery attempt. The connector returned 403 without mutating anything; the authorized `gh` fallback issued exactly one `POST /repos/auths-dev/auths-proof/actions/runs/40899439869/rerun-failed-jobs`. Attempt 2 started at 15:47:45 UTC on the same source head. Only the unsuccessful consumers were queued for execution: + +- [CPython 3.10 macOS retry, job123557778142](https://github.com/auths-dev/auths-proof/actions/runs/40899439869/job/123557778142). +- [CPython 3.11 macOS retry, job123557777897](https://github.com/auths-dev/auths-proof/actions/runs/40899439869/job/123557777897). + +Both retries were cancelled again before execution with the same runner-acquisition/capacity annotations. Attempt 2 finished at 16:02:46 UTC. **No second retry was issued.** Healthy jobs and the separate main/formal workflow were not rerun or cancelled. GitHub copied successful job records to new attempt handles while retaining original execution timestamps: for example the macOS wheel's copied job123557836972 still completed at 15:24:12 UTC, before retry submission. Original successful producer artifacts therefore remain attempt-1 evidence. + +Full original and retry job records/annotations: `/tmp/ap074-ci-ce9d-python-retry.json`. No platform, assertion, deadline or approval requirement was removed. The unresolved coverage is specifically the installed CPython 3.10/3.11 macOS consumers on this source head. Other 16 Python consumers, all three wheel producers, typing/API, source tests and both gateway harnesses passed. + +## Main CI and formal qualification + +- [Preflight123540248975](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123540248975): passed. +- [Authoritative123543879706](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123543879706) and [rollup123558564984](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123558564984): passed. Log has 609 result suites totaling 3,010 passed, zero failed and 98 ignored across repeated configurations, not 3,010 unique tests. Feature-gated native cases executed separately below. +- [Compliance123543880074](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123543880074), security, dependencies and all three live-reference implementations (OpenTofu/PostgreSQL/records API) plus rollups: passed. +- [Kani123543879775](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123543879775) and [rollup123558055121](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123558055121): passed, with **49 actual successful verifications**. +- [Authoritative Lean123552204257](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123552204257): clean rebuild and audit passed for **329 compiled statements**, reviewed transitive axioms, **four reviewed external links and zero compiled external axioms**, and all four Rust refinement tests. Fast Lean123540249162 also passed; it remains feedback rather than qualification. +- [Formal evidence123567518646](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123567518646): **PASS at 16:11:45 UTC**, explicitly `translation + clean Lean + Kani`; artifact12912697748. +- [Formal-translation rollup123572141294](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123572141294): passed. +- [CI-qualified123572202035](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123572202035): passed. + +### Translation reuse provenance + +[Translation123543879863](https://github.com/auths-dev/auths-proof/actions/runs/40899439849/job/123543879863) passed by validated same-PR reuse, not fresh translation execution. Phase artifact12909767960 records current head ce9d, run40899439849, attempt1; execution=`reused-pr-run`; reproduction_count=2; reused_from head9913d4c7/run40889129833/attempt1. The durable previous-head report records its underlying fresh ab36/run40867724155/attempt1 two-reproduction provenance. Preserve this chain rather than claiming two new builds. + +- Source closure: `a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825`. +- Translation phase: `a5a98c9c76bde8f03021fd572008961e2c425d11a8eb9ba2080b270b4a65c519`. +- Toolchain closure: `baff1cabbf9c83ffca0f4bdb1b8dda685a5ac59638e95d6d12e57f5d5bda9633`. +- Evidence closure: `cbc4400d316703bd0a0af4136f65c580047835a03144353343d051214233269f`. + +Saved phase artifact: `/tmp/ap074-ci-ce9d-formal-translation-phase.zip`. + +## Actual native PostgreSQL execution + +[PG job123537375377](https://github.com/auths-dev/auths-proof/actions/runs/40899439948/job/123537375377) executed all **20 explicit native selectors**, each one passed and zero ignored: CLI content capacity; file/PG process capacity; file/PG acquisition crash; file/PG mutation crash; **file/PG disclosure crash**; file/PG dependency ordering; file/PG window budgets; file I/O faults; PG partial-batch rollback; PG COMMIT reply loss; file/PG mutation retained replay; file/PG information retained replay. + +New disclosure generators passed in 11.15 seconds (file) and 40.86 seconds (TLS PostgreSQL). Existing 30 PG gateway tests passed in 13.74 seconds; lifecycle in 16.89 seconds; operator plane in 0.71 seconds. Physical/WAL restore retained before-target state and excluded after-target state; `replay_continuity_claim=false` remains explicit. + +Full log and timestamped execution lines: `/tmp/ap074-ci-ce9d-pg-job.json`. + +## Producer identity and evidence files + +Linux wheel and PG checked out PR merge **`cc77cdbea1132f2b1e0e48f2a2f96aa8e8d8dfb5`**, not literal source head ce9d. Both have verified Git tree **`11274eea06e9d50ccaf61475bc877e2bda19da89`**. Preserve the actual producer identity and the source-tree equivalence. Demo producers explicitly use PR head. + +Final complete check/workflow matrix, producer identity, native execution and retry evidence: `/tmp/ap074-ci-ce9d-evidence.json`. This report: `/tmp/ap074-ci-ce9d-report.md`. + +Main/formal work finished and will not be cancelled by the next coherent publication. No source fix or child commit is pending. Remaining runner capacity, conditional live qualification and other AP074 acceptance gaps are not waived. No claim is made for unpublished parent changes. AP070 remains independent; AP073 untouched. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 10f084656..02d2e48bd 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2585,8 +2585,8 @@ closure regeneration passed after that correction (one artifact-generation test) and public surface 406 subjects. Journal schema `/16`, effect schema `/3`, compiler `/8`, all native clocks/deadlines and shipping semantics remain unchanged. This batch and local threshold commit `0e20c5f8` require fresh - exact-head hosted verification after publication. The live authoritative Lean - job `123552204257` for published `ce9d6cf5` is preserved; its twenty explicit + exact-head hosted verification after publication. The authoritative Lean + job `123552204257` for published `ce9d6cf5` was preserved and completed; its twenty explicit native PostgreSQL workflow cases passed with none ignored, including the newly published disclosure matrices. That evidence does not attest to these later unpublished sources or close complete AP074 acceptance. @@ -2633,6 +2633,29 @@ closure regeneration passed after that correction (one artifact-generation test) runtime, gateway source closure, native schemas, formal predicates or tool pins change in this UI batch. +## Published ce9d6cf5 terminal hosted checkpoint + +- All 96 check records are terminal: 86 successful, two cancelled and eight + conditional skips. Main CI `40899439849`, authoritative implementation/Kani/ + clean Lean, final formal evidence `123567518646` and CI-qualified + `123572202035` passed. The complete PR matrix is not all green: Python workflow + `40899439869` failed solely because CPython 3.10/3.11 macOS consumers never + acquired hosted runners, including one grouped recovery attempt. Neither + cancelled consumer ran a test. No source defect was identified, no healthy + execution was rerun, and no platform/assertion/deadline was removed. +- PostgreSQL job `123537375377` executed all twenty explicit native selectors + with zero ignored, including the published disclosure crash matrices. Installed + Docker demos, TypeScript, SDK recipes, operator package, isolation and retained + independent Google reference passed. Conditional live/reviewer skips provide + no qualification evidence. +- The [durable terminal report](0074-hosted-evidence-ce9d6cf5.md) preserves the + complete workflow matrix, exact producer merge/tree identity, validated + translation reuse chain and both original/retry macOS job identities and + runner-acquisition annotations. All useful formal work completed before the + next publication. Local threshold `0e20c5f8`, independent recovery `5eb761d2` + and owner UI `37a218c9` remain outside this older-head evidence and require + fresh exact-head hosted verification. Complete AP074 acceptance remains open. + ## Phase gates | Phase | State | Outstanding gate | From 91552fa5079b1846643fc72efa3b31329df26fa8 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 16:50:00 +0000 Subject: [PATCH 090/136] test(gateway): compare bound mutations with independent references --- .github/workflows/python-sdk.yml | 21 + ...ependent-mutation-differential-report.json | 399 +++++++++ ...ive-independent-mutation-differential.json | 766 ++++++++++++++++++ compliance.toml | 2 + docs/plans/0074-differential-contracts.md | 72 ++ docs/plans/0074-implementation-status.md | 50 +- .../auths-gateway/src/effect_native_tests.rs | 4 + .../src/native_differential_tests.rs | 394 +++++++++ qualification/reference/ap074_differential.py | 241 ++++++ .../tests/test_ap074_differential.py | 51 ++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 12 files changed, 2010 insertions(+), 12 deletions(-) create mode 100644 bindings/fixtures/gateway/independent-mutation-differential-report.json create mode 100644 bindings/fixtures/gateway/native-independent-mutation-differential.json create mode 100644 docs/plans/0074-differential-contracts.md create mode 100644 product/runtime/auths-gateway/src/native_differential_tests.rs create mode 100644 qualification/reference/ap074_differential.py create mode 100644 qualification/reference/tests/test_ap074_differential.py diff --git a/.github/workflows/python-sdk.yml b/.github/workflows/python-sdk.yml index 70458dc9c..fa0f03082 100644 --- a/.github/workflows/python-sdk.yml +++ b/.github/workflows/python-sdk.yml @@ -11,6 +11,8 @@ on: - "bindings/wasm/auths-proof-wasm/examples/generate-node-vectors.rs" - "bindings/fixtures/openapi-corpus/**" - "bindings/fixtures/openapi-derivation/**" + - "bindings/fixtures/gateway/*differential*.json" + - "qualification/reference/**" - "product/tools/auths-openapi-derive/**" - ".github/workflows/python-sdk.yml" - "Cargo.lock" @@ -26,6 +28,8 @@ on: - "bindings/wasm/auths-proof-wasm/examples/generate-node-vectors.rs" - "bindings/fixtures/openapi-corpus/**" - "bindings/fixtures/openapi-derivation/**" + - "bindings/fixtures/gateway/*differential*.json" + - "qualification/reference/**" - "product/tools/auths-openapi-derive/**" - ".github/workflows/python-sdk.yml" - "Cargo.lock" @@ -65,6 +69,23 @@ jobs: cargo run --locked -p auths-proof-wasm --example generate-node-vectors -- target/binding-vectors - run: maturin develop --manifest-path bindings/python/Cargo.toml + - name: Execute the native side of the independent mutation differential + run: >- + cargo test --locked -p auths-gateway --features testkit-harness --lib + observed_tests::effect_native_tests::differential_tests::native_independent_mutation_differential_fixture_is_current + -- --exact + - name: Compare retained independent mutation references without provider access + run: >- + python qualification/reference/ap074_differential.py + --output target/ap074-independent-mutation-differential.json + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + with: + name: ap074-independent-mutation-differential-${{ github.run_id }}-${{ github.run_attempt }} + path: | + target/ap074-independent-mutation-differential.json + bindings/fixtures/gateway/native-independent-mutation-differential.json + if-no-files-found: error + retention-days: 30 - run: python -m pip install --no-deps -e bindings/python-adapters/sqlite - run: pytest -q bindings/python/tests - run: pytest -q bindings/python-adapters/sqlite/tests diff --git a/bindings/fixtures/gateway/independent-mutation-differential-report.json b/bindings/fixtures/gateway/independent-mutation-differential-report.json new file mode 100644 index 000000000..4eff0b4d2 --- /dev/null +++ b/bindings/fixtures/gateway/independent-mutation-differential-report.json @@ -0,0 +1,399 @@ +{ + "families": [ + { + "family": "airtable-record-update-v1", + "independent_entry_guards": null, + "observations": [ + { + "name": "exact", + "native": "echo-linked", + "reference_code": null, + "reference_complete_domain_witness": true + }, + { + "name": "wrong-value", + "native": "state-mismatch", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "wrong-echo", + "native": "echo-mismatch", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "null-echo", + "native": "state-match", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "different-resource", + "native": "echo-linked", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "duplicate-member", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "malformed", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "nonfinite", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "over-limit", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + } + ], + "recovery": { + "contract": "same known record can be read without a write response", + "native_capability": { + "class": "linked", + "declared_idempotency_retention_seconds": null, + "pre_entry_reread": false, + "provider_link": "verified", + "state_locator": "verified", + "unknown_reobservation": true, + "write_is_conditional": false + }, + "native_with_response_target": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "native_without_response_target": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "reference_read_paths": [ + "/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001" + ] + }, + "requests": [ + { + "contract": "both-refuse", + "name": "wrong-namespace", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.recipe-binding" + }, + { + "contract": "both-refuse", + "name": "wrong-recipe", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.recipe-binding" + }, + { + "contract": "both-refuse", + "name": "extra-field", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.closed-fields" + }, + { + "contract": "both-refuse", + "name": "empty-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.text-bound" + }, + { + "contract": "both-refuse", + "name": "long-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.text-bound" + }, + { + "contract": "both-refuse", + "name": "missing-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.closed-fields" + }, + { + "contract": "equal-request", + "name": "baseline", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "equal-request", + "name": "other-operation", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "reference-pool-refuses", + "name": "unowned-resource", + "native_accepted": true, + "reference_accepted": false, + "reference_code": "qualification.reference.resource-binding" + }, + { + "contract": "equal-request", + "name": "other-value", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "both-refuse", + "name": "invalid-value", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.replacement" + }, + { + "contract": "both-refuse", + "name": "wrong-value-type", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.replacement" + } + ] + }, + { + "family": "stripe-platform-refund-v1", + "independent_entry_guards": { + "baseline": null, + "maximum-amount": "gateway.relative-ceiling.above", + "other-currency": "gateway.relative-ceiling.binding-mismatch" + }, + "observations": [ + { + "name": "exact", + "native": "echo-linked", + "reference_code": null, + "reference_complete_domain_witness": true + }, + { + "name": "wrong-value", + "native": "state-mismatch", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "wrong-echo", + "native": "echo-mismatch", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "null-echo", + "native": "state-match", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "different-resource", + "native": "echo-linked", + "reference_code": null, + "reference_complete_domain_witness": true + }, + { + "name": "duplicate-member", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "malformed", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "nonfinite", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "over-limit", + "native": "unavailable", + "reference_code": "qualification.fresh.invalid-json", + "reference_complete_domain_witness": false + }, + { + "name": "pending-refund", + "native": "echo-linked", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "other-payment", + "native": "echo-linked", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "other-currency", + "native": "echo-linked", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + }, + { + "name": "live-refund", + "native": "echo-linked", + "reference_code": "qualification.fresh.state-mismatch", + "reference_complete_domain_witness": false + } + ], + "recovery": { + "contract": "native needs its recorded response locator; independent reference discovers one refund from an action-bound bounded listing; discovery is not a native recovery permit", + "native_capability": { + "class": "linked-after-response", + "declared_idempotency_retention_seconds": 86400, + "pre_entry_reread": false, + "provider_link": "response", + "state_locator": "response", + "unknown_reobservation": false, + "write_is_conditional": false + }, + "native_with_response_target": "https://api.stripe.com/v1/refunds/re_TEST123", + "native_without_response_target": null, + "reference_read_paths": [ + "/v1/refunds?payment_intent=pi_TEST123&limit=100", + "/v1/refunds/re_TEST123" + ] + }, + "requests": [ + { + "contract": "both-refuse", + "name": "wrong-namespace", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.recipe-binding" + }, + { + "contract": "both-refuse", + "name": "wrong-recipe", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.recipe-binding" + }, + { + "contract": "both-refuse", + "name": "extra-field", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.closed-fields" + }, + { + "contract": "both-refuse", + "name": "empty-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.text-bound" + }, + { + "contract": "both-refuse", + "name": "long-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.text-bound" + }, + { + "contract": "both-refuse", + "name": "missing-operation", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.closed-fields" + }, + { + "contract": "equal-request", + "name": "baseline", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "equal-request", + "name": "other-operation", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "reference-pool-refuses", + "name": "unowned-resource", + "native_accepted": true, + "reference_accepted": false, + "reference_code": "qualification.reference.resource-binding" + }, + { + "contract": "equal-request", + "name": "minimum-amount", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "equal-request", + "name": "maximum-amount", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "equal-request", + "name": "other-currency", + "native_accepted": true, + "reference_accepted": true, + "reference_code": null + }, + { + "contract": "both-refuse", + "name": "zero-amount", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.integer-bound" + }, + { + "contract": "both-refuse", + "name": "negative-amount", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.integer-bound" + }, + { + "contract": "both-refuse", + "name": "boolean-amount", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.integer-bound" + }, + { + "contract": "both-refuse", + "name": "over-grant-ceiling", + "native_accepted": false, + "reference_accepted": false, + "reference_code": "qualification.reference.ceiling" + } + ] + } + ], + "native_corpus_sha256": "5bf9583f6bee226f243e34c0e125b6f179370de53d5a76c36b76203e20947c26", + "schema": "auths.ap074-independent-mutation-differential/1", + "scope": "test-only native verified compilation and response classification compared with retained independent references; no admission, provider I/O, production qualification or AP070 guarantee", + "source_sha256": { + "product/runtime/auths-gateway/src/native_differential_tests.rs": "65d5ed32c660d2e25c503417ada142bfd8b550f449fe1c21c35f5afe556ade2b", + "qualification/reference/airtable_record.py": "d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa", + "qualification/reference/ap074_differential.py": "08684a044c2d46b43f3ee8c27c901430de5ddac1fca892cdde384e0abb6fa866", + "qualification/reference/common.py": "604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce", + "qualification/reference/fresh_evidence.py": "cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f", + "qualification/reference/provider_readback.py": "d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2", + "qualification/reference/stripe_platform.py": "2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec" + } +} diff --git a/bindings/fixtures/gateway/native-independent-mutation-differential.json b/bindings/fixtures/gateway/native-independent-mutation-differential.json new file mode 100644 index 000000000..fc2aa4ec2 --- /dev/null +++ b/bindings/fixtures/gateway/native-independent-mutation-differential.json @@ -0,0 +1,766 @@ +{ + "schema": "auths.ap074-native-mutation-differential/1", + "scope": "native signed authorization, bound effect, approval, closed request and response classification; no admission or I/O", + "families": [ + { + "family": "airtable-record-update-v1", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "resources": { + "schema": "auths.airtable-record-qualification-resources/1", + "protected_run": "ap074-independent-differential", + "base": "appQD3Qf0YFBCW9bV", + "table": "tblBx2jwe0IsPYRKT", + "records": [ + { + "id": "recTEST0000000001", + "run_metadata": "ap074-independent-differential" + } + ] + }, + "cases": [ + { + "name": "baseline", + "contract": "equal-request", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": true, + "action_commitment": "66f58a580076258123d0aed9be63ebe8087fa1687b45822f54b2ee620906a87f", + "effect_id": "5f98943a2e3228a3e4917c9b78f1083f9a0b5999844e80075a8f605171c6c71d", + "request": { + "method": "PATCH", + "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "content_type": "application/json", + "body": "{\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "headers": [], + "idempotency_key": null + } + }, + { + "name": "other-operation", + "contract": "equal-request", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-2", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": true, + "action_commitment": "39e92faea5b0ab1b149d3960897bcd767e7609229a9699bd05b7c0a9e89cba81", + "effect_id": "1402dec6c48b0566e052a45b4d57b76900468a6a1013186e866fdf536a0ac5fb", + "request": { + "method": "PATCH", + "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "content_type": "application/json", + "body": "{\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-e6411277d2a3b39d6a829697d9c43b957900496af7c601f1a79ea5ecee73c1f5\"}}", + "headers": [], + "idempotency_key": null + } + }, + { + "name": "wrong-namespace", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "other", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "wrong-recipe", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "0000000000000000000000000000000000000000000000000000000000000000", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "extra-field", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Approved", + "unreviewed": true + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "empty-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "long-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + "record_id": "recTEST0000000001", + "replacement": "Approved" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "other-value", + "contract": "equal-request", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Pending" + }, + "native_accepted": true, + "action_commitment": "242d5ec4433731ba499ce0817cd313059a151268be3441fb29d37e886518ca53", + "effect_id": "a3d84a833afcd6dbd2360777ba94100bcbfa822f7c9022c89ce683a1246d2852", + "request": { + "method": "PATCH", + "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "content_type": "application/json", + "body": "{\"fields\":{\"DemoStatus\":\"Pending\",\"auths_echo\":\"auths-e1-f39b0e96ca5722bda5932f2cde32e0cf311bc2a4ba6f8aebaa6dea4a85eafe1d\"}}", + "headers": [], + "idempotency_key": null + } + }, + { + "name": "invalid-value", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": "Deleted" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "wrong-value-type", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recTEST0000000001", + "replacement": true + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "unowned-resource", + "contract": "reference-pool-refuses", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "operation_id": "differential-1", + "record_id": "recOTHER000000001", + "replacement": "Approved" + }, + "native_accepted": true, + "action_commitment": "00a098319fe0bd89dfcc0a0b59f35e66e10bce49646a5b8194f083b4a359f65e", + "effect_id": "5d5324a5aa20adcfcda73d4943f4bca88bb40b0c917f3f2dbf402284eb499436", + "request": { + "method": "PATCH", + "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recOTHER000000001", + "content_type": "application/json", + "body": "{\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d786ad3dbf8a0be990e97a9e615f81843c5211c30565a6e692108454b2a080\"}}", + "headers": [], + "idempotency_key": null + } + }, + { + "name": "missing-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "airtable-demo", + "recipe_digest": "09f2ef1441edd6808b78ea8dc7237dd0f14e7056999cec553a0c8f6fe9a99307", + "replacement": "Approved", + "record_id": "recTEST0000000001" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + } + ], + "observations": [ + { + "name": "exact", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "native": "echo-linked" + }, + { + "name": "wrong-value", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":0,\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "native": "state-mismatch" + }, + { + "name": "wrong-echo", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"unrelated\"}}", + "native": "echo-mismatch" + }, + { + "name": "null-echo", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":null}}", + "native": "state-match" + }, + { + "name": "different-resource", + "response": "{\"id\":\"re_OTHER123\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "native": "echo-linked" + }, + { + "name": "duplicate-member", + "response": "{\"id\":\"one\",\"id\":\"two\"}", + "native": "unavailable" + }, + { + "name": "malformed", + "response": "{", + "native": "unavailable" + }, + { + "name": "nonfinite", + "response": "{\"amount\":NaN}", + "native": "unavailable" + }, + { + "name": "over-limit", + "response": " ", + "native": "unavailable" + } + ], + "recovery": { + "without_write_response_url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "with_write_response_url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", + "dot_segment_response_locator_refused": true, + "separator_response_locator_url": null, + "capability": { + "class": "linked", + "state_locator": "verified", + "provider_link": "verified", + "unknown_reobservation": true, + "declared_idempotency_retention_seconds": null, + "pre_entry_reread": false, + "write_is_conditional": false + } + } + }, + { + "family": "stripe-platform-refund-v1", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "resources": { + "schema": "auths.stripe-platform-qualification-resources/1", + "protected_run": "ap074-independent-differential", + "platform": "acct_TEST123", + "payments": [ + { + "id": "pi_TEST123", + "amount_received": 2000, + "currency": "usd", + "livemode": false, + "run_metadata": "ap074-independent-differential" + } + ] + }, + "cases": [ + { + "name": "baseline", + "contract": "equal-request", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": true, + "action_commitment": "a48e849c7bf68005ca5ddae4f85e4606edf94ecb84b06b59d29aedae31bb2eb6", + "effect_id": "0f98ac340142839f4f75718ce23cace9d794382ecd20774096ad6100c10da5b6", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=1000&metadata%5Bauths_echo%5D=auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5&payment_intent=pi_TEST123", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + ] + ], + "idempotency_key": "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + } + }, + { + "name": "other-operation", + "contract": "equal-request", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-2", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": true, + "action_commitment": "28a7460889975f09f92c7b70270433b895fd71347868d2491fc1d1c6ab8fc9d1", + "effect_id": "ddf1e8f9ad3fb48dabfea3d09254cb9624277762fb8e41d7c7f3c6a6a1711aa1", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=1000&metadata%5Bauths_echo%5D=auths-e1-956164018784dd5360359e9065469f21cef7cfaa4a7564ce4199b4cdf9de8e98&payment_intent=pi_TEST123", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-4ab0c6f7e4e5cf3207644b2cd5067fca82849a274f14ab6240311bfab491840d" + ] + ], + "idempotency_key": "auths-i1-4ab0c6f7e4e5cf3207644b2cd5067fca82849a274f14ab6240311bfab491840d" + } + }, + { + "name": "wrong-namespace", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "other", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "wrong-recipe", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "0000000000000000000000000000000000000000000000000000000000000000", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "extra-field", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd", + "unreviewed": true + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "empty-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "long-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "minimum-amount", + "contract": "equal-request", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1, + "currency": "usd" + }, + "native_accepted": true, + "action_commitment": "2e112296fad14010df8203d13a6947493c2fbcebfd1857180558671ff435048b", + "effect_id": "9cde1e05aea4849c8b57aa2bcc88b8ec130e595cede5f70449f604352efa332c", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=1&metadata%5Bauths_echo%5D=auths-e1-96abcdbce6502a2d66afd33a5e0f6d1b8e0b61ecc5070bfb095a3af59ebda750&payment_intent=pi_TEST123", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + ] + ], + "idempotency_key": "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + } + }, + { + "name": "maximum-amount", + "contract": "equal-request", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 10000, + "currency": "usd" + }, + "native_accepted": true, + "action_commitment": "d6b9319f1bca77084049edd604e007786362b2b9321193dd6dd82eec2bceb19f", + "effect_id": "b7dc642d7e76d0486ead39a2f7320d1b851d2d2e07cea3b6acb84c1ea1e869a4", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=10000&metadata%5Bauths_echo%5D=auths-e1-de7b5a2eaf54bb774648d466b6dcdcc83d7978649fd0423d644041b5f1dee3a4&payment_intent=pi_TEST123", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + ] + ], + "idempotency_key": "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + } + }, + { + "name": "other-currency", + "contract": "equal-request", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 1000, + "currency": "eur" + }, + "native_accepted": true, + "action_commitment": "7d20d9a26aca455a9533ce4d7638fef508cec323578db89772d05641edc3a1fa", + "effect_id": "51f5b71f4d573dfbbb4cd5955cae945461b5818930fb70261f121bbdae22afee", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=1000&metadata%5Bauths_echo%5D=auths-e1-a4515cb008893feba8e0c9b054d091b7dd7d21ba81b7dc6c2b64a0f86369d22c&payment_intent=pi_TEST123", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + ] + ], + "idempotency_key": "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + } + }, + { + "name": "zero-amount", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 0, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + }, + { + "name": "negative-amount", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": -1, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.policy.argument-unavailable" + } + }, + { + "name": "boolean-amount", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": true, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.policy.argument-unavailable" + } + }, + { + "name": "over-grant-ceiling", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_TEST123", + "amount": 10001, + "currency": "usd" + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.policy.above-ceiling" + } + }, + { + "name": "unowned-resource", + "contract": "reference-pool-refuses", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "operation_id": "differential-1", + "payment_intent": "pi_OTHER", + "amount": 1000, + "currency": "usd" + }, + "native_accepted": true, + "action_commitment": "37175b71d9b0df38bf46ebf96ecdd5b761295b7d08f5a24e6ee3d7ee6706aa67", + "effect_id": "74de469548c6e5a3ebb5b1598a977a8d33e079203f879b2e91b255adf6c261dc", + "request": { + "method": "POST", + "url": "https://api.stripe.com/v1/refunds", + "content_type": "application/x-www-form-urlencoded", + "body": "amount=1000&metadata%5Bauths_echo%5D=auths-e1-10112f4ae4b0e07f547513fde48845bdee6c06c82d8b6885f218349382f45a33&payment_intent=pi_OTHER", + "headers": [ + [ + "Stripe-Version", + "2025-03-31.basil" + ], + [ + "Idempotency-Key", + "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + ] + ], + "idempotency_key": "auths-i1-6a00004b8dfbec9f03af24e555e51e452c0eb1a156c0e780d66be3d57d555730" + } + }, + { + "name": "missing-operation", + "contract": "both-refuse", + "arguments": { + "operator_namespace": "stripe-platform-refunds", + "recipe_digest": "8927c857adafbbb4231827c68c6e8dd828c08e6dba0f4fe1585fcafa3e672a9a", + "currency": "usd", + "payment_intent": "pi_TEST123", + "amount": 1000 + }, + "native_accepted": false, + "native_result": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + } + } + ], + "observations": [ + { + "name": "exact", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "wrong-value", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":0,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "state-mismatch" + }, + { + "name": "wrong-echo", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"unrelated\"}}", + "native": "echo-mismatch" + }, + { + "name": "null-echo", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":null}}", + "native": "state-match" + }, + { + "name": "different-resource", + "response": "{\"id\":\"re_OTHER123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "pending-refund", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"pending\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "other-payment", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_OTHER\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "other-currency", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"eur\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "live-refund", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":true,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "native": "echo-linked" + }, + { + "name": "duplicate-member", + "response": "{\"id\":\"one\",\"id\":\"two\"}", + "native": "unavailable" + }, + { + "name": "malformed", + "response": "{", + "native": "unavailable" + }, + { + "name": "nonfinite", + "response": "{\"amount\":NaN}", + "native": "unavailable" + }, + { + "name": "over-limit", + "response": " ", + "native": "unavailable" + } + ], + "recovery": { + "without_write_response_url": null, + "with_write_response_url": "https://api.stripe.com/v1/refunds/re_TEST123", + "dot_segment_response_locator_refused": true, + "separator_response_locator_url": "https://api.stripe.com/v1/refunds/..%2Fother", + "capability": { + "class": "linked-after-response", + "state_locator": "response", + "provider_link": "response", + "unknown_reobservation": false, + "declared_idempotency_retention_seconds": 86400, + "pre_entry_reread": false, + "write_is_conditional": false + } + } + } + ] +} diff --git a/compliance.toml b/compliance.toml index 29d3e5596..3cf663c02 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1694,6 +1694,8 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/recipe/tests.rs#credential_reads_are_fixed_and_carry_no_action_value", "product/runtime/auths-gateway/src/recipe/tests.rs#construction_leaf_matches_the_serde_oracle_on_json_bodies", "product/runtime/auths-gateway/src/recipe/tests.rs#construction_leaf_matches_the_serde_oracle_on_form_bodies", + "product/runtime/auths-gateway/src/native_differential_tests.rs#native_independent_mutation_differential_fixture_is_current", + "qualification/reference/tests/test_ap074_differential.py#test_comparator_rejects_request_response_inventory_and_recovery_drift", "product/runtime/auths-gateway/src/pending_vectors/recipes.rs#every_base_compiles_to_its_documented_class_and_digest", "product/runtime/auths-gateway/src/pending_vectors/recipes.rs#every_hostile_case_fails_with_its_code", ] diff --git a/docs/plans/0074-differential-contracts.md b/docs/plans/0074-differential-contracts.md new file mode 100644 index 000000000..5e0c62dbd --- /dev/null +++ b/docs/plans/0074-differential-contracts.md @@ -0,0 +1,72 @@ +# AP074 independent differential contracts + +A19 requires both mutation and acquisition/disclosure comparisons. This file +records the exact overlap and differences; neither independent reference becomes +a managed execution path. The acceptance row remains partial until all required +comparisons and exact-head hosted execution exist. + +## Mutation corpus + +`native_differential_tests.rs` compiles the maintained Airtable record-update and +Stripe platform-refund recipes. The Airtable fixed base/table substitution is +the same reviewed, pure expansion permitted by the independent reference. No +network request is sent to those resources. Each request case has an actually +signed native grant/action/proof, ordinary verification, and either a refusal or +an immutable bound effect. Successful cases also obtain and revalidate a real +exact-effect approval signed by public fixed test keys. There is no admission, +entry permit, credential, provider execution or human-presence claim. + +The retained native corpus has 28 request cases and 22 response cases across +the two families. `qualification/reference/ap074_differential.py` calls the +unchanged `airtable_record.py`, `stripe_platform.py`, `fresh_evidence.py` and +`provider_readback.py`; the references never import the gateway implementation +or this comparator. Every case name/count is required, including duplicate and +omission refusal. A negative comparator test mutates request bytes, native +decisions, case inventory, observations, recovery targets and resource scope. + +| Contract | Comparison and limits | +| --- | --- | +| Request equality | Exact method, URL, body bytes, content type, ordered noncredential headers, echo and idempotency key agree for all shared positive inputs. | +| Shared refusal | Missing/extra fields, wrong namespace/recipe, operation limits, invalid values and signed amount-ceiling violations refuse on both sides. Refusal codes are retained separately: reference input validation and native authorization occur at different stages. | +| Resource scope | The independent qualification pool refuses an otherwise well-shaped unowned resource. A native grant/recipe can authorize that resource without knowing the qualification pool. These expected differences are required assertions, not accepted unexplained drift. | +| Provider guard | Native compilation is not the separately fenced fresh provider-read decision. Independent Stripe guards separately demonstrate the exact 50 percent ceiling and currency binding; this corpus does not claim to execute the native live guard. | +| Observation | Exact expected value plus exact declared echo links the generic native observation. Wrong value/echo and unavailable JSON retain distinct facts. Duplicate members, malformed/nonfinite JSON and over-limit responses never become a definitive observation. | +| Full domain witness | Independent references additionally check the record identity or refund payment, status, currency and live-mode facts. A generic recipe that projects one value and echo does not acquire those extra domain predicates. Missing echo can be native state equality while the full independent witness refuses. | +| Refund identity | The independent Stripe reference discovers a refund by its action-bound echo. A different safe refund ID alone does not invalidate that witness. It never trusts an application-supplied refund locator. | +| Recovery capability | Airtable has a verified record locator before any write response. Stripe's native response-derived locator is unavailable without the recorded response; a declared idempotency key cannot recreate it or confer a new entry permit. The independent reference can instead find exactly one action-bound refund in its own bounded listing. That discovery is an intentionally different test-only capability, not a native recovery grant. | +| Path closure | Native response locator extraction refuses a bare dot segment. A slash inside a value stays percent-encoded within one closed segment. The reference's refund identifier grammar is narrower. | + +The source-contract Python workflow first executes the native generator with +fixture updates disabled, then executes the independent comparison and retains +both artifacts. The report hashes the exact native corpus and relevant source +files. A checked-in report alone is not fresh execution evidence. Required +hosted results must identify the actual tested source/PR-merge revision and run. + +## Acquisition/disclosure boundary still to implement + +AP070 remains an independently implemented application-owned Python/SQLite +reference. Its admission and release behavior may be compared on a precisely +named post-authorization contract without rewriting its source or supplying it +managed credentials or entry permits. It is not yet included in the mutation +corpus above. + +Comparisons must preserve these differences: + +- Native acquisition response and separate recipient ACK are distinct facts. + AP070's transactional release commitment has no authenticated recipient ACK + protocol and cannot be relabeled as one. +- Native replay may return retained historical facts. AP070 can refuse a + repeated challenge. The shared property is no new external entry or charge; + equality of public result codes is not required across those contracts. +- AP070 task-lifetime content ceilings and metadata-plus-content provider byte + reservations differ from native fixed-window response ceilings and separate + disclosure byte allocations. Preserve raw values and named units; do not + force unlike quantities into equal totals. +- A native durable multi-process/adapter guarantee cannot be inferred from + AP070's application runtime lock or SQLite demonstration. + +Future comparisons must execute the unchanged reference, pair it with actual +native file/PostgreSQL histories, and establish conservation, revocation before +release, crash/reopen and no automatic repeated disclosure within the overlap. +All remaining A19 requirements stay open until that evidence exists. No managed +guarantee is claimed for AP070. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 02d2e48bd..0f9f4b3f0 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2656,6 +2656,54 @@ closure regeneration passed after that correction (one artifact-generation test) and owner UI `37a218c9` remain outside this older-head evidence and require fresh exact-head hosted verification. Complete AP074 acceptance remains open. +## Independent mutation differential checkpoint + +This batch starts from published `cb1ee6d15a8f728b2f6f9ce01021de69b67ac966`. +It changes test-only native authoring/comparison, fixtures, CI wiring and +documentation; no shipping authorization, admission, recovery, binding schema, +compiler identity, provider recipe or AP070 source is changed. + +- Native generator + `observed_tests::effect_native_tests::differential_tests::native_independent_mutation_differential_fixture_is_current` + verifies actual signed native grants/actions/proofs and exact effect approval. + Airtable uses the independently reviewed fixed base/table pure expansion; + Stripe uses the maintained guarded platform recipe and a signed bounded + amount/count/sum policy. No admission, custody or provider call occurs. +- The two-family native artifact has 28 request and 22 response cases. + Successful shared requests agree byte-for-byte with the unchanged independent + Airtable/Stripe mappings. Shared refusals, source-owned resource-pool limits, + fresh-guard versus compilation differences, full domain witness versus + generic observation, and distinct recovery locator capabilities have explicit + assertions. An injected read-only exchange runs each independent reference's + real discovery/read-back selection without a network or credential. +- The native capability projection explicitly retains response/verified locator, + provider link, unknown reobservation, declared idempotency retention and + nonconditional-write facts. A declared Stripe idempotency key cannot fabricate + its missing recorded-response locator. Reference discovery is not a native + permit. Full contracts and remaining gaps: + [0074-differential-contracts.md](0074-differential-contracts.md). +- Construction executed locally on this batch over the stated base: + `AUTHS_UPDATE_FIXTURES=1 cargo test --locked -p auths-gateway --features testkit-harness --lib observed_tests::effect_native_tests::differential_tests::native_independent_mutation_differential_fixture_is_current -- --exact` + passed one test, zero failed/ignored, 0.10 seconds after compilation. + `python3 qualification/reference/ap074_differential.py --update` constructs the + independently checked comparison report with native corpus and source hashes. + These are required artifact construction, not exact-head hosted qualification. +- Eight adversarial comparator mutations are authored (request bytes, decision, + omitted/duplicate cases, response claim, missing-response locator, resource + scope and recovery capability); that unit test is not yet executed. The + existing reference unittest workflow will execute it. The Python source-contract + workflow now first executes the native generator without updates, then the + independent comparator and uploads both artifacts. +- Semantic inventory construction advances freeze408 and only the reported + identity152/public-SDK149/public-surface408 entries. No formal source or + translation input was intentionally changed. New hosted execution remains + pending; the live cb1 CI/formal cohort is preserved while this batch is local. +- A19 remains partial. AP070 acquisition/disclosure comparisons, native durable + contract overlap, and final hosted evidence remain required. AP070's + transactional release is not a recipient ACK, its task-lifetime budgets are + not native fixed-window/disclosure units, and its runtime lock is not native + multi-host durability. No managed guarantee is claimed for that reference. + ## Phase gates | Phase | State | Outstanding gate | @@ -2692,7 +2740,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Pending / independent references retained / no complete differential corpus | Preserve AP070 reference independence; complete comparable native contracts without broker migration | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / two-family native signed/approved compilation and independent unchanged reference comparison / 28 request and 22 response cases constructed locally, explicit distinct recovery locator/link assertions | Acquisition/disclosure and durable contract comparisons plus exact-head hosted execution remain; AP070 source stays independent without managed guarantees | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index b4e17d35b..092a3643a 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -12,6 +12,10 @@ use ed25519_dalek::{Signer as _, SigningKey}; #[path = "effect_candidate_tests.rs"] mod candidate_tests; +#[cfg(feature = "testkit-harness")] +#[path = "native_differential_tests.rs"] +mod differential_tests; + #[path = "effect_disclosure_journal_tests.rs"] mod disclosure_journal_tests; diff --git a/product/runtime/auths-gateway/src/native_differential_tests.rs b/product/runtime/auths-gateway/src/native_differential_tests.rs new file mode 100644 index 000000000..3a6823de0 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_differential_tests.rs @@ -0,0 +1,394 @@ +//! Native side of the retained, independently implemented recipe comparison. +//! This produces verified compilation/observation facts, never provider evidence. + +use super::*; +use crate::harness::authoring::tool_fixture_in_window; +use crate::recipe::ReadBack; +use crate::{ArgumentCeilingPolicy, ListedValues}; + +const RUN: &str = "ap074-independent-differential"; + +#[derive(Clone, Copy)] +enum Family { + Airtable, + Stripe, +} + +impl Family { + fn recipe(self) -> CompiledRecipe { + let (source, lock) = match self { + Self::Airtable => ( + include_bytes!("../../../../bindings/fixtures/gateway/airtable/recipe.json") + .as_slice(), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json") + .as_slice(), + ), + Self::Stripe => ( + include_bytes!( + "../../../../qualification/simulation/live/stripe-platform/recipe.json" + ) + .as_slice(), + include_bytes!( + "../../../../qualification/simulation/live/stripe-platform/profile.lock.json" + ) + .as_slice(), + ), + }; + let mut source: Value = serde_json::from_slice(source).expect("recipe"); + if matches!(self, Self::Airtable) { + // Pure construction only: the independent reference pins this reviewed + // base/table. These bytes never reach a provider or a credential port. + for kind in ["write", "observation"] { + source[kind]["path"][1]["value"] = json!("appQD3Qf0YFBCW9bV"); + source[kind]["path"][2]["value"] = json!("tblBx2jwe0IsPYRKT"); + } + } + CompiledRecipe::compile(&serde_json::to_vec(&source).expect("source"), lock) + .expect("reviewed recipe") + } + + const fn name(self) -> &'static str { + match self { + Self::Airtable => "airtable-record-update-v1", + Self::Stripe => "stripe-platform-refund-v1", + } + } + + fn arguments(self, recipe: &CompiledRecipe) -> Value { + let mut arguments = json!({ + "operator_namespace": recipe.namespace().as_str(), + "recipe_digest": recipe.digest_hex(), "operation_id": "differential-1", + }); + match self { + Self::Airtable => { + arguments["record_id"] = json!("recTEST0000000001"); + arguments["replacement"] = json!("Approved"); + } + Self::Stripe => { + arguments["payment_intent"] = json!("pi_TEST123"); + arguments["amount"] = json!(1000); + arguments["currency"] = json!("usd"); + } + } + arguments + } + + fn resources(self) -> Value { + match self { + Self::Airtable => json!({ + "schema":"auths.airtable-record-qualification-resources/1", "protected_run":RUN, + "base":"appQD3Qf0YFBCW9bV", "table":"tblBx2jwe0IsPYRKT", + "records":[{"id":"recTEST0000000001", "run_metadata":RUN}], + }), + Self::Stripe => json!({ + "schema":"auths.stripe-platform-qualification-resources/1", "protected_run":RUN, + "platform":"acct_TEST123", "payments":[{"id":"pi_TEST123", + "amount_received":2000, "currency":"usd", "livemode":false, + "run_metadata":RUN}], + }), + } + } + + fn policy(self) -> Option { + matches!(self, Self::Stripe).then(|| { + ArgumentCeilingPolicy::new("amount", 10_000, 3600, 16) + .expect("bounded grant") + .with_sum( + 160_000, + Some(ListedValues::new("currency", &["usd", "eur"]).expect("partition")), + ) + .expect("sum") + }) + } +} + +fn mutations(family: Family, base: &Value) -> Vec<(&'static str, &'static str, Value)> { + let mut cases = vec![("baseline", "equal-request", base.clone())]; + let mut add = |name, contract, field: &str, value| { + let mut arguments = base.clone(); + arguments[field] = value; + cases.push((name, contract, arguments)); + }; + add( + "other-operation", + "equal-request", + "operation_id", + json!("differential-2"), + ); + add( + "wrong-namespace", + "both-refuse", + "operator_namespace", + json!("other"), + ); + add( + "wrong-recipe", + "both-refuse", + "recipe_digest", + json!("0".repeat(64)), + ); + add("extra-field", "both-refuse", "unreviewed", json!(true)); + add("empty-operation", "both-refuse", "operation_id", json!("")); + add( + "long-operation", + "both-refuse", + "operation_id", + json!("x".repeat(129)), + ); + match family { + Family::Airtable => { + add( + "other-value", + "equal-request", + "replacement", + json!("Pending"), + ); + add( + "invalid-value", + "both-refuse", + "replacement", + json!("Deleted"), + ); + add( + "wrong-value-type", + "both-refuse", + "replacement", + json!(true), + ); + add( + "unowned-resource", + "reference-pool-refuses", + "record_id", + json!("recOTHER000000001"), + ); + } + Family::Stripe => { + add("minimum-amount", "equal-request", "amount", json!(1)); + add("maximum-amount", "equal-request", "amount", json!(10_000)); + add("other-currency", "equal-request", "currency", json!("eur")); + add("zero-amount", "both-refuse", "amount", json!(0)); + add("negative-amount", "both-refuse", "amount", json!(-1)); + add("boolean-amount", "both-refuse", "amount", json!(true)); + add("over-grant-ceiling", "both-refuse", "amount", json!(10_001)); + add( + "unowned-resource", + "reference-pool-refuses", + "payment_intent", + json!("pi_OTHER"), + ); + } + } + let mut missing = base.clone(); + missing + .as_object_mut() + .expect("object") + .remove("operation_id"); + cases.push(("missing-operation", "both-refuse", missing)); + cases +} + +fn request_json(request: &crate::ClosedProviderRequest) -> Value { + json!({"method":request.method().as_str(), "url":request.url(), + "content_type":request.content_type(), + "body":std::str::from_utf8(request.body()).expect("body"), + "headers":request.headers().iter().map(|h| [h.name(), h.value()]).collect::>(), + "idempotency_key":request.idempotency_key()}) +} + +fn recovery_json(recipe: &CompiledRecipe) -> Value { + use crate::{LostClaimReentry, RecoveryClass, StateObservation, UnknownResolution}; + let capability = recipe.recovery().expect("mutation capability"); + let locator = |value| match value { + StateObservation::None => "none", + StateObservation::VerifiedLocator => "verified", + StateObservation::ResponseLocator => "response", + }; + let class = match capability.class { + RecoveryClass::Linked => "linked", + RecoveryClass::LinkedAfterResponse => "linked-after-response", + RecoveryClass::Observed => "observed", + RecoveryClass::Recorded => "recorded", + }; + let retention = match capability.lost_claim_reentry { + LostClaimReentry::None => None, + LostClaimReentry::Declared { + retention_seconds, .. + } => Some(retention_seconds), + }; + json!({"class":class, "state_locator":locator(capability.state_observation), + "provider_link":locator(capability.provider_link), + "unknown_reobservation":matches!(capability.unknown_resolution, UnknownResolution::GatewayReobservation), + "declared_idempotency_retention_seconds":retention, + "pre_entry_reread":capability.pre_entry_reread, + "write_is_conditional":capability.write_is_conditional}) +} + +fn response_cases(family: Family, request: &crate::ClosedProviderRequest) -> Vec { + let echo = request.echo_token().expect("declared echo"); + let original = match family { + Family::Airtable => json!({"id":"recTEST0000000001", "fields":{ + "DemoStatus":"Approved", "auths_echo":echo}}), + Family::Stripe => json!({"id":"re_TEST123", "object":"refund", "livemode":false, + "payment_intent":"pi_TEST123", "amount":1000, "currency":"usd", + "status":"succeeded", "metadata":{"auths_echo":echo}}), + }; + let template = request.observation_template().expect("template"); + let raw = serde_json::to_vec(&original).expect("response"); + let locator = template.extract_locator(&raw); + let observation = template + .request(locator.as_ref()) + .expect("closed observation"); + let mut inputs = vec![("exact", original.clone())]; + let (value_pointer, echo_pointer) = match family { + Family::Airtable => ("/fields/DemoStatus", "/fields/auths_echo"), + Family::Stripe => ("/amount", "/metadata/auths_echo"), + }; + for (name, pointer, replacement) in [ + ("wrong-value", value_pointer, json!(0)), + ("wrong-echo", echo_pointer, json!("unrelated")), + ("null-echo", echo_pointer, Value::Null), + ("different-resource", "/id", json!("re_OTHER123")), + ] { + let mut changed = original.clone(); + *changed.pointer_mut(pointer).expect("field") = replacement; + inputs.push((name, changed)); + } + if matches!(family, Family::Stripe) { + for (name, field, value) in [ + ("pending-refund", "status", json!("pending")), + ("other-payment", "payment_intent", json!("pi_OTHER")), + ("other-currency", "currency", json!("eur")), + ("live-refund", "livemode", json!(true)), + ] { + let mut changed = original.clone(); + changed[field] = value; + inputs.push((name, changed)); + } + } + let mut inputs: Vec<_> = inputs + .into_iter() + .map(|(name, value)| (name, serde_json::to_string(&value).expect("response JSON"))) + .collect(); + inputs.extend([ + ( + "duplicate-member", + "{\"id\":\"one\",\"id\":\"two\"}".to_owned(), + ), + ("malformed", "{".to_owned()), + ("nonfinite", "{\"amount\":NaN}".to_owned()), + ( + "over-limit", + " ".repeat(observation.maximum_response_bytes() + 1), + ), + ]); + inputs + .into_iter() + .map(|(name, raw)| { + let native = match observation.read_back(Some(echo), raw.as_bytes()) { + Some(ReadBack::EchoMatched) => "echo-linked", + Some(ReadBack::EchoMismatch) => "echo-mismatch", + Some(ReadBack::Value { matched: true }) => "state-match", + Some(ReadBack::Value { matched: false }) => "state-mismatch", + None => "unavailable", + }; + json!({"name":name, "response":raw, "native":native}) + }) + .collect() +} + +fn family_corpus(family: Family) -> Value { + let recipe = family.recipe(); + let key = SigningKey::from_bytes(&[29; 32]); + let policy = EffectPolicy::new("differential".to_owned(), 1, key.verifying_key().to_bytes()) + .expect("effect policy"); + let connection = connection(&recipe); + let ceiling = family.policy(); + let mut cases = Vec::new(); + let mut observations = Value::Null; + let mut recovery = Value::Null; + for (name, contract, arguments) in mutations(family, &family.arguments(&recipe)) { + let call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + arguments.as_object().expect("arguments").clone(), + ) + .expect("call"); + let signed = tool_fixture_in_window(&call, NOW, NOW - 3600, NOW + 3600, ceiling.as_ref()) + .expect("real signed native input"); + let context = auths_codec::decode_verifier_context(&signed.context).expect("trust"); + let installed = policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ); + let result = compile_mutation_effect(&installed, NOW, &signed.proof, &signed.action); + assert_eq!( + result.is_ok(), + contract != "both-refuse", + "{} {name}", + family.name() + ); + let mut row = json!({"name":name, "contract":contract, "arguments":arguments, + "native_accepted":result.is_ok()}); + match result { + Ok(effect) => { + let request = effect.private_request().expect("mutation request"); + row["action_commitment"] = json!(hex::encode(request.action_commitment())); + row["effect_id"] = json!(hex::encode(effect.binding().id().as_bytes())); + row["request"] = request_json(request); + // Approval signs the same immutable binding; no admission, + // credential or transport exists in this corpus. + let approval = effect.approval_request(NOW, NOW + 300).expect("request"); + let signature = key + .sign(&approval.signing_message().expect("message")) + .to_bytes(); + if name == "baseline" { + observations = json!(response_cases(family, request)); + let template = request.observation_template().expect("observation"); + let locator = template.extract_locator(b"{\"id\":\"re_TEST123\"}"); + let separator = template.extract_locator(b"{\"id\":\"../other\"}"); + recovery = json!({ + "without_write_response_url":template.request(None).map(|r| r.url().to_owned()), + "with_write_response_url":template.request(locator.as_ref()).map(|r| r.url().to_owned()), + "dot_segment_response_locator_refused":template.extract_locator(b"{\"id\":\"..\"}").is_none(), + "separator_response_locator_url":separator.as_ref().and_then(|value| template.request(Some(value))).map(|r| r.url().to_owned()), + "capability":recovery_json(&recipe), + }); + } + effect + .approve( + approval.with_signature(signature), + &key.verifying_key().to_bytes(), + NOW, + ) + .expect("native exact approval") + .validate_for_entry(&installed, NOW) + .expect("same verified effect"); + } + Err(error) => { + row["native_result"] = serde_json::to_value(error).expect("native refusal") + } + } + cases.push(row); + } + json!({"family":family.name(), "recipe_digest":recipe.digest_hex(), + "resources":family.resources(), "cases":cases, "observations":observations, + "recovery":recovery}) +} + +#[test] +fn native_independent_mutation_differential_fixture_is_current() { + let corpus = json!({"schema":"auths.ap074-native-mutation-differential/1", + "scope":"native signed authorization, bound effect, approval, closed request and response classification; no admission or I/O", + "families":[family_corpus(Family::Airtable), family_corpus(Family::Stripe)]}); + let mut bytes = serde_json::to_vec_pretty(&corpus).expect("corpus"); + bytes.push(b'\n'); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-independent-mutation-differential.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write corpus"); + } + assert_eq!(std::fs::read(path).expect("retained corpus"), bytes); +} diff --git a/qualification/reference/ap074_differential.py b/qualification/reference/ap074_differential.py new file mode 100644 index 000000000..a651c2969 --- /dev/null +++ b/qualification/reference/ap074_differential.py @@ -0,0 +1,241 @@ +"""Test-only AP074 comparisons against unchanged independent domain references. + +The native generator verifies real signed proofs and exact approvals. This +runner compares its closed outputs with the retained references; it cannot +authorize an operation, obtain a credential, or issue a managed receipt. +""" + +import argparse +import hashlib +import json +from pathlib import Path + +import airtable_record as airtable +import fresh_evidence +from common import Refusal, canonical, require, sha256 +from provider_readback import ReadBack +import stripe_platform as stripe + + +ROOT = Path(__file__).resolve().parents[2] +FIXTURES = ROOT / 'bindings/fixtures/gateway' +NATIVE = FIXTURES / 'native-independent-mutation-differential.json' +REPORT = FIXTURES / 'independent-mutation-differential-report.json' +REFERENCES = {airtable.FAMILY: airtable, stripe.FAMILY: stripe} + + +def request_cases(family): + cases = {name: 'both-refuse' for name in [ + 'wrong-namespace', 'wrong-recipe', 'extra-field', 'empty-operation', + 'long-operation', 'missing-operation', + ]} + cases.update({'baseline': 'equal-request', 'other-operation': 'equal-request', + 'unowned-resource': 'reference-pool-refuses'}) + if family == airtable.FAMILY: + cases.update({'other-value': 'equal-request', 'invalid-value': 'both-refuse', + 'wrong-value-type': 'both-refuse'}) + else: + cases.update({name: 'equal-request' for name in [ + 'minimum-amount', 'maximum-amount', 'other-currency', + ]}) + cases.update({name: 'both-refuse' for name in [ + 'zero-amount', 'negative-amount', 'boolean-amount', 'over-grant-ceiling', + ]}) + return cases + + +def indexed(rows, names): + require(type(rows) is list and len(rows) == len(names), + 'ap074.differential.case-count') + result = {row['name']: row for row in rows} + require(len(result) == len(rows) and set(result) == set(names), + 'ap074.differential.case-inventory') + return result + + +def reference_request(reference, row, resources, recipe_digest): + try: + result = reference.request(row['arguments'], resources, + row.get('action_commitment', '0' * 64), recipe_digest) + return result, None + except Refusal as error: + return None, str(error) + + +def compare_requests(family): + reference = REFERENCES[family['family']] + resources = reference.resources(family['resources'], 'ap074-independent-differential') + expected = request_cases(family['family']) + rows = indexed(family['cases'], expected) + compared = [] + for name, contract in expected.items(): + row = rows[name] + require(row['contract'] == contract + and row['native_accepted'] is (contract != 'both-refuse'), + 'ap074.differential.native-request-decision') + result, code = reference_request(reference, row, resources, family['recipe_digest']) + if contract == 'equal-request': + # Includes exact bytes, URL, ordered headers, echo and idempotency. + require(result == row['request'], 'ap074.differential.closed-request') + else: + require(result is None, 'ap074.differential.reference-refusal') + compared.append({'name': name, 'contract': contract, + 'native_accepted': row['native_accepted'], + 'reference_accepted': result is not None, 'reference_code': code}) + if reference is stripe: + # Encoding a closed request does not satisfy the separately fenced, + # fresh provider-read guard. Retain that distinction in the report. + guards = {name: stripe.entry_policy(rows[name]['arguments'], resources) + for name in ['baseline', 'maximum-amount', 'other-currency']} + require(guards == {'baseline': None, + 'maximum-amount': 'gateway.relative-ceiling.above', + 'other-currency': 'gateway.relative-ceiling.binding-mismatch'}, + 'ap074.differential.reference-guard') + else: + guards = None + return rows['baseline'], compared, guards + + +def compare_observations(family, baseline): + reference = REFERENCES[family['family']] + expected = {'exact': ('echo-linked', True), + 'wrong-value': ('state-mismatch', False), + 'wrong-echo': ('echo-mismatch', False), + 'null-echo': ('state-match', False), + 'different-resource': ('echo-linked', False), + 'duplicate-member': ('unavailable', False), + 'malformed': ('unavailable', False), + 'nonfinite': ('unavailable', False), + 'over-limit': ('unavailable', False)} + if reference is stripe: + # A refund is discovered by action-bound echo, rather than a caller's + # claimed refund ID. Another safe refund ID alone is not a mismatch. + expected['different-resource'] = ('echo-linked', True) + expected.update({name: ('echo-linked', False) for name in [ + 'pending-refund', 'other-payment', 'other-currency', 'live-refund', + ]}) + rows = indexed(family['observations'], expected) + compared = [] + for name, (native, accepted) in expected.items(): + row = rows[name] + require(row['native'] == native, 'ap074.differential.native-response') + try: + witness = fresh_evidence.witness(family['family'], baseline['arguments'], + family['resources'], baseline['action_commitment'], family['recipe_digest'], + row['response'].encode()) + actual, code = True, None + require(witness['response_sha256'] == sha256(row['response'].encode()), + 'ap074.differential.reference-response-digest') + except Refusal as error: + actual, code = False, str(error) + require(actual is accepted, 'ap074.differential.reference-response') + compared.append({'name': name, 'native': native, + 'reference_complete_domain_witness': actual, 'reference_code': code}) + return rows['exact']['response'].encode(), compared + + +def compare_recovery(family, baseline, response): + reference = REFERENCES[family['family']] + calls = [] + + def exchange(origin, method, path, key, *, headers): + require(method == 'GET' and key == 'public-test-only-no-credential', + 'ap074.differential.reference-read-only') + expected_origin = 'https://api.stripe.com' if reference is stripe else 'https://api.airtable.com' + expected_headers = {'Stripe-Version': '2025-03-31.basil'} if reference is stripe else {} + require(origin == expected_origin and headers == expected_headers, + 'ap074.differential.reference-read-binding') + calls.append(path) + if reference is stripe and len(calls) == 1: + require(path == '/v1/refunds?payment_intent=pi_TEST123&limit=100', + 'ap074.differential.reference-discovery-binding') + return 200, canonical({'data': [json.loads(response)], 'has_more': False}) + return 200, response + + reviewed = {'schema': 'auths.gateway-submission-review/1', 'actors': [], + 'action_commitment': baseline['action_commitment'], + 'arguments': baseline['arguments'], 'request': baseline['request']} + result = ReadBack(family['family'], family['resources'], + 'public-test-only-no-credential', exchange=exchange).fresh(reviewed, family['recipe_digest']) + require(result == response, 'ap074.differential.reference-read-bytes') + recovery = family['recovery'] + locator = 'response' if reference is stripe else 'verified' + require(recovery['capability'] == { + 'class': 'linked-after-response' if reference is stripe else 'linked', + 'state_locator': locator, 'provider_link': locator, + 'unknown_reobservation': reference is airtable, + 'declared_idempotency_retention_seconds': 86400 if reference is stripe else None, + 'pre_entry_reread': False, 'write_is_conditional': False, + }, 'ap074.differential.recovery-capability') + final_url = ('https://api.stripe.com' if reference is stripe else 'https://api.airtable.com') + calls[-1] + require(final_url == recovery['with_write_response_url'], + 'ap074.differential.closed-observation-url') + if reference is airtable: + require(len(calls) == 1 and recovery['without_write_response_url'] == final_url, + 'ap074.differential.verified-locator') + contract = 'same known record can be read without a write response' + else: + require(len(calls) == 2 and recovery['without_write_response_url'] is None + and recovery['dot_segment_response_locator_refused'] is True + and recovery['separator_response_locator_url'] == 'https://api.stripe.com/v1/refunds/..%2Fother', + 'ap074.differential.response-locator') + contract = ('native needs its recorded response locator; independent reference discovers ' + 'one refund from an action-bound bounded listing; discovery is not a native recovery permit') + return {'contract': contract, 'reference_read_paths': calls, + 'native_capability': recovery['capability'], + 'native_without_response_target': recovery['without_write_response_url'], + 'native_with_response_target': recovery['with_write_response_url']} + + +def compare(corpus): + require(corpus['schema'] == 'auths.ap074-native-mutation-differential/1' + and len(corpus['families']) == 2, + 'ap074.differential.native-schema') + require({family['family'] for family in corpus['families']} == set(REFERENCES), + 'ap074.differential.family-inventory') + families = [] + for family in corpus['families']: + baseline, requests, guards = compare_requests(family) + response, observations = compare_observations(family, baseline) + recovery = compare_recovery(family, baseline, response) + families.append({'family': family['family'], 'requests': requests, + 'observations': observations, 'independent_entry_guards': guards, + 'recovery': recovery}) + return families + + +def generate(native_path=NATIVE): + raw = native_path.read_bytes() + require(0 < len(raw) <= 2 * 1024 * 1024, 'ap074.differential.corpus-bound') + sources = ['qualification/reference/' + name for name in [ + 'airtable_record.py', 'stripe_platform.py', 'fresh_evidence.py', 'provider_readback.py', + 'common.py', 'ap074_differential.py', + ]] + sources.append('product/runtime/auths-gateway/src/native_differential_tests.rs') + return {'schema': 'auths.ap074-independent-mutation-differential/1', + 'scope': 'test-only native verified compilation and response classification compared with retained independent references; no admission, provider I/O, production qualification or AP070 guarantee', + 'native_corpus_sha256': hashlib.sha256(raw).hexdigest(), + 'source_sha256': {name: sha256((ROOT / name).read_bytes()) for name in sources}, + 'families': compare(json.loads(raw))} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--update', action='store_true', help='construct the retained comparison artifact') + parser.add_argument('--output', type=Path, help='also retain this execution report as a CI artifact') + args = parser.parse_args() + report = generate() + encoded = json.dumps(report, indent=2, sort_keys=True).encode() + b'\n' + if args.update: + REPORT.write_bytes(encoded) + require(REPORT.read_bytes() == encoded, 'ap074.differential.retained-report-drift') + if args.output: + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_bytes(encoded) + print(json.dumps({'schema': report['schema'], 'families': len(report['families']), + 'request_cases': sum(len(f['requests']) for f in report['families']), + 'response_cases': sum(len(f['observations']) for f in report['families'])})) + + +if __name__ == '__main__': + main() diff --git a/qualification/reference/tests/test_ap074_differential.py b/qualification/reference/tests/test_ap074_differential.py new file mode 100644 index 000000000..ca510b185 --- /dev/null +++ b/qualification/reference/tests/test_ap074_differential.py @@ -0,0 +1,51 @@ +"""The AP074 comparator must detect drift, missing cases and altered contracts.""" + +import copy +import json +from pathlib import Path +import sys +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +import ap074_differential as differential +from common import Refusal + + +class DifferentialContract(unittest.TestCase): + def test_comparator_rejects_request_response_inventory_and_recovery_drift(self): + original = json.loads(differential.NATIVE.read_bytes()) + + def request(value): + value['families'][0]['cases'][0]['request']['body'] += ' ' + + def decision(value): + value['families'][0]['cases'][2]['native_accepted'] = True + + def missing(value): + value['families'][0]['cases'].pop() + + def duplicated(value): + value['families'][0]['cases'][-1] = copy.deepcopy(value['families'][0]['cases'][0]) + + def response(value): + value['families'][0]['observations'][0]['native'] = 'state-match' + + def locator(value): + value['families'][1]['recovery']['without_write_response_url'] = 'https://api.stripe.com/v1/refunds/re_TEST123' + + def scope(value): + value['families'][0]['resources']['base'] = 'appOTHER' + + def capability(value): + value['families'][1]['recovery']['capability']['unknown_reobservation'] = True + + for mutate in [request, decision, missing, duplicated, response, locator, scope, capability]: + with self.subTest(mutation=mutate.__name__): + changed = copy.deepcopy(original) + mutate(changed) + with self.assertRaises(Refusal): + differential.compare(changed) + + +if __name__ == '__main__': + unittest.main() diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 87e053a76..1c09f36a1 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 407 +freeze_version = 408 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 407 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 151 +"auths.identity.protocol" = 152 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 407 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 148 +"auths.product.public-sdk-contract" = 149 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 407 +"auths.release.public-surface" = 408 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index fb06eb4e1..2e39f90b1 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 407, + "freezeVersion": 408, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 151, + "version": 152, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "c836df56e0071e3c352859075ff84cf3361d9eb4a8b5fb40d7fd823ac5efbe97" + "sha256": "4cdc3408a6e078404e07bdc8cc84ceee5c84a621cb5b617f5a333bc432ed6309" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 148, + "version": 149, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "83a319c6061d2dc631768c0560e2841c56da37fb3004d678d304cd9f3ffdb2b5" + "sha256": "2501dff8b2cab3d7e591e8f1180e13ed281ebfbb029e9947a1f0f70fd65db272" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 407, + "version": 408, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "0b82dab279a92e5e531372cbaf8e12eedf5d0814d755106ac55ae90609f8ff7f" + "sha256": "519182043829ee688dd62a9f8fa009108fd4469b020b15a15e54608a4b466576" } ] } From f5f3a8cacc9e4202e5e587817581e0d41f043811 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 17:00:35 +0000 Subject: [PATCH 091/136] test(gateway): compare independent read and release state histories --- .github/workflows/postgres-lifecycle.yml | 33 ++ compliance.toml | 1 + docs/plans/0074-differential-contracts.md | 46 ++- docs/plans/0074-implementation-status.md | 40 +- .../ap074_information_differential.py | 353 ++++++++++++++++++ .../test_ap074_information_differential.py | 38 ++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 8 files changed, 511 insertions(+), 22 deletions(-) create mode 100644 qualification/reference/ap074_information_differential.py create mode 100644 qualification/reference/tests/test_ap074_information_differential.py diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 3251369ca..6d6638092 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -7,6 +7,13 @@ on: - "product/runtime/auths-gateway/**" - "product/stores/auths-stores/**" - "bindings/fixtures/gateway/**" + - "qualification/reference/ap074_information_differential.py" + - "qualification/reference/common.py" + - "qualification/reference/tests/test_ap074_information_differential.py" + - "demos/google-employee-delegation/broker/src/employee_read_demo/admission.py" + - "demos/google-employee-delegation/broker/src/employee_read_demo/authority.py" + - "demos/google-employee-delegation/broker/src/employee_read_demo/contracts.py" + - "bindings/python/**" - ".github/workflows/postgres-lifecycle.yml" - "deployment/gateway/**" workflow_dispatch: @@ -39,6 +46,9 @@ jobs: AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt AUTHS_POSTGRES_SERVER_NAME: localhost run: | + set -o pipefail + mkdir -p target + { cargo test -p auths-gateway --lib -- --ignored postgres cargo test -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --exact native_content_process_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_process_tests::native_file_process_capacity_fixture_is_current @@ -63,6 +73,29 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres + } 2>&1 | tee target/ap074-native-adapter-evidence.log + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version: "3.12" + - name: Install this checkout's native Python SDK for the unchanged reference digest + run: | + python -m venv .ap074-reference-venv + .ap074-reference-venv/bin/python -m pip install maturin==1.9.6 + VIRTUAL_ENV="$PWD/.ap074-reference-venv" .ap074-reference-venv/bin/maturin develop --locked --manifest-path bindings/python/Cargo.toml + - name: Compare independent application state with freshly executed native adapter histories + run: >- + .ap074-reference-venv/bin/python qualification/reference/ap074_information_differential.py + --native-log target/ap074-native-adapter-evidence.log + --output target/ap074-independent-information-differential.json + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + if: always() + with: + name: ap074-information-differential-${{ github.run_id }}-${{ github.run_attempt }} + path: | + target/ap074-native-adapter-evidence.log + target/ap074-independent-information-differential.json + if-no-files-found: error + retention-days: 30 - name: Rehearse a physical backup and point-in-time restore run: deployment/gateway/tools/exercise-postgres-restore.sh - name: Stop fixture diff --git a/compliance.toml b/compliance.toml index 3cf663c02..1778a3f26 100644 --- a/compliance.toml +++ b/compliance.toml @@ -540,6 +540,7 @@ runtime-enforcement-boundary = [ "product/integrations/auths-git-signing/tests/cli_end_to_end.rs#delegated_agent_signs_headlessly_and_revocation_denies_it", ] stateful-replay-budget-component = [ + "qualification/reference/tests/test_ap074_information_differential.py#test_evidence_requires_each_actual_selector_and_one_pass_without_ignored_tests", "product/integrations/auths-git-signing/src/workflow_tests.rs#revocation_by_the_root_denies_the_revoked_grant", "product/integrations/auths-git-signing/src/workflow_tests.rs#invalid_revocations_fail_the_trust_instead_of_being_ignored", ] diff --git a/docs/plans/0074-differential-contracts.md b/docs/plans/0074-differential-contracts.md index 5e0c62dbd..3f613d32b 100644 --- a/docs/plans/0074-differential-contracts.md +++ b/docs/plans/0074-differential-contracts.md @@ -42,13 +42,40 @@ both artifacts. The report hashes the exact native corpus and relevant source files. A checked-in report alone is not fresh execution evidence. Required hosted results must identify the actual tested source/PR-merge revision and run. -## Acquisition/disclosure boundary still to implement +## Acquisition/disclosure comparison (authored; hosted execution pending) AP070 remains an independently implemented application-owned Python/SQLite -reference. Its admission and release behavior may be compared on a precisely -named post-authorization contract without rewriting its source or supplying it -managed credentials or entry permits. It is not yet included in the mutation -corpus above. +reference. `ap074_information_differential.py` executes its unchanged admission, +release and runtime-reopen code on a precisely named post-authorization contract. +Its synthetic `VerifiedRead` inputs use the existing reference unit-test boundary; +they do not prove authorization equivalence. Challenge body digests still call +the actual native SDK built from the same checkout; hashing is not stubbed or +reimplemented. No reference source, provider credential or managed permit is +changed or supplied. + +The authored corpus has three separate count/byte/both capacity races, with a +prefix admission and two independent SQLite worker processes contending for the +last unit. Closing in-flight work retains all conservative call, content, +provider-byte and two-GET attempt reservations. Four release gates cover current +state, task revocation, connection revocation and task expiry. Reopening refuses +the old claim and repeated release without additional charges. A further +positive release followed by connection revocation is paired with native +historical replay; retained facts cannot send again. A real SIGKILL after the +reference persists its first provider-attempt start proves that runtime reopen +marks the claim abandoned, frees only in-flight capacity and preserves charges. +No Google I/O is performed. + +The PostgreSQL lifecycle job retains the output of its existing native selectors +and then runs this comparator using the same checkout's installed native Python +SDK. It requires exactly one passing, nonignored execution for each of eight +file/PostgreSQL capacity, information replay, acquisition crash and disclosure +crash selectors before reading their natively regenerated-and-checked artifacts. +Missing, duplicated, ignored and zero-pass results refuse comparison; parser +controls use explicitly synthetic logs and make no runtime claim themselves. +The report records tested commit/run, native log/artifact hashes, unchanged +reference source hashes and 22 paired comparisons. This avoids rerunning the +native matrices merely to perform the independent comparison. The new runner +and parser test have not yet executed; the hosted report is required evidence. Comparisons must preserve these differences: @@ -65,8 +92,7 @@ Comparisons must preserve these differences: - A native durable multi-process/adapter guarantee cannot be inferred from AP070's application runtime lock or SQLite demonstration. -Future comparisons must execute the unchanged reference, pair it with actual -native file/PostgreSQL histories, and establish conservation, revocation before -release, crash/reopen and no automatic repeated disclosure within the overlap. -All remaining A19 requirements stay open until that evidence exists. No managed -guarantee is claimed for AP070. +Native current-authority gates and AP070 task expiry/revision are compared only +on the shared fail-closed state property; their authority models are different. +All remaining A19 requirements stay open until actual hosted execution and +coverage audit establish them. No managed guarantee is claimed for AP070. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 0f9f4b3f0..27c5671cb 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2704,6 +2704,44 @@ compiler identity, provider recipe or AP070 source is changed. not native fixed-window/disclosure units, and its runtime lock is not native multi-host durability. No managed guarantee is claimed for that reference. +## Independent information comparison source (hosted execution pending) + +After local mutation comparison commit `91552fa5`, authored +`qualification/reference/ap074_information_differential.py` without changing +any AP070 file. This executes the retained application-owned SQLite state +implementation at its existing synthetic post-authorization test boundary, +using the same-checkout installed native SDK only for the unchanged canonical +body-digest call. No Google call, managed credential/permit, reference migration +or authorization/ACK equivalence claim is made. + +- Three count/byte/both scenarios use an initial admission and two independent + SQLite worker processes racing for the last unit; failed/closed work retains + all conservative call, content, metadata/provider-byte and two-attempt charges. +- Four current/revoked/disconnected/expired release scenarios reopen state and + refuse repeat release/claim without refund. An additional successful release + followed by connection revocation provides the independent historical replay + comparison. The reference's release commitment stays distinct from ACK. +- A real worker SIGKILL occurs after durable claim and provider-attempt start; + runtime reopen must mark the old claim abandoned, free only in-flight slots, + preserve all charges and refuse old-claim entry/release. It performs no I/O + against Google or a managed provider port. +- The maintained PostgreSQL workflow preserves the output of the existing + native selector block without removing or repeating any of its tests. The + runner requires one actual pass, zero failed/ignored, for each of eight native + file/PostgreSQL capacity/replay/acquisition-crash/disclosure-crash selectors. + It checks their schemas and adapter identities, executes the reference, and + writes 22 paired comparisons with separate units, differing result meanings, + source/run/commit and artifact/log hashes. Synthetic log-parser controls + reject missing, duplicated, ignored and zero-pass executions. +- New information runner, parser test and workflow extension are authored, + **not executed locally or hosted yet**. Existing cb1 native matrices do not + establish that the new comparison ran. The mutation report construction is + separate evidence. A19 remains partial pending exact-head hosted execution + and a full coverage audit. See the differential contract document for limits. +- Required semantic inventory construction for this workflow/consumer extension + advances freeze409 and only its reported identity153/public-SDK150/ + public-surface409 entries; no shipping Rust or reference implementation changes. + ## Phase gates | Phase | State | Outstanding gate | @@ -2740,7 +2778,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / two-family native signed/approved compilation and independent unchanged reference comparison / 28 request and 22 response cases constructed locally, explicit distinct recovery locator/link assertions | Acquisition/disclosure and durable contract comparisons plus exact-head hosted execution remain; AP070 source stays independent without managed guarantees | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / mutation reference comparison constructed; 22 paired post-authorization information comparisons authored against unchanged AP070 and native file/PostgreSQL histories / 28 request and 22 response mutation cases constructed locally; information comparison unrun | Execute new independent information runner and parser controls plus exact-head hosted mutation corpus; complete coverage audit; AP070 source stays independent without managed guarantees | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | diff --git a/qualification/reference/ap074_information_differential.py b/qualification/reference/ap074_information_differential.py new file mode 100644 index 000000000..ce11c6fa7 --- /dev/null +++ b/qualification/reference/ap074_information_differential.py @@ -0,0 +1,353 @@ +"""Post-authorization state comparisons with unchanged AP070 application code. + +Run after the exact native file/PostgreSQL selectors in the same hosted job, +with that checkout's Python SDK installed. No Google or managed credential is +used. Synthetic VerifiedRead inputs delimit the claim: this does not compare +authorization proofs or turn AP070 release commitment into recipient ACK. +""" + +import argparse +import json +import multiprocessing +import os +from pathlib import Path +import re +import signal +import subprocess +import sys +import tempfile + +from common import require, sha256 + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / 'demos/google-employee-delegation/broker/src')) + +from employee_read_demo.admission import AdmissionDenied, AdmissionStore +from employee_read_demo.authority import VerifiedRead, native_body_digest +from employee_read_demo.contracts import MAX_METADATA_BYTES, TaskDescriptor + +NOW = 1_790_000_000 +MAXIMUM = 1024 +BODY = b'private-test-content!' +CHARGES = ['calls', 'provider_attempt_slots', 'charged_content_bytes', 'reserved_provider_bytes'] +SUITES = { + 'capacity': ('native_budget_tests', 'window_capacity', 'native-window-capacity', 'auths.native-window-capacity/1'), + 'replay': ('native_information_replay_tests', 'information_retained_replay', 'native-information-retained-replay', 'auths.native-information-retained-replay/1'), + 'acquisition-crash': ('native_crash_tests', 'process_crash', 'native-process-crash', 'auths.native-process-crash/1'), + 'disclosure-crash': ('native_disclosure_crash_tests', 'disclosure_process_crash', 'native-disclosure-process-crash', 'auths.native-disclosure-process-crash/1'), +} + + +def descriptor(limit='count-and-byte-sum'): + calls = 4 if limit == 'byte-sum' else 2 + total = 4096 if limit == 'count' else 2048 + return TaskDescriptor( + 'auths.google-read-task/v1', 'atlas-studio', 'customer-demo-01', 'a' * 64, + 'employee-principal', 'binding-1', 'agent-principal', 'atlas-drive', + 'connection-1', 1, ('file-A', 'file-B'), 'text', MAXIMUM, calls, total, + NOW - 1, NOW + 600, 'differential-task', 'Independent reference state comparison', + ) + + +def setup(path, task): + store = AdmissionStore(path) + store.register_connection(connection_id=task.connection_id, company=task.company_id, + employee=task.employee_principal, binding_ref=task.identity_binding_ref, generation=1) + store.enroll(task) + return store + + +def verified(task): + # Exactly the existing reference unit-test boundary: its caller has already + # verified authorization. This fixture supplies no managed authority/permit. + return VerifiedRead(task.calls()[0], b'x' * 32, 'authorized') + + +def challenge(store, task): + return store.issue_challenge(task, native_body_digest(task.calls()[0], task.service), now=NOW) + + +def snapshot(store, task, token=None): + with store._connect() as db: + row = db.execute('SELECT calls,attempts,charged_bytes,reserved_provider_bytes,in_flight ' + 'FROM tasks WHERE id=?', (task.task_id,)).fetchone() + state = None if token is None else db.execute( + 'SELECT status FROM challenges WHERE value=?', (token,)).fetchone()[0] + return {**dict(zip(CHARGES, row[:4])), 'in_flight': row[4], 'challenge_state': state} + + +def charges(snapshot_value): + return {key: snapshot_value[key] for key in CHARGES} + + +def denied(action): + try: + action() + except AdmissionDenied: + return True + return False + + +def claim_worker(path, task, token, start, output): + require(start.wait(10), 'ap074.reference.worker-start') + store = AdmissionStore(Path(path)) + try: + reservation = store.claim(task, verified(task), token, now=NOW) + except AdmissionDenied: + output.put(False) + else: + # Close only the in-flight slot; calls/bytes/attempt charges stay spent. + store.fail(reservation) + output.put(True) + + +def stop(processes): + for process in processes: + if process.is_alive(): + process.kill() + if process.pid is not None: + process.join(timeout=5) + + +def capacity_reference(limit): + task = descriptor(limit) + with tempfile.TemporaryDirectory(prefix='ap074-reference-capacity-') as directory: + path = Path(directory) / 'admission.sqlite3' + store = setup(path, task) + prefix = store.claim(task, verified(task), challenge(store, task), now=NOW) + store.fail(prefix) + tokens = [challenge(store, task) for _ in range(2)] + context = multiprocessing.get_context('spawn') + start, output = context.Event(), context.Queue() + workers = [context.Process(target=claim_worker, + args=(str(path), task, token, start, output)) for token in tokens] + try: + for worker in workers: + worker.start() + start.set() + for worker in workers: + worker.join(timeout=15) + require(worker.exitcode == 0, 'ap074.reference.capacity-worker') + winners = sum(output.get(timeout=3) for _ in workers) + finally: + stop(workers) + output.close() + require(winners == 1, 'ap074.reference.capacity-single-winner') + final = snapshot(AdmissionStore(path), task) + require(charges(final) == {'calls': 2, 'provider_attempt_slots': 4, + 'charged_content_bytes': 2048, + 'reserved_provider_bytes': 2 * (MAX_METADATA_BYTES + MAXIMUM + 2)}, + 'ap074.reference.capacity-charges') + require(final['in_flight'] == 0, 'ap074.reference.capacity-in-flight') + return {'limit': limit, 'prefix': 1, 'contenders': 2, 'final_winners': winners, + 'snapshot': final, 'provider_io_executed': False} + + +def release_reference(gate, *, disconnect_after_release=False): + task = descriptor() + with tempfile.TemporaryDirectory(prefix='ap074-reference-release-') as directory: + path = Path(directory) / 'admission.sqlite3' + store = setup(path, task) + token = challenge(store, task) + reservation = store.claim(task, verified(task), token, now=NOW) + before = snapshot(store, task, token) + at = NOW + if gate == 'task-revoked': + store.revoke(task.task_id) + elif gate == 'connection-revoked': + store.disconnect(task.connection_id) + elif gate == 'task-expired': + at = NOW + 601 + released = [] + try: + released.append(store.release(reservation, BODY, now=at)) + except AdmissionDenied: + pass + require(bool(released) is (gate == 'current'), 'ap074.reference.release-current-gate') + if disconnect_after_release: + require(gate == 'current', 'ap074.reference.replay-positive-control') + store.disconnect(task.connection_id) + reopened = AdmissionStore(path) + require(denied(lambda: reopened.release(reservation, BODY, now=at)) + and denied(lambda: reopened.claim(task, verified(task), token, now=at)), + 'ap074.reference.no-repeat-release-or-claim') + after = snapshot(reopened, task, token) + require(charges(before) == charges(after), 'ap074.reference.release-conservation') + return {'gate': gate, 'connection_revoked_after_release': disconnect_after_release, + 'returned_content_bytes': sum(map(len, released)), + 'before': before, 'after': after, + 'repeat_release_and_claim_refused': True, + 'recipient_ack_protocol': False, 'provider_io_executed': False} + + +def crash_worker(path, task, token, ready, hold): + store = AdmissionStore(Path(path)) + runtime = store.open_runtime() + reservation = store.claim(task, verified(task), token, now=NOW) + store.attempt_observer(reservation).begin(1, 'metadata') + ready.send(reservation) + require(hold.wait(30), 'ap074.reference.crash-worker-not-killed') + runtime.close() + + +def crash_reference(): + task = descriptor() + with tempfile.TemporaryDirectory(prefix='ap074-reference-crash-') as directory: + path = Path(directory) / 'admission.sqlite3' + store = setup(path, task) + token = challenge(store, task) + context = multiprocessing.get_context('spawn') + received, ready = context.Pipe(duplex=False) + worker = context.Process(target=crash_worker, + args=(str(path), task, token, ready, context.Event())) + worker.start() + ready.close() + try: + require(received.poll(15), 'ap074.reference.crash-ready') + reservation = received.recv() + before = snapshot(store, task, token) + worker.kill() + worker.join(timeout=5) + require(worker.exitcode == -signal.SIGKILL, 'ap074.reference.actual-sigkill') + finally: + stop([worker]) + received.close() + reopened = AdmissionStore(path) + runtime = reopened.open_runtime() + try: + require(runtime.abandoned_claims == 1, 'ap074.reference.abandoned-claim') + require(denied(lambda: reopened.claim(task, verified(task), token, now=NOW)) + and denied(lambda: reopened.release(reservation, BODY, now=NOW)), + 'ap074.reference.crash-no-reentry-or-release') + after = snapshot(reopened, task, token) + require(charges(before) == charges(after) + and after['in_flight'] == 0 and after['challenge_state'] == 'abandoned', + 'ap074.reference.crash-conservation') + with reopened._connect() as db: + attempt = db.execute('SELECT status FROM provider_attempts WHERE challenge=? ' + 'AND ordinal=1', (token,)).fetchone() + require(attempt == ('started',), 'ap074.reference.unknown-provider-attempt') + finally: + runtime.close() + return {'sigkill': True, 'before': before, 'after': after, + 'provider_attempt': 'started', 'old_claim_and_release_refused': True, + 'provider_io_executed': False} + + +def native_evidence(log): + require('AUTHS_UPDATE_FIXTURES' not in os.environ, 'ap074.differential.fixture-updates-forbidden') + require(0 < log.stat().st_size <= 8 * 1024 * 1024, 'ap074.differential.native-log-bound') + text = re.sub(r'\x1b\[[0-?]*[ -/]*[@-~]', '', log.read_text()) + result = {} + for adapter in ['file', 'postgres']: + result[adapter] = {} + for label, (module, suffix, stem, schema) in SUITES.items(): + function = ('native_file_' if adapter == 'file' else 'postgres_native_') + suffix + '_fixture_is_current' + selector = module + '::' + function + occurrences = list(re.finditer(r'^test ' + re.escape(selector) + r' \.\.\. ok$', text, re.M)) + require(len(occurrences) == 1, 'ap074.differential.native-selector-execution') + following = text[occurrences[0].end():] + outcome = re.search(r'test result: (.*)', following) + require(outcome is not None and outcome.group(1).startswith('ok. 1 passed; 0 failed; 0 ignored;'), + 'ap074.differential.native-selector-result') + path = ROOT / f'bindings/fixtures/gateway/{stem}-{adapter}.json' + raw = path.read_bytes() + value = json.loads(raw) + require(value['schema'] == schema and value['adapter'] == adapter, + 'ap074.differential.native-artifact-binding') + result[adapter][label] = {'selector': selector, 'sha256': sha256(raw), 'value': value} + return result + + +def one(rows, **fields): + matches = [row for row in rows if all(row.get(key) == value for key, value in fields.items())] + require(len(matches) == 1, 'ap074.differential.native-case-unique') + return matches[0] + + +def compare(native, reference): + pairs = [] + for adapter, artifacts in native.items(): + for ref in reference['capacity']: + case = one(artifacts['capacity']['value']['cases'], limit=ref['limit']) + require(case['prefix'] == ref['prefix'] and case['contenders'] == ref['contenders'] + and case['final_winners'] == ref['final_winners'] + and case['reserved_calls'] == ref['snapshot']['calls'] == 2 + and case['reserved_bytes'] == ref['snapshot']['charged_content_bytes'] == 2048 + and case['actual_http_reads'] == 2 + and case['reopened_replay_preserves_attempt_and_counter_bytes'] is True + and case['reopened_replay_leases_and_sends_nothing'] is True, + 'ap074.differential.capacity-conservation') + pairs.append({'adapter': adapter, 'contract': 'one final admission; charges conserved', + 'reference': ref, 'native': case, + 'units': 'same chosen numeric ceiling; native response bytes and reference content/provider bytes retain distinct meanings'}) + for ref in reference['release']: + gate = {'current': 'current', 'task-revoked': 'revoked', + 'connection-revoked': 'revoked', 'task-expired': 'authority-expired'}[ref['gate']] + case = one(artifacts['disclosure-crash']['value']['cases'], + pause='after-reservation-commit', current_gate=gate) + accepted = ref['gate'] == 'current' + require((case['final_history']['stage'] == 'acknowledged') is accepted + and case['continued_only_after_fresh_authorization'] is accepted + and case['replays_do_not_authenticate_or_redeliver'] is True + and case['source_allocation_calls'] == 1 + and case['source_allocation_bytes'] == ref['before']['charged_content_bytes'] == MAXIMUM, + 'ap074.differential.release-current-gate') + if not accepted: + require(case['original_recipient']['received_full'] is False + and case['final_history']['stage'] == 'reserved', + 'ap074.differential.release-no-delivery') + pairs.append({'adapter': adapter, 'contract': 'current state gate before release; no repeated release', + 'reference': ref, 'native': case, + 'difference': 'reference task expiry/revision versus native current authority/connection; reference release commitment is not native recipient ACK'}) + case = one(artifacts['acquisition-crash']['value']['cases'], pause='after-entry-commit') + require(case['after']['stage'] == 'unknown' + and case['provider_calls_at_kill'] == case['provider_calls_after_replays'] == 0 + and case['terminal_replays_leave_journal_and_boundary_counters_unchanged'] is True + and case['after']['reserved_calls'] == reference['crash']['after']['calls'] == 1 + and case['after']['reserved_bytes'] == reference['crash']['after']['charged_content_bytes'] == MAXIMUM, + 'ap074.differential.crash-no-reentry') + pairs.append({'adapter': adapter, 'contract': 'durable entry uncertainty retains charges and forbids old operation reentry', + 'reference': reference['crash'], 'native': case}) + for protocol in ['acquisition-response', 'disclosure-ack', 'disclosure-unknown']: + case = one(artifacts['replay']['value']['cases'], protocol=protocol, change='connection-revoked') + require(case['journal_and_execution_witness_unchanged'] is True + and case['no_replay_authentication_or_delivery'] is True + and case['changed_caller_target_refused'] is True, + 'ap074.differential.historical-replay-no-new-release') + pairs.append({'adapter': adapter, 'contract': 'historical replay does not deliver or charge again', + 'native': case, 'reference': reference['retained_replay'], + 'difference': 'native returns retained protocol facts; AP070 refuses a repeated challenge/release'}) + return pairs + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--native-log', required=True, type=Path) + parser.add_argument('--output', required=True, type=Path) + args = parser.parse_args() + native = native_evidence(args.native_log) + reference = {'capacity': [capacity_reference(limit) for limit in ['count', 'byte-sum', 'count-and-byte-sum']], + 'release': [release_reference(gate) for gate in ['current', 'task-revoked', 'connection-revoked', 'task-expired']], + 'retained_replay': release_reference('current', disconnect_after_release=True), + 'crash': crash_reference()} + sources = ['demos/google-employee-delegation/broker/src/employee_read_demo/' + name + for name in ['admission.py', 'authority.py', 'contracts.py']] + sources.append('qualification/reference/ap074_information_differential.py') + sources.append('qualification/reference/common.py') + report = {'schema': 'auths.ap074-independent-information-differential/1', + 'scope': 'post-authorization reference state only; actual SQLite workers/SIGKILL paired with freshly executed native file/TLS PostgreSQL histories; no AP070 managed, recipient ACK, full authorization equivalence or live Google claim', + 'source_commit': subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=ROOT, text=True).strip(), + 'run_id': os.environ.get('GITHUB_RUN_ID'), 'run_attempt': os.environ.get('GITHUB_RUN_ATTEMPT'), + 'native_log_sha256': sha256(args.native_log.read_bytes()), + 'sources_sha256': {name: sha256((ROOT / name).read_bytes()) for name in sources}, + 'native_execution': {adapter: {label: {key: artifact[key] for key in ['selector', 'sha256']} + for label, artifact in artifacts.items()} for adapter, artifacts in native.items()}, + 'pairs': compare(native, reference)} + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(report, sort_keys=True, indent=2) + '\n') + print(json.dumps({'schema': report['schema'], 'adapters': len(native), 'pairs': len(report['pairs'])})) + + +if __name__ == '__main__': + main() diff --git a/qualification/reference/tests/test_ap074_information_differential.py b/qualification/reference/tests/test_ap074_information_differential.py new file mode 100644 index 000000000..d691d499d --- /dev/null +++ b/qualification/reference/tests/test_ap074_information_differential.py @@ -0,0 +1,38 @@ +"""Synthetic log-parser controls; these do not establish native execution.""" + +from pathlib import Path +import sys +import tempfile +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +import ap074_information_differential as differential +from common import Refusal + + +class NativeEvidenceInventory(unittest.TestCase): + def test_evidence_requires_each_actual_selector_and_one_pass_without_ignored_tests(self): + selectors = [] + for adapter in ['file', 'postgres']: + for module, suffix, _stem, _schema in differential.SUITES.values(): + function = ('native_file_' if adapter == 'file' else 'postgres_native_') + suffix + '_fixture_is_current' + selectors.append(module + '::' + function) + records = [f'test {selector} ... ok\ntest result: ok. 1 passed; 0 failed; 0 ignored;\n' + for selector in selectors] + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / 'synthetic.log' + path.write_text(''.join(records)) + self.assertEqual(set(differential.native_evidence(path)), {'file', 'postgres'}) + altered = [records[1:], records + [records[0]], + [records[0].replace('1 passed', '0 passed'), *records[1:]], + [records[0].replace('0 ignored', '1 ignored'), *records[1:]], + [records[0].replace('... ok', '... ignored'), *records[1:]]] + for index, rows in enumerate(altered): + with self.subTest(alteration=index): + path.write_text(''.join(rows)) + with self.assertRaises(Refusal): + differential.native_evidence(path) + + +if __name__ == '__main__': + unittest.main() diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 1c09f36a1..dcc373676 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 408 +freeze_version = 409 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 408 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 152 +"auths.identity.protocol" = 153 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 408 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 149 +"auths.product.public-sdk-contract" = 150 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 408 +"auths.release.public-surface" = 409 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 2e39f90b1..9497d46b2 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 408, + "freezeVersion": 409, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 152, + "version": 153, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "4cdc3408a6e078404e07bdc8cc84ceee5c84a621cb5b617f5a333bc432ed6309" + "sha256": "cab906bb70abbacd4a904c1ff83d5e62e69f42fe8e219fe555f2a7c2b094c666" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 149, + "version": 150, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "2501dff8b2cab3d7e591e8f1180e13ed281ebfbb029e9947a1f0f70fd65db272" + "sha256": "0c859bf7d08c15cf009c8f14a2489b2f821c3d8ba5ce9df14af30e32e0139714" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 408, + "version": 409, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "519182043829ee688dd62a9f8fa009108fd4469b020b15a15e54608a4b466576" + "sha256": "bcdbb560cdafa93e0fba1ae1fdcd2b7ae9650d6087d2d50e92a3120b37ac7a93" } ] } From 5744894590341c43981e4cc07953d0a7aa340a7e Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 17:05:12 +0000 Subject: [PATCH 092/136] test(gateway): isolate valid response byte-limit boundaries --- ...ependent-mutation-differential-report.json | 130 ++++++++++++++---- ...ive-independent-mutation-differential.json | 76 +++++++++- docs/plans/0074-differential-contracts.md | 3 +- docs/plans/0074-implementation-status.md | 21 ++- .../src/native_differential_tests.rs | 23 +++- qualification/reference/ap074_differential.py | 20 ++- .../tests/test_ap074_differential.py | 6 +- 7 files changed, 238 insertions(+), 41 deletions(-) diff --git a/bindings/fixtures/gateway/independent-mutation-differential-report.json b/bindings/fixtures/gateway/independent-mutation-differential-report.json index 4eff0b4d2..a86607673 100644 --- a/bindings/fixtures/gateway/independent-mutation-differential-report.json +++ b/bindings/fixtures/gateway/independent-mutation-differential-report.json @@ -7,56 +7,90 @@ { "name": "exact", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": null, - "reference_complete_domain_witness": true + "reference_complete_domain_witness": true, + "response_bytes": 150 }, { "name": "wrong-value", "native": "state-mismatch", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 141 }, { "name": "wrong-echo", "native": "echo-mismatch", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 86 }, { "name": "null-echo", "native": "state-match", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 79 }, { "name": "different-resource", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 144 }, { "name": "duplicate-member", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 23 }, { "name": "malformed", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 1 }, { "name": "nonfinite", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 14 + }, + { + "name": "at-limit", + "native": "echo-linked", + "native_maximum_response_bytes": 16384, + "reference_code": null, + "reference_complete_domain_witness": true, + "response_bytes": 16384 }, { "name": "over-limit", "native": "unavailable", - "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "native_maximum_response_bytes": 16384, + "reference_code": null, + "reference_complete_domain_witness": true, + "response_bytes": 16385 + }, + { + "name": "over-reference-limit", + "native": "unavailable", + "native_maximum_response_bytes": 16384, + "reference_code": "qualification.fresh.response-bound", + "reference_complete_domain_witness": false, + "response_bytes": 65537 } ], "recovery": { @@ -174,80 +208,122 @@ { "name": "exact", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": null, - "reference_complete_domain_witness": true + "reference_complete_domain_witness": true, + "response_bytes": 238 }, { "name": "wrong-value", "native": "state-mismatch", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 235 }, { "name": "wrong-echo", "native": "echo-mismatch", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 174 }, { "name": "null-echo", "native": "state-match", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 167 }, { "name": "different-resource", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": null, - "reference_complete_domain_witness": true + "reference_complete_domain_witness": true, + "response_bytes": 239 }, { "name": "duplicate-member", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 23 }, { "name": "malformed", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 1 }, { "name": "nonfinite", "native": "unavailable", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 14 + }, + { + "name": "at-limit", + "native": "echo-linked", + "native_maximum_response_bytes": 16384, + "reference_code": null, + "reference_complete_domain_witness": true, + "response_bytes": 16384 }, { "name": "over-limit", "native": "unavailable", - "reference_code": "qualification.fresh.invalid-json", - "reference_complete_domain_witness": false + "native_maximum_response_bytes": 16384, + "reference_code": null, + "reference_complete_domain_witness": true, + "response_bytes": 16385 + }, + { + "name": "over-reference-limit", + "native": "unavailable", + "native_maximum_response_bytes": 16384, + "reference_code": "qualification.fresh.response-bound", + "reference_complete_domain_witness": false, + "response_bytes": 65537 }, { "name": "pending-refund", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 236 }, { "name": "other-payment", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 236 }, { "name": "other-currency", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 238 }, { "name": "live-refund", "native": "echo-linked", + "native_maximum_response_bytes": 16384, "reference_code": "qualification.fresh.state-mismatch", - "reference_complete_domain_witness": false + "reference_complete_domain_witness": false, + "response_bytes": 237 } ], "recovery": { @@ -384,13 +460,13 @@ ] } ], - "native_corpus_sha256": "5bf9583f6bee226f243e34c0e125b6f179370de53d5a76c36b76203e20947c26", + "native_corpus_sha256": "5a77da8180e7b57644038325ab32813f49e3b1de9561d167c079c01695c9d0c6", "schema": "auths.ap074-independent-mutation-differential/1", "scope": "test-only native verified compilation and response classification compared with retained independent references; no admission, provider I/O, production qualification or AP070 guarantee", "source_sha256": { - "product/runtime/auths-gateway/src/native_differential_tests.rs": "65d5ed32c660d2e25c503417ada142bfd8b550f449fe1c21c35f5afe556ade2b", + "product/runtime/auths-gateway/src/native_differential_tests.rs": "1c5993be7f284477952bd95ff36b38d1c426cee21ffbd533ec3886bdff5eb879", "qualification/reference/airtable_record.py": "d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa", - "qualification/reference/ap074_differential.py": "08684a044c2d46b43f3ee8c27c901430de5ddac1fca892cdde384e0abb6fa866", + "qualification/reference/ap074_differential.py": "b2f88044a9131a3d62b11f842ea1f132f70563063cc45a25d48796641266127c", "qualification/reference/common.py": "604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce", "qualification/reference/fresh_evidence.py": "cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f", "qualification/reference/provider_readback.py": "d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2", diff --git a/bindings/fixtures/gateway/native-independent-mutation-differential.json b/bindings/fixtures/gateway/native-independent-mutation-differential.json index fc2aa4ec2..95ac3eb1b 100644 --- a/bindings/fixtures/gateway/native-independent-mutation-differential.json +++ b/bindings/fixtures/gateway/native-independent-mutation-differential.json @@ -239,46 +239,78 @@ { "name": "exact", "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "wrong-value", "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":0,\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "state-mismatch" }, { "name": "wrong-echo", "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"unrelated\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-mismatch" }, { "name": "null-echo", "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":null}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "state-match" }, { "name": "different-resource", "response": "{\"id\":\"re_OTHER123\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "duplicate-member", "response": "{\"id\":\"one\",\"id\":\"two\"}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, { "name": "malformed", "response": "{", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, { "name": "nonfinite", "response": "{\"amount\":NaN}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, + { + "name": "at-limit", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 16234, + "native_maximum_response_bytes": 16384, + "native": "echo-linked" + }, { "name": "over-limit", - "response": " ", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 16235, + "native_maximum_response_bytes": 16384, + "native": "unavailable" + }, + { + "name": "over-reference-limit", + "response": "{\"id\":\"recTEST0000000001\",\"fields\":{\"DemoStatus\":\"Approved\",\"auths_echo\":\"auths-e1-64d5feadbcf45b725231123481386f30821215397d52b5ad9a08c8770e8379ed\"}}", + "trailing_space_bytes": 65387, + "native_maximum_response_bytes": 16384, "native": "unavailable" } ], @@ -683,66 +715,106 @@ { "name": "exact", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "wrong-value", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":0,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "state-mismatch" }, { "name": "wrong-echo", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"unrelated\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-mismatch" }, { "name": "null-echo", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":null}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "state-match" }, { "name": "different-resource", "response": "{\"id\":\"re_OTHER123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "pending-refund", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"pending\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "other-payment", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_OTHER\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "other-currency", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"eur\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "live-refund", "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":true,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "echo-linked" }, { "name": "duplicate-member", "response": "{\"id\":\"one\",\"id\":\"two\"}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, { "name": "malformed", "response": "{", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, { "name": "nonfinite", "response": "{\"amount\":NaN}", + "trailing_space_bytes": 0, + "native_maximum_response_bytes": 16384, "native": "unavailable" }, + { + "name": "at-limit", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 16146, + "native_maximum_response_bytes": 16384, + "native": "echo-linked" + }, { "name": "over-limit", - "response": " ", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 16147, + "native_maximum_response_bytes": 16384, + "native": "unavailable" + }, + { + "name": "over-reference-limit", + "response": "{\"id\":\"re_TEST123\",\"object\":\"refund\",\"livemode\":false,\"payment_intent\":\"pi_TEST123\",\"amount\":1000,\"currency\":\"usd\",\"status\":\"succeeded\",\"metadata\":{\"auths_echo\":\"auths-e1-1c757c5260b8cb620c77830b93ac52caffadcb7d4b4042201014b4a5df7e84f5\"}}", + "trailing_space_bytes": 65299, + "native_maximum_response_bytes": 16384, "native": "unavailable" } ], diff --git a/docs/plans/0074-differential-contracts.md b/docs/plans/0074-differential-contracts.md index 3f613d32b..a4577ed48 100644 --- a/docs/plans/0074-differential-contracts.md +++ b/docs/plans/0074-differential-contracts.md @@ -16,7 +16,7 @@ an immutable bound effect. Successful cases also obtain and revalidate a real exact-effect approval signed by public fixed test keys. There is no admission, entry permit, credential, provider execution or human-presence claim. -The retained native corpus has 28 request cases and 22 response cases across +The retained native corpus has 28 request cases and 26 response cases across the two families. `qualification/reference/ap074_differential.py` calls the unchanged `airtable_record.py`, `stripe_platform.py`, `fresh_evidence.py` and `provider_readback.py`; the references never import the gateway implementation @@ -31,6 +31,7 @@ decisions, case inventory, observations, recovery targets and resource scope. | Resource scope | The independent qualification pool refuses an otherwise well-shaped unowned resource. A native grant/recipe can authorize that resource without knowing the qualification pool. These expected differences are required assertions, not accepted unexplained drift. | | Provider guard | Native compilation is not the separately fenced fresh provider-read decision. Independent Stripe guards separately demonstrate the exact 50 percent ceiling and currency binding; this corpus does not claim to execute the native live guard. | | Observation | Exact expected value plus exact declared echo links the generic native observation. Wrong value/echo and unavailable JSON retain distinct facts. Duplicate members, malformed/nonfinite JSON and over-limit responses never become a definitive observation. | +| Byte limits | Complete valid JSON plus trailing whitespace remains accepted at the native 16,384-byte observation limit and becomes unavailable at 16,385. The independent full-domain witness has a different 65,536-byte limit, so it accepts that larger valid native-refused response; both refuse 65,537 bytes. These bound differences are explicit. Large padding is represented by its bounded count in the corpus and materialized before actual native/reference calls. | | Full domain witness | Independent references additionally check the record identity or refund payment, status, currency and live-mode facts. A generic recipe that projects one value and echo does not acquire those extra domain predicates. Missing echo can be native state equality while the full independent witness refuses. | | Refund identity | The independent Stripe reference discovers a refund by its action-bound echo. A different safe refund ID alone does not invalidate that witness. It never trusts an application-supplied refund locator. | | Recovery capability | Airtable has a verified record locator before any write response. Stripe's native response-derived locator is unavailable without the recorded response; a declared idempotency key cannot recreate it or confer a new entry permit. The independent reference can instead find exactly one action-bound refund in its own bounded listing. That discovery is an intentionally different test-only capability, not a native recovery grant. | diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 27c5671cb..38d19ecdc 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2742,6 +2742,25 @@ or authorization/ACK equivalence claim is made. advances freeze409 and only its reported identity153/public-SDK150/ public-surface409 entries; no shipping Rust or reference implementation changes. +## Differential response boundary hardening + +Review of the new mutation corpus found that its oversized response was also +invalid JSON, so that negative alone could not isolate the byte-limit predicate. +The follow-up over `f5f3a8ca` replaces it with complete valid domain JSON plus +trailing whitespace at 16,384, 16,385 and 65,537 bytes. Native observation accepts +exactly its configured 16,384-byte bound and refuses the next byte. The unchanged +independent witness has a 65,536-byte bound and therefore accepts the valid +16,385-byte response; both refuse 65,537. The difference is required explicitly, +not hidden as equivalent bounds. A bounded padding count keeps the retained +fixture readable; both implementations receive the actual materialized bytes. + +The updated native artifact generator passed one test, zero failed/ignored, +0.11 seconds after compilation. Independent report construction also passed, +now with 28 request and 26 response cases. Its nine adversarial comparator +mutations include changing the exact-limit padding; that unit test and new +hosted execution remain pending. Semantic inventory construction stayed at +freeze409 without identity/hash changes. No shipping or AP070 source changed. + ## Phase gates | Phase | State | Outstanding gate | @@ -2778,7 +2797,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / mutation reference comparison constructed; 22 paired post-authorization information comparisons authored against unchanged AP070 and native file/PostgreSQL histories / 28 request and 22 response mutation cases constructed locally; information comparison unrun | Execute new independent information runner and parser controls plus exact-head hosted mutation corpus; complete coverage audit; AP070 source stays independent without managed guarantees | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / mutation reference comparison constructed; 22 paired post-authorization information comparisons authored against unchanged AP070 and native file/PostgreSQL histories / 28 request and 26 response mutation cases constructed locally, including valid JSON at/above both byte bounds; information comparison unrun | Execute new independent information runner and parser controls plus exact-head hosted mutation corpus; complete coverage audit; AP070 source stays independent without managed guarantees | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | | A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | diff --git a/product/runtime/auths-gateway/src/native_differential_tests.rs b/product/runtime/auths-gateway/src/native_differential_tests.rs index 3a6823de0..071ea17c8 100644 --- a/product/runtime/auths-gateway/src/native_differential_tests.rs +++ b/product/runtime/auths-gateway/src/native_differential_tests.rs @@ -276,11 +276,20 @@ fn response_cases(family: Family, request: &crate::ClosedProviderRequest) -> Vec ), ("malformed", "{".to_owned()), ("nonfinite", "{\"amount\":NaN}".to_owned()), - ( - "over-limit", - " ".repeat(observation.maximum_response_bytes() + 1), - ), ]); + // Vary only trailing whitespace on a complete valid response, so the + // negative boundary cannot also be explained by malformed JSON. + let exact = serde_json::to_string(&original).expect("complete response"); + for (name, length) in [ + ("at-limit", observation.maximum_response_bytes()), + ("over-limit", observation.maximum_response_bytes() + 1), + ("over-reference-limit", 65_537), + ] { + assert!(exact.len() < length); + let mut response = exact.clone(); + response.extend(std::iter::repeat_n(' ', length - exact.len())); + inputs.push((name, response)); + } inputs .into_iter() .map(|(name, raw)| { @@ -291,7 +300,11 @@ fn response_cases(family: Family, request: &crate::ClosedProviderRequest) -> Vec Some(ReadBack::Value { matched: false }) => "state-mismatch", None => "unavailable", }; - json!({"name":name, "response":raw, "native":native}) + let response = raw.trim_end_matches(' '); + json!({"name":name, "response":response, + "trailing_space_bytes":raw.len() - response.len(), + "native_maximum_response_bytes":observation.maximum_response_bytes(), + "native":native}) }) .collect() } diff --git a/qualification/reference/ap074_differential.py b/qualification/reference/ap074_differential.py index a651c2969..58056c6bb 100644 --- a/qualification/reference/ap074_differential.py +++ b/qualification/reference/ap074_differential.py @@ -106,7 +106,9 @@ def compare_observations(family, baseline): 'duplicate-member': ('unavailable', False), 'malformed': ('unavailable', False), 'nonfinite': ('unavailable', False), - 'over-limit': ('unavailable', False)} + 'at-limit': ('echo-linked', True), + 'over-limit': ('unavailable', True), + 'over-reference-limit': ('unavailable', False)} if reference is stripe: # A refund is discovered by action-bound echo, rather than a caller's # claimed refund ID. Another safe refund ID alone is not a mismatch. @@ -119,17 +121,27 @@ def compare_observations(family, baseline): for name, (native, accepted) in expected.items(): row = rows[name] require(row['native'] == native, 'ap074.differential.native-response') + padding = row['trailing_space_bytes'] + require(type(padding) is int and 0 <= padding <= 65537 + and row['native_maximum_response_bytes'] == 16384, + 'ap074.differential.response-padding-bound') + raw = row['response'].encode() + b' ' * padding + if name in ['at-limit', 'over-limit', 'over-reference-limit']: + length = {'at-limit': 16384, 'over-limit': 16385, 'over-reference-limit': 65537}[name] + require(len(raw) == length and json.loads(raw) == json.loads(rows['exact']['response']), + 'ap074.differential.valid-json-byte-boundary') try: witness = fresh_evidence.witness(family['family'], baseline['arguments'], family['resources'], baseline['action_commitment'], family['recipe_digest'], - row['response'].encode()) + raw) actual, code = True, None - require(witness['response_sha256'] == sha256(row['response'].encode()), + require(witness['response_sha256'] == sha256(raw), 'ap074.differential.reference-response-digest') except Refusal as error: actual, code = False, str(error) require(actual is accepted, 'ap074.differential.reference-response') - compared.append({'name': name, 'native': native, + compared.append({'name': name, 'native': native, 'response_bytes': len(raw), + 'native_maximum_response_bytes': row['native_maximum_response_bytes'], 'reference_complete_domain_witness': actual, 'reference_code': code}) return rows['exact']['response'].encode(), compared diff --git a/qualification/reference/tests/test_ap074_differential.py b/qualification/reference/tests/test_ap074_differential.py index ca510b185..5d832975f 100644 --- a/qualification/reference/tests/test_ap074_differential.py +++ b/qualification/reference/tests/test_ap074_differential.py @@ -39,7 +39,11 @@ def scope(value): def capability(value): value['families'][1]['recovery']['capability']['unknown_reobservation'] = True - for mutate in [request, decision, missing, duplicated, response, locator, scope, capability]: + def byte_boundary(value): + row = next(row for row in value['families'][0]['observations'] if row['name'] == 'at-limit') + row['trailing_space_bytes'] -= 1 + + for mutate in [request, decision, missing, duplicated, response, locator, scope, capability, byte_boundary]: with self.subTest(mutation=mutate.__name__): changed = copy.deepcopy(original) mutate(changed) From d9618a568c4db8fae0b8bc4cb80b77de81c8e7d1 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 17:06:04 +0000 Subject: [PATCH 093/136] test(demo): verify the rendered native recovery contract The complete literal renderer identifies recovery through its acquisition protocol and versioned recovery contract, not an internal tool name. Assert the exact source binding, GET method, matching native and semantic recovery, and a separate reader actor while retaining all consent, no-entry and replay controls. Verified the full browser journey against the exact hosted cb1ee6d1 package in an isolated Linux Docker container with pinned Playwright and Chromium. No application or native runtime behavior changed. --- demos/airtable-gateway/tests/owner_browser.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/demos/airtable-gateway/tests/owner_browser.py b/demos/airtable-gateway/tests/owner_browser.py index 33a18a35e..87c6e3bd1 100644 --- a/demos/airtable-gateway/tests/owner_browser.py +++ b/demos/airtable-gateway/tests/owner_browser.py @@ -94,10 +94,19 @@ def test_installed_authenticated_owner_review_and_native_recovery(): agent.locator('#experiment').select_option('recover-exact') agent.locator('#submit').click() expect(owner.locator('#review')).to_be_visible(timeout=45000) - expect(owner.locator('#literal')).to_contain_text('auths_gateway_recovery_read_v1') + expect(owner.locator('#literal')).to_contain_text('"contract": "auths.gateway-recovery-read/1"') native_read = native_review('read-exact-1') assert owner.locator('#literal').text_content() == native_read['literal_review'] - assert json.loads(native_read['literal_review'])['native']['recovery']['source_effect'] == effect_id + read_review = json.loads(native_read['literal_review']) + assert read_review['native']['protocol'] == 'acquisition' + assert read_review['native']['method'] == 'GET' + assert read_review['native']['recovery']['source_effect'] == effect_id + assert read_review['native']['recovery']['source_operation'] == 'exact' + assert read_review['binding']['operation'] == 'read-exact-1' + assert read_review['binding']['protocol']['kind'] == 'acquisition' + assert read_review['semantic']['contract'] == 'auths.gateway-recovery-read/1' + assert read_review['semantic']['recovery'] == read_review['native']['recovery'] + assert read_review['native']['actors'] != json.loads(native['literal_review'])['native']['actors'] assert witness() == after_write owner.locator('#approve').click() expect(agent.locator('#outcome')).to_have_text('RECOVERY-REPORT', timeout=45000) From f6ef54a1b081a45b0e3dd7843292424a030edb97 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 17:06:04 +0000 Subject: [PATCH 094/136] test(demo): verify the rendered native recovery contract The complete literal renderer identifies recovery through its acquisition protocol and versioned recovery contract, not an internal tool name. Assert the exact source binding, GET method, matching native and semantic recovery, and a separate reader actor while retaining all consent, no-entry and replay controls. Verified the full browser journey against the exact hosted cb1ee6d1 package in an isolated Linux Docker container with pinned Playwright and Chromium. No application or native runtime behavior changed. --- demos/airtable-gateway/tests/owner_browser.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/demos/airtable-gateway/tests/owner_browser.py b/demos/airtable-gateway/tests/owner_browser.py index 33a18a35e..87c6e3bd1 100644 --- a/demos/airtable-gateway/tests/owner_browser.py +++ b/demos/airtable-gateway/tests/owner_browser.py @@ -94,10 +94,19 @@ def test_installed_authenticated_owner_review_and_native_recovery(): agent.locator('#experiment').select_option('recover-exact') agent.locator('#submit').click() expect(owner.locator('#review')).to_be_visible(timeout=45000) - expect(owner.locator('#literal')).to_contain_text('auths_gateway_recovery_read_v1') + expect(owner.locator('#literal')).to_contain_text('"contract": "auths.gateway-recovery-read/1"') native_read = native_review('read-exact-1') assert owner.locator('#literal').text_content() == native_read['literal_review'] - assert json.loads(native_read['literal_review'])['native']['recovery']['source_effect'] == effect_id + read_review = json.loads(native_read['literal_review']) + assert read_review['native']['protocol'] == 'acquisition' + assert read_review['native']['method'] == 'GET' + assert read_review['native']['recovery']['source_effect'] == effect_id + assert read_review['native']['recovery']['source_operation'] == 'exact' + assert read_review['binding']['operation'] == 'read-exact-1' + assert read_review['binding']['protocol']['kind'] == 'acquisition' + assert read_review['semantic']['contract'] == 'auths.gateway-recovery-read/1' + assert read_review['semantic']['recovery'] == read_review['native']['recovery'] + assert read_review['native']['actors'] != json.loads(native['literal_review'])['native']['actors'] assert witness() == after_write owner.locator('#approve').click() expect(agent.locator('#outcome')).to_have_text('RECOVERY-REPORT', timeout=45000) From 76d008a020e5b8e6c89e70bcb86ebc34e2c0e29d Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 21:03:36 +0000 Subject: [PATCH 095/136] fix(gateway): bound expiry sweeps and preserve native replay state --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-retention-file.json | 79 +++++++ .../gateway/native-retention-postgres.json | 79 +++++++ compliance.toml | 5 + ...017-bound-effect-and-recovery-ownership.md | 36 +++ docs/plans/0074-hosted-evidence-d9618a56.md | 25 ++ docs/plans/0074-implementation-status.md | 64 ++++- .../0009-bound-effect-and-recovery.md | 11 + product/runtime/auths-gateway/src/engine.rs | 43 +++- .../src/native_information_replay_tests.rs | 3 + .../src/native_retention_tests.rs | 220 ++++++++++++++++++ .../auths-gateway/src/scenario_tests.rs | 23 ++ product/runtime/auths-gateway/src/store.rs | 122 +++++++--- .../src/store_retention_tests.rs | 124 ++++++++++ .../ap074_information_differential.py | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 17 files changed, 813 insertions(+), 47 deletions(-) create mode 100644 bindings/fixtures/gateway/native-retention-file.json create mode 100644 bindings/fixtures/gateway/native-retention-postgres.json create mode 100644 docs/plans/0074-hosted-evidence-d9618a56.md create mode 100644 product/runtime/auths-gateway/src/native_retention_tests.rs create mode 100644 product/runtime/auths-gateway/src/store_retention_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 6d6638092..81925c942 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -70,6 +70,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::retention_tests::native_file_retention_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::retention_tests::postgres_native_retention_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres diff --git a/bindings/fixtures/gateway/native-retention-file.json b/bindings/fixtures/gateway/native-retention-file.json new file mode 100644 index 000000000..2cbd10686 --- /dev/null +++ b/bindings/fixtures/gateway/native-retention-file.json @@ -0,0 +1,79 @@ +{ + "schema": "auths.native-retention/1", + "adapter": "file", + "scope": "real native bounded proof/approval, HTTP and authenticated Unix delivery; expiry-slot sweep on file/TLS PostgreSQL; retained full records serve as replay tombstones", + "excluded": [ + "epoch changes and rollback floors", + "malicious whole-store rollback", + "hostile OS or live provider qualification" + ], + "cases": [ + { + "protocol": "acquisition-response", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + }, + { + "protocol": "disclosure-acknowledged", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + }, + { + "protocol": "disclosure-unknown", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-retention-postgres.json b/bindings/fixtures/gateway/native-retention-postgres.json new file mode 100644 index 000000000..a9ee29c8a --- /dev/null +++ b/bindings/fixtures/gateway/native-retention-postgres.json @@ -0,0 +1,79 @@ +{ + "schema": "auths.native-retention/1", + "adapter": "postgres", + "scope": "real native bounded proof/approval, HTTP and authenticated Unix delivery; expiry-slot sweep on file/TLS PostgreSQL; retained full records serve as replay tombstones", + "excluded": [ + "epoch changes and rollback floors", + "malicious whole-store rollback", + "hostile OS or live provider qualification" + ], + "cases": [ + { + "protocol": "acquisition-response", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 1, + "policy_byte_counters": 1, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + }, + { + "protocol": "disclosure-acknowledged", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + }, + { + "protocol": "disclosure-unknown", + "window_seconds": 60, + "slot_expiry": 1790000100, + "deleted_before_expiry": 0, + "deleted_at_expiry": 2, + "original_approval_current_at_sweep": true, + "native_snapshot": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "new_operation_with_old_approval_refused": true, + "claims_and_recorded_allocations_unchanged": true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing": true, + "provider_reads": 1 + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 1778a3f26..5ea2c3f2f 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1826,6 +1826,11 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#postgres_native_mutation_retained_replay_fixture_is_current", "product/runtime/auths-gateway/src/native_information_replay_tests.rs#native_file_information_retained_replay_fixture_is_current", "product/runtime/auths-gateway/src/native_information_replay_tests.rs#postgres_native_information_retained_replay_fixture_is_current", + "product/runtime/auths-gateway/src/native_retention_tests.rs#native_file_retention_fixture_is_current", + "product/runtime/auths-gateway/src/native_retention_tests.rs#postgres_native_retention_fixture_is_current", + "product/runtime/auths-gateway/src/store_retention_tests.rs#bounded_cursor_progress_preserves_every_durable_record_kind", + "product/runtime/auths-gateway/src/store_retention_tests.rs#corrupt_slot_is_not_treated_as_expired_or_absent", + "product/runtime/auths-gateway/src/engine.rs#slot_sweep_refuses_untrusted_required_time_without_deleting_state", "product/runtime/auths-gateway/src/entry_tests.rs#retained_native_authority_projection_is_required_and_bound", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#postgres_in_flight_prerequisite_cannot_poison_shared_parent", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 84ee4ee86..f20cb20ad 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1126,6 +1126,42 @@ PostgreSQL and hostile process isolation remain distinct incomplete obligations. No production transition predicate or wire schema changed in this increment. +## Bounded expiry maintenance and retained replay facts + +The existing store remains the only journal and reservation owner. Count/sum +slots expire one complete window after the corresponding window ends. Attempts, +configuration, commissioning budgets and lifetime effect allocations do not +expire and are never eligible for this sweep. Full retained attempt records +serve as replay tombstones; no compressed tombstone decoder or alternative +admission path is added. Total journal storage may grow with retained operations. + +The file adapter now inspects at most 4,096 directory entries in a sweep and +checks the existing two-second cooperative work deadline between entries. It +retains one transient directory iterator, so later calls can advance past +permanent and unexpired records without collecting or sorting the directory. +All inspection and deletion participate in the common writer fence. Reopening +loses only scan progress, never journal authority. Each record read remains +byte-bounded; physical filesystem I/O/sync latency remains a host assumption. +Deletion of expired slots is directory-synced even if a later read fails. +The indexed PostgreSQL sweep keeps its existing writer fence and bounded LIMIT. + +The engine supplies the same deployment clock used for native effect evaluation; +required qualification with untrusted time refuses cleanup before storage work. +An independently sampled wall clock must not age out a still-current effect +window. This is not a new clock rollback detector or a whole-store rollback claim. + +Native file/PostgreSQL evidence acquires actual HTTP content using signed +count/byte bounds and exact approval, then optionally performs authenticated +Unix disclosure with ACK or ACK loss. Slots remain before their exact expiry +and are removed at expiry while the original approval remains current. Replay +returns the same original facts without new entry, recipient authentication, +delivery or charges; another operation cannot consume the old approval. A +reopened engine preserves those facts after full authority expiry. Separate +adapter controls retain every nonexpiring kind, bound scan progress and refuse +corrupt slots. Execution status belongs in the AP074 ledger; epoch/floor, +reserved/mutation retention and remaining fault cases are not inferred from +these read/release histories. + ## Standalone read-only recipe decision A source `/3` with no `write` declaration is a content-only installation. It must diff --git a/docs/plans/0074-hosted-evidence-d9618a56.md b/docs/plans/0074-hosted-evidence-d9618a56.md new file mode 100644 index 000000000..ffb16cebc --- /dev/null +++ b/docs/plans/0074-hosted-evidence-d9618a56.md @@ -0,0 +1,25 @@ +# Airtable CI-only fix — published and verified + +Observed terminal success on 2026-10-29 at 19:49 UTC. **Main AP074 work remains paused.** + +Published exact commit **`d9618a568c4db8fae0b8bc4cb80b77de81c8e7d1`** to `origin/codex/effect-recovery-foundation` for [PR213](https://github.com/auths-dev/auths-proof/pull/213). Before pushing, verified remote and PR head were `cb1ee6d15a8f728b2f6f9ce01021de69b67ac966`, that this was an ancestor of the repair, and that the entire outgoing delta was exactly one reviewed commit changing only `demos/airtable-gateway/tests/owner_browser.py` (11 insertions/two deletions). Non-force push succeeded; remote SHA reverified afterward. No unrelated A19 commits were published. Main worktree, uncommitted retention/comparator work, AP070 and AP073 were untouched. + +The [original failure](https://github.com/auths-dev/auths-proof/actions/runs/40911731259/job/123585414288) expected an internal recovery tool identifier in the complete native literal review. The native renderer instead identifies a recovery acquisition using the versioned `auths.gateway-recovery-read/1` contract. The repair checks that rendered contract, acquisition/GET, exact source effect and operation, correct bound read operation, matching native/semantic recovery and a separate reader actor. Existing literal byte equality, authentication, consent/no-entry, substitution, provider-count and replay assertions remain intact. No application/native behavior or security deadline changed. + +Existing complete local hosted-package Docker/browser reproduction was rechecked rather than repeated. Publication now has fresh authoritative hosted verification: + +- **[Airtable run40942189355](https://github.com/auths-dev/auths-proof/actions/runs/40942189355), attempt1: completed SUCCESS**, source head exactly `d9618a568c4db8fae0b8bc4cb80b77de81c8e7d1`. +- [Package job123688155935](https://github.com/auths-dev/auths-proof/actions/runs/40942189355/job/123688155935): passed. +- [Installed-demo job123691155527](https://github.com/auths-dev/auths-proof/actions/runs/40942189355/job/123691155527): passed, including all 36 existing cases and the repaired complete installed owner-browser journey. +- Evidence artifact **12928066979**, SHA256 **`f61da4e93df77739da78960f20d4baa994583b5126ddb1a2d820328e80c1d147`**, downloaded and checksum verified. Its `owner-journey.json` explicitly identifies exact source `d9618a56` and records unchanged native renderer, withheld pre-consent approvals, decline/no entry, substituted review refusal, private owner credential isolation, one write, independent read and browser/fresh-process replay without extra execution. +- Package artifact **12927612249**, SHA256 **`b240c4a5e3e0a1b37549fc8f971b6112ae9abea84b246688e7c967a39ba15f95`**, attributed to the same head. + +This completes the requested CI-only fix. No additional changes or reruns were needed. Other automatically triggered workflows were preserved; no claim is made here that the entire new-head PR matrix is terminal or green. Owner actions are browser-simulated against a local provider; the artifact explicitly excludes human attention, production custody, live provider qualification, hostile OS and a full content/disclosure journey. + +Saved records: + +- `/tmp/ap074-ci-d961-evidence.json`: job records, artifact attribution and installed-job log. +- `/tmp/ap074-ci-d961-owner-journey.json`: verified hosted owner-journey manifest. +- `/tmp/ap074-ci-d961-airtable-evidence.zip`: checksum-verified hosted evidence archive. + +Child checkout is clean. Main's previously cherry-picked duplicate `f6ef54a1` and unpublished work remain preserved; any future ancestry reconciliation belongs to a later authorized resumption, not this paused goal. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 38d19ecdc..7f883e5ba 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2761,6 +2761,68 @@ mutations include changing the exact-limit padding; that unit test and new hosted execution remain pending. Semantic inventory construction stayed at freeze409 without identity/hash changes. No shipping or AP070 source changed. +## Resumed completion and retention checkpoint + +The user resumed the full completion prompt after the pause. The published +CI-only repair `d9618a568c4db8fae0b8bc4cb80b77de81c8e7d1` is now an ancestor of +this branch through a non-rewriting merge; the three A19 commits, duplicate +local cherry-pick and all unfinished work were preserved. The durable goal +above continues to mean all P0–P4/A01–A22, not merely the current patch. + +The exact published d961 Airtable run40942189355, package123688155935 and +installed-demo123691155527 passed, including all 36 existing cases and the +complete repaired owner-browser journey. Its verified artifact12928066979 is +attributed to d961; production_qualification=false remains explicit. The saved +[hosted report](0074-hosted-evidence-d9618a56.md) records the CI-only scope and +pause as historical facts. On resumption, the commit-workflows API returned all +14 d961 workflows terminal: 13 successful and custody live conditionally skipped. +No unpublished A19 or retention behavior is established by those old-head runs. + +Retention implementation now removes the file adapter's full-directory +collection/sort. Each call scans at most 4,096 directory entries, checks the +common two-second cooperative deadline between entries and retains one +nonauthoritative iterator for progress. It uses the same writer fence, only +deletes expired count/sum slots and syncs safe deletions even if a later read +fails. Restart loses only scan progress. Filesystem I/O latency remains an +explicit host assumption. All other record kinds remain permanent; retained +full attempts are the replay tombstones, with continuing storage growth. + +The engine sweep now uses the existing deployment/effect clock and fails before +storage if required qualification lacks trusted time. A separately sampled wall +clock could previously delete windows still current on that effect clock. +No new clock-rollback or malicious whole-store rollback guarantee is claimed. + +Required fixture construction executed this batch over the reconciled branch: + +- `AUTHS_UPDATE_FIXTURES=1 cargo test --locked -p auths-gateway --features loopback-provider,testkit-harness --lib native_information_replay_tests::retention_tests::native_file_retention_fixture_is_current -- --exact` + passed one test, zero failed/ignored, 0.93 seconds after compilation. +- The corresponding explicit `postgres_native_retention_fixture_is_current` + selector with `--ignored --exact` and the owned TLS PostgreSQL fixture passed + one test, zero failed/ignored, 1.63 seconds after compilation. + +The six histories use actual native signed bounded grants, exact approval, +HTTP acquisition and authenticated Unix delivery/ACK loss. Cleanup preserves +slots before expiry and removes two at exact expiry while approval is still +current. Original replay cannot send again or allocate again; an independently +signed new operation cannot consume the old approval. After reopening and full +authority expiry, source/disclosure records and recorded allocations/charges +remain byte-identical and provider reads remain one. Scope excludes independent +OS isolation, mutation/reserved retention and epoch/rollback-floor evidence. + +File cursor scan bounds/corrupt-slot controls, required-untrusted-clock refusal, +and both-adapter conformance over all five durable record kinds are authored, +not executed locally. The PostgreSQL workflow adds the two native selectors +(24 explicit selections total) without dropping existing cases. Hosted checks +must execute these and the previously unpublished A19 comparisons on the new +head before any completion claim. AP070/AP073 source remains untouched. + +The preserved information comparator also now uses the native artifact's actual +`disclosure-acknowledged` label; the prior shorthand was not an accepted native +protocol value. This is a correction to previously unrun test orchestration, +not a runtime protocol change. Required semantic inventory regeneration advances +freeze410 with only reported identity154/public-SDK151/public-surface410 inputs. +Effect/compiler/attempt schemas and translated pure predicates stay unchanged. + ## Phase gates | Phase | State | Outstanding gate | @@ -2799,7 +2861,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / mutation reference comparison constructed; 22 paired post-authorization information comparisons authored against unchanged AP070 and native file/PostgreSQL histories / 28 request and 26 response mutation cases constructed locally, including valid JSON at/above both byte bounds; information comparison unrun | Execute new independent information runner and parser controls plus exact-head hosted mutation corpus; complete coverage audit; AP070 source stays independent without managed guarantees | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | -| A21 | Tombstones, stale state, supported rollback floors | Pending / no / no | Epoch/retention evidence | +| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded file maintenance and shared effect clock; native read/release expiry cleanup / six file/TLS PostgreSQL histories constructed, with retained replay and unchanged recorded charges after cleanup/reopen | Hosted execution, reserved/mutation retention, epoch/stale configuration and supported rollback-floor evidence remain required | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 1c4034993..08112bc30 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -114,6 +114,17 @@ byte private authority projection limit and no reader for obsolete state. ## Cutover and evidence +The retained replay/maintenance boundary has two separate bounds: native policy +windows and adapter maintenance work. Expiring count/sum slots may be reclaimed +without deleting attempts, configuration, commissioning or lifetime allocations. +File maintenance uses a nonauthoritative iterator (4,096 inspected directory +entries and a cooperative two-second work budget), not a second journal or a +full-directory sort. PostgreSQL retains its indexed LIMIT and common writer +fence. The engine samples the existing deployment/effect clock for both stores. +The source and native retention fixtures are recorded in the ledger; they do +not establish clock rollback detection, all reserved/mutation histories or +malicious whole-store rollback protection. + Replace affected formats and call sites in one bounded PR. No production compatibility path, migration or dual journal. Reference models remain explicitly test-only or independently application-owned with explicit narrower claims. diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index d9859beef..3a9d514b4 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1268,10 +1268,14 @@ impl GatewayEngine { /// clock, and returns how many were deleted. Claims are never swept. /// /// # Errors - /// `gateway.sweep.clock-unavailable` without a clock, and + /// `gateway.sweep.clock-unavailable` without the effect clock (including + /// untrusted time under required qualification), and /// `gateway.sweep.unavailable` when the store fails. pub async fn sweep_expired_slots(&self) -> Result { - let now = wall_clock_seconds().ok_or("gateway.sweep.clock-unavailable")?; + let now = self + .qualification + .effect_time() + .ok_or("gateway.sweep.clock-unavailable")?; let deleted = self .attempts .sweep_expired(now, SLOT_SWEEP_LIMIT) @@ -4094,6 +4098,41 @@ pub(crate) mod tests { assert!(swept <= status.gateway_clock); } + #[tokio::test] + async fn slot_sweep_refuses_untrusted_required_time_without_deleting_state() { + let mut installation = installation(8).await; + let raw = installation.attempts.raw(); + let entry = crate::store::GatewayRecordEntry { + kind: crate::GatewayRecordKind::CountSlot, + key: crate::GatewayAttemptKey::from_bytes([91; 32]), + record: b"public-untrusted-clock-slot".to_vec(), + expires_at: Some(1), + }; + raw.insert(&entry).expect("slot"); + let clock = Arc::new(crate::FixedClock::at(100)); + clock.trust_is(false); + installation.first.engine.qualification = Arc::new(crate::QualificationGate::new( + crate::QualificationPolicy::Required, + None, + None, + Box::new(clock), + auths_recipe_qualification::VerifierState::default(), + )); + assert_eq!( + installation.first.engine.sweep_expired_slots().await, + Err("gateway.sweep.clock-unavailable") + ); + assert_eq!( + raw.load(entry.kind, &entry.key).expect("slot"), + Some(entry.record) + ); + assert_eq!( + installation.first.engine.last_sweep.load(Ordering::SeqCst), + 0 + ); + assert_eq!(installation.first.leases.load(Ordering::SeqCst), 0); + } + #[tokio::test] async fn an_obsolete_record_is_refused_as_state() { let installation = installation(8).await; diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index 34d63d3b9..21398ff35 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -26,6 +26,9 @@ use tokio::{io::AsyncReadExt as _, net::UnixStream}; const SOURCE: &str = "retained-read"; const RELEASE: &str = "retained-release"; +#[path = "native_retention_tests.rs"] +mod retention_tests; + #[derive(Clone, Copy, Debug)] enum Protocol { Acquisition, diff --git a/product/runtime/auths-gateway/src/native_retention_tests.rs b/product/runtime/auths-gateway/src/native_retention_tests.rs new file mode 100644 index 000000000..9ac3bc0e4 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_retention_tests.rs @@ -0,0 +1,220 @@ +//! Retained native facts survive expiry-slot cleanup; no permit is recreated. +use super::*; +use crate::harness::authoring::tool_fixture_using_policy; +use crate::{ArgumentCeilingPolicy, GatewayAttemptKey}; + +const WINDOW: u64 = 60; +type StoredRecord = (GatewayRecordKind, GatewayAttemptKey, Vec); + +async fn bounded_input(engine: &GatewayEngine, operation: &str) -> Input { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) + .await + .expect("native call"); + let policy = ArgumentCeilingPolicy::new("maximum_response_bytes", 1024, WINDOW, 1) + .expect("count bound") + .with_sum(1024, None) + .expect("byte bound"); + let signed = tool_fixture_using_policy(&call, NOW, NOW + 86_400, Some(&policy)) + .expect("native bounded proof"); + let effect = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("bound effect"); + Input { + proof: signed.proof, + action: signed.action, + approval: Input::approval(&effect, Change::None), + } +} + +fn slots(fixture: &Fixture) -> Vec { + let mut slots = Vec::new(); + for bytes in fixture.records() { + let record: Value = serde_json::from_slice(&bytes).expect("native record"); + for counter in record["state"]["facts"]["counters"] + .as_array() + .expect("counters") + { + let digest: [u8; 32] = hex::decode(counter["counter"].as_str().expect("digest")) + .expect("hex") + .try_into() + .expect("length"); + let slot = counter["slot"].as_u64().expect("slot"); + let (kind, key) = if counter["kind"] == "count" { + ( + GatewayRecordKind::CountSlot, + crate::bounds::count_slot_key(&digest, slot), + ) + } else { + assert_eq!(counter["kind"], "sum"); + ( + GatewayRecordKind::SumSlot, + crate::bounds::sum_slot_key(&digest, slot), + ) + }; + let key = GatewayAttemptKey::from_bytes(key); + let bytes = fixture + .store + .raw() + .load(kind, &key) + .expect("slot load") + .expect("slot"); + slots.push((kind, key, bytes)); + } + } + assert_eq!( + slots.len(), + 2, + "only the bounded source's count and byte slots" + ); + slots +} + +async fn replay( + engine: &GatewayEngine, + input: &Input, + acquired: &crate::AcquisitionSnapshot, + disclosure: Option<&ReleaseHistory>, +) -> Value { + let acquisition = replay_content(engine, input, acquired).await; + match disclosure { + Some(history) => replay_release(engine, history).await, + None => acquisition, + } +} + +fn retained_case(backend: Backend, protocol: Protocol) -> Value { + let fixture = Fixture::new(backend); + let source = fixture + .runtime + .block_on(bounded_input(&fixture.engine, SOURCE)); + let acquired = fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &source.proof, + &source.action, + source.approval.clone(), + )) + .expect("one real GET"); + let disclosure = prepare_release(&fixture, protocol, Change::None); + let before = fixture.records(); + let allocated = slots(&fixture); + let expiry = (NOW / WINDOW + 2) * WINDOW; + let witness = fixture.engine.execution_witness(); + fixture.clock.set(expiry - 1); + assert_eq!( + fixture + .runtime + .block_on(fixture.engine.sweep_expired_slots()), + Ok(0) + ); + for (kind, key, expected) in &allocated { + assert_eq!( + fixture.store.raw().load(*kind, key).expect("slot"), + Some(expected.clone()) + ); + } + // Approval is still valid: deleting the old window cannot license another + // grant for the exact same retained operation in the new window. + assert!(expiry < NOW + 300); + fixture.clock.set(expiry); + assert_eq!( + fixture + .runtime + .block_on(fixture.engine.sweep_expired_slots()), + Ok(2) + ); + assert_eq!( + fixture + .runtime + .block_on(fixture.engine.sweep_expired_slots()), + Ok(0) + ); + for (kind, key, _) in &allocated { + assert_eq!( + fixture.store.raw().load(*kind, key).expect("expired slot"), + None + ); + } + let after_sweep = fixture.runtime.block_on(replay( + &fixture.engine, + &source, + &acquired, + disclosure.as_ref(), + )); + assert_eq!(fixture.engine.execution_witness(), witness); + assert_eq!( + fixture.records(), + before, + "claims, allocations and charges remain recorded" + ); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + // A fresh proof for another operation cannot consume the original approval. + let substituted = fixture + .runtime + .block_on(bounded_input(&fixture.engine, "after-sweep")); + assert!( + fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &substituted.proof, + &substituted.action, + source.approval.clone() + )) + .is_err() + ); + assert_eq!(fixture.records(), before); + let reopened = fixture.change_and_reopen(Change::None); + fixture.clock.set(NOW + 86_401); + let reopened_witness = reopened.execution_witness(); + fixture + .runtime + .block_on(replay(&reopened, &source, &acquired, disclosure.as_ref())); + assert_eq!(reopened.execution_witness(), reopened_witness); + assert_eq!(fixture.records(), before); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + json!({"protocol":protocol.label(), "window_seconds":WINDOW, + "slot_expiry":expiry, "deleted_before_expiry":0, "deleted_at_expiry":2, + "original_approval_current_at_sweep":true, "native_snapshot":after_sweep, + "new_operation_with_old_approval_refused":true, + "claims_and_recorded_allocations_unchanged":true, + "replay_after_window_cleanup_and_full_authority_expiry_sends_nothing":true, + "provider_reads":1}) +} + +fn matrix(backend: Backend) { + let cases: Vec<_> = [ + Protocol::Acquisition, + Protocol::Acknowledged, + Protocol::LostAcknowledgement, + ] + .into_iter() + .map(|protocol| retained_case(backend, protocol)) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-retention/1", + "adapter":backend.label(), + "scope":"real native bounded proof/approval, HTTP and authenticated Unix delivery; expiry-slot sweep on file/TLS PostgreSQL; retained full records serve as replay tombstones", + "excluded":["epoch changes and rollback floors", "malicious whole-store rollback", "hostile OS or live provider qualification"], + "cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-retention-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write artifact"); + } + assert_eq!(std::fs::read(path).expect("retained artifact"), artifact); +} + +#[test] +fn native_file_retention_fixture_is_current() { + matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_retention_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 392070935..37f72509e 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -2482,12 +2482,35 @@ async fn conformance_sweep_bounds(backend: Backend) { expires_at: None, }; raw.insert(&connection).expect("connection"); + let permanent: Vec<_> = [ + GatewayRecordKind::CommissioningBudget, + GatewayRecordKind::EffectConfiguration, + GatewayRecordKind::EffectAllocation, + ] + .into_iter() + .enumerate() + .map(|(index, kind)| GatewayRecordEntry { + kind, + key: GatewayAttemptKey::from_bytes(test_key("sweep-durable", index, None)), + record: b"permanent-retention-control".to_vec(), + expires_at: None, + }) + .collect(); + for entry in &permanent { + raw.insert(entry).expect("permanent record"); + } assert_eq!(raw.sweep_expired(99, 10), Ok(0), "nothing expired yet"); assert_eq!(raw.sweep_expired(150, 3), Ok(3), "at most the limit"); assert_eq!(raw.sweep_expired(150, 10), Ok(2)); assert_eq!(raw.sweep_expired(150, 10), Ok(0)); assert_eq!(raw.sweep_expired(200, 10), Ok(2), "expiry is inclusive"); assert_eq!(raw.sweep_expired(u64::MAX >> 1, 10), Ok(0)); + for entry in &permanent { + assert_eq!( + raw.load(entry.kind, &entry.key).expect("permanent record"), + Some(entry.record.clone()) + ); + } assert!( raw.load(GatewayRecordKind::Attempt, &attempt) .expect("load") diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index de5aa5ead..d198c91c0 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -28,7 +28,7 @@ use std::{ fs::{self, File, OpenOptions}, io::{Read as _, Write as _}, path::{Component, Path, PathBuf}, - sync::Arc, + sync::{Arc, Mutex}, time::Instant, }; use tempfile::NamedTempFile; @@ -45,6 +45,9 @@ const LOCK_FILE: &str = ".replace.lock"; /// A load that keeps finding a crashed batch gives up after this many /// rollbacks rather than spin. const MAX_RECOVERY_ROUNDS: usize = 8; +/// Maintenance work is bounded even when most directory entries are retained +/// attempts or slots that have not expired. This cursor confers no authority. +const MAX_FILE_SWEEP_SCAN: usize = 4_096; const MAX_RECORD_BYTES: usize = auths_stores::MAX_GATEWAY_RECORD_BYTES; const MAX_BATCH_ENTRIES: usize = auths_stores::MAX_GATEWAY_BATCH_ENTRIES; /// A slot file wraps its record in base64 with its expiry. @@ -1439,12 +1442,23 @@ pub trait GatewayAttemptStore: Send + Sync { /// `.batch.json` listing each target and its bytes, then creates the /// targets, then deletes the batch file; a batch file found later means the /// batch never returned, so its targets are deleted. +/// Expiry maintenance inspects at most 4,096 directory entries per call and +/// stops between entries at the common two-second cooperative work deadline. +/// One transient directory cursor resumes later; reopening loses only progress. +/// It never sweeps attempts, configuration, commissioning or lifetime allocations. pub struct FileGatewayAttemptStore { root: PathBuf, + sweep_cursor: Mutex>, #[cfg(test)] io_fault: std::sync::Mutex, } +#[derive(Clone, Copy, Default)] +struct FileSweepProgress { + inspected: usize, + deleted: usize, +} + /// Private test-only failures at the actual adapter's I/O call sites. Shipping /// builds contain neither the selector nor mutable fault state. #[cfg(test)] @@ -1529,6 +1543,7 @@ impl FileGatewayAttemptStore { })?; let store = Self { root, + sweep_cursor: Mutex::default(), #[cfg(test)] io_fault: std::sync::Mutex::default(), }; @@ -1575,6 +1590,74 @@ impl FileGatewayAttemptStore { Ok(Some(bytes)) } + /// Resumes bounded maintenance under the same fence as every writer. + /// The in-memory iterator is only a progress hint: losing it can delay + /// reclamation, never remove a retained claim or recreate entry authority. + fn sweep_batch( + &self, + now: u64, + limit: usize, + scan_budget: usize, + ) -> Result { + let mut progress = FileSweepProgress::default(); + if limit == 0 || scan_budget == 0 { + return Ok(progress); + } + let _writer = self.exclusive()?; + let started = Instant::now(); + let mut cursor = self + .sweep_cursor + .lock() + .map_err(|_| GatewayAttemptError::Unavailable)?; + if cursor.is_none() { + *cursor = Some(fs::read_dir(&self.root).map_err(|_| GatewayAttemptError::Unavailable)?); + } + let result = (|| { + while progress.inspected < scan_budget.min(MAX_FILE_SWEEP_SCAN) + && progress.deleted < limit + && started.elapsed() < auths_stores::GATEWAY_FENCE_DEADLINE + { + let next = cursor + .as_mut() + .ok_or(GatewayAttemptError::Unavailable)? + .next(); + let entry = match next { + Some(Ok(entry)) => entry, + Some(Err(_)) => { + *cursor = None; + return Err(GatewayAttemptError::Unavailable); + } + None => { + *cursor = None; + break; + } + }; + progress.inspected += 1; + let name = entry.file_name(); + let Some(name) = name.to_str().filter(|name| { + (name.starts_with("slot-") || name.starts_with("sum-")) && valid_file_name(name) + }) else { + continue; + }; + let path = self.root.join(name); + let Some(bytes) = Self::read_file(&path, MAX_SLOT_FILE_BYTES)? else { + continue; + }; + if Self::decode_slot(&bytes)?.0 <= now { + fs::remove_file(&path).map_err(|_| GatewayAttemptError::Unavailable)?; + progress.deleted += 1; + } + } + Ok(progress) + })(); + // Sync even if a later directory/record read failed after a safe + // expired-slot deletion. Errors cannot turn unreadable state into absence. + if progress.deleted > 0 { + self.sync_root()?; + } + result + } + /// The bytes a record's file holds: the record itself, or for a slot /// the record wrapped with its expiry. fn file_bytes(entry: &GatewayRecordEntry) -> Result, GatewayAttemptError> { @@ -2038,37 +2121,8 @@ impl GatewayAttemptStore for FileGatewayAttemptStore { } fn sweep_expired(&self, now: u64, limit: usize) -> Result { - let _lock = self.exclusive()?; - let mut names: Vec = fs::read_dir(&self.root) - .map_err(|_| GatewayAttemptError::Unavailable)? - .map(|entry| { - entry - .map(|entry| entry.file_name().to_string_lossy().into_owned()) - .map_err(|_| GatewayAttemptError::Unavailable) - }) - .collect::, _>>()?; - names.retain(|name| { - (name.starts_with("slot-") || name.starts_with("sum-")) && valid_file_name(name) - }); - names.sort_unstable(); - let mut deleted = 0; - for name in names { - if deleted >= limit { - break; - } - let path = self.root.join(&name); - let Some(bytes) = Self::read_file(&path, MAX_SLOT_FILE_BYTES)? else { - continue; - }; - if Self::decode_slot(&bytes)?.0 <= now { - fs::remove_file(&path).map_err(|_| GatewayAttemptError::Unavailable)?; - deleted += 1; - } - } - if deleted > 0 { - self.sync_root()?; - } - Ok(deleted) + self.sweep_batch(now, limit, MAX_FILE_SWEEP_SCAN) + .map(|progress| progress.deleted) } } @@ -3573,3 +3627,7 @@ impl GatewayAttempts { #[cfg(test)] #[path = "entry_tests.rs"] mod entry_tests; + +#[cfg(test)] +#[path = "store_retention_tests.rs"] +mod retention_tests; diff --git a/product/runtime/auths-gateway/src/store_retention_tests.rs b/product/runtime/auths-gateway/src/store_retention_tests.rs new file mode 100644 index 000000000..2f71f8549 --- /dev/null +++ b/product/runtime/auths-gateway/src/store_retention_tests.rs @@ -0,0 +1,124 @@ +//! Maintenance work bounds and conservative retention in the real file adapter. +use super::*; + +fn fixture() -> (tempfile::TempDir, FileGatewayAttemptStore) { + let directory = tempfile::tempdir().expect("directory"); + let root = fs::canonicalize(directory.path()) + .expect("canonical") + .join("records"); + let store = FileGatewayAttemptStore::open(root).expect("store"); + (directory, store) +} + +fn entry(kind: GatewayRecordKind, byte: u8, expiry: Option) -> GatewayRecordEntry { + GatewayRecordEntry { + kind, + key: GatewayAttemptKey::from_bytes([byte; 32]), + record: format!("public-retention-fixture-{byte}").into_bytes(), + expires_at: expiry, + } +} + +#[test] +fn bounded_cursor_progress_preserves_every_durable_record_kind() { + let (directory, store) = fixture(); + let permanent: Vec<_> = [ + GatewayRecordKind::Attempt, + GatewayRecordKind::Connection, + GatewayRecordKind::CommissioningBudget, + GatewayRecordKind::EffectConfiguration, + GatewayRecordKind::EffectAllocation, + ] + .into_iter() + .enumerate() + .map(|(index, kind)| entry(kind, u8::try_from(index).expect("small"), None)) + .collect(); + for record in &permanent { + store.insert(record).expect("durable"); + } + let slots: Vec<_> = (20..28) + .map(|byte| { + entry( + if byte % 2 == 0 { + GatewayRecordKind::CountSlot + } else { + GatewayRecordKind::SumSlot + }, + byte, + Some(if byte < 24 { 100 } else { 200 }), + ) + }) + .collect(); + for record in &slots { + store.insert(record).expect("slot"); + } + assert_eq!( + store + .sweep_batch(100, 0, 3) + .expect("zero deletion") + .inspected, + 0 + ); + let mut deleted = 0; + for _ in 0..32 { + let batch = store.sweep_batch(100, 1, 3).expect("bounded batch"); + assert!(batch.inspected <= 3 && batch.deleted <= 1); + deleted += batch.deleted; + if deleted == 4 { + break; + } + } + assert_eq!( + deleted, 4, + "cursor advances past permanent and unexpired records" + ); + for record in &slots[4..] { + assert_eq!( + store.load(record.kind, &record.key).expect("future slot"), + Some(record.record.clone()) + ); + } + drop(store); // Cursor is deliberately not persisted; authority is persisted. + let reopened = FileGatewayAttemptStore::open( + fs::canonicalize(directory.path()) + .expect("canonical") + .join("records"), + ) + .expect("reopen"); + let mut deleted = 0; + for _ in 0..32 { + let batch = reopened + .sweep_batch(200, 2, 3) + .expect("bounded inclusive expiry"); + assert!(batch.inspected <= 3 && batch.deleted <= 2); + deleted += batch.deleted; + if deleted == 4 { + break; + } + } + assert_eq!(deleted, 4); + for record in &permanent { + assert_eq!( + reopened.load(record.kind, &record.key).expect("retained"), + Some(record.record.clone()) + ); + } + assert_eq!(reopened.sweep_expired(u64::MAX, 100), Ok(0)); +} + +#[test] +fn corrupt_slot_is_not_treated_as_expired_or_absent() { + let (_directory, store) = fixture(); + let record = entry(GatewayRecordKind::CountSlot, 42, Some(100)); + store.insert(&record).expect("slot"); + fs::write(store.path_for(record.kind, &record.key), b"invalid-slot").expect("damage"); + assert!(matches!( + store.sweep_expired(1000, 100), + Err(GatewayAttemptError::Corrupt) + )); + assert!(matches!( + store.load(record.kind, &record.key), + Err(GatewayAttemptError::Corrupt) + )); + assert!(store.path_for(record.kind, &record.key).exists()); +} diff --git a/qualification/reference/ap074_information_differential.py b/qualification/reference/ap074_information_differential.py index ce11c6fa7..0d27e86aa 100644 --- a/qualification/reference/ap074_information_differential.py +++ b/qualification/reference/ap074_information_differential.py @@ -309,7 +309,7 @@ def compare(native, reference): 'ap074.differential.crash-no-reentry') pairs.append({'adapter': adapter, 'contract': 'durable entry uncertainty retains charges and forbids old operation reentry', 'reference': reference['crash'], 'native': case}) - for protocol in ['acquisition-response', 'disclosure-ack', 'disclosure-unknown']: + for protocol in ['acquisition-response', 'disclosure-acknowledged', 'disclosure-unknown']: case = one(artifacts['replay']['value']['cases'], protocol=protocol, change='connection-revoked') require(case['journal_and_execution_witness_unchanged'] is True and case['no_replay_authentication_or_delivery'] is True diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index dcc373676..75e8ef7c6 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 409 +freeze_version = 410 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 409 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 153 +"auths.identity.protocol" = 154 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 409 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 150 +"auths.product.public-sdk-contract" = 151 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 409 +"auths.release.public-surface" = 410 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 9497d46b2..fbe008362 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 409, + "freezeVersion": 410, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 153, + "version": 154, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "cab906bb70abbacd4a904c1ff83d5e62e69f42fe8e219fe555f2a7c2b094c666" + "sha256": "8f8abbf6e5704af515b1da39a13b3bb17afd77e246cf698e3a266502ae571315" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 150, + "version": 151, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "0c859bf7d08c15cf009c8f14a2489b2f821c3d8ba5ce9df14af30e32e0139714" + "sha256": "578182fe32c85fd5a82be7a05ca35cc7750fc0ed366721ddbc4ae23fc973d564" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 409, + "version": 410, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "bcdbb560cdafa93e0fba1ae1fdcd2b7ae9650d6087d2d50e92a3120b37ac7a93" + "sha256": "2a014b701ef419329dfea0c284c89da5d606e00c3b80360eddb6162254ae9c86" } ] } From 49a5c0f046860a35fb3bf1952668e5938f1c13b7 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 21:18:30 +0000 Subject: [PATCH 096/136] fix(ci): repair differential worker lifetime and strict lint --- .../runtime/auths-gateway/src/native_differential_tests.rs | 2 +- qualification/reference/ap074_information_differential.py | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/product/runtime/auths-gateway/src/native_differential_tests.rs b/product/runtime/auths-gateway/src/native_differential_tests.rs index 071ea17c8..9ac7cf19c 100644 --- a/product/runtime/auths-gateway/src/native_differential_tests.rs +++ b/product/runtime/auths-gateway/src/native_differential_tests.rs @@ -381,7 +381,7 @@ fn family_corpus(family: Family) -> Value { .expect("same verified effect"); } Err(error) => { - row["native_result"] = serde_json::to_value(error).expect("native refusal") + row["native_result"] = serde_json::to_value(error).expect("native refusal"); } } cases.push(row); diff --git a/qualification/reference/ap074_information_differential.py b/qualification/reference/ap074_information_differential.py index 0d27e86aa..0b1c55122 100644 --- a/qualification/reference/ap074_information_differential.py +++ b/qualification/reference/ap074_information_differential.py @@ -198,8 +198,11 @@ def crash_reference(): token = challenge(store, task) context = multiprocessing.get_context('spawn') received, ready = context.Pipe(duplex=False) + # Keep the synchronization primitive alive in the parent until the + # spawned child exits; spawn reconstructs its semaphore by name. + hold = context.Event() worker = context.Process(target=crash_worker, - args=(str(path), task, token, ready, context.Event())) + args=(str(path), task, token, ready, hold)) worker.start() ready.close() try: From 74ce9f753faa6bf3f1cb065bc369f655e6c0b236 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 21:32:38 +0000 Subject: [PATCH 097/136] fix(gateway): bound file journal inventory queries --- ...ependent-mutation-differential-report.json | 2 +- compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 14 ++++ docs/plans/0074-hosted-evidence-76d008a0.md | 34 +++++++++ docs/plans/0074-implementation-status.md | 71 ++++++++++++++++++ .../0009-bound-effect-and-recovery.md | 4 + product/runtime/auths-gateway/src/store.rs | 52 +++++++++++-- .../src/store_retention_tests.rs | 74 +++++++++++++++++++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 ++-- 10 files changed, 256 insertions(+), 19 deletions(-) create mode 100644 docs/plans/0074-hosted-evidence-76d008a0.md diff --git a/bindings/fixtures/gateway/independent-mutation-differential-report.json b/bindings/fixtures/gateway/independent-mutation-differential-report.json index a86607673..cecfe9037 100644 --- a/bindings/fixtures/gateway/independent-mutation-differential-report.json +++ b/bindings/fixtures/gateway/independent-mutation-differential-report.json @@ -464,7 +464,7 @@ "schema": "auths.ap074-independent-mutation-differential/1", "scope": "test-only native verified compilation and response classification compared with retained independent references; no admission, provider I/O, production qualification or AP070 guarantee", "source_sha256": { - "product/runtime/auths-gateway/src/native_differential_tests.rs": "1c5993be7f284477952bd95ff36b38d1c426cee21ffbd533ec3886bdff5eb879", + "product/runtime/auths-gateway/src/native_differential_tests.rs": "4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1", "qualification/reference/airtable_record.py": "d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa", "qualification/reference/ap074_differential.py": "b2f88044a9131a3d62b11f842ea1f132f70563063cc45a25d48796641266127c", "qualification/reference/common.py": "604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce", diff --git a/compliance.toml b/compliance.toml index 5ea2c3f2f..52f60aea8 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1830,6 +1830,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_retention_tests.rs#postgres_native_retention_fixture_is_current", "product/runtime/auths-gateway/src/store_retention_tests.rs#bounded_cursor_progress_preserves_every_durable_record_kind", "product/runtime/auths-gateway/src/store_retention_tests.rs#corrupt_slot_is_not_treated_as_expired_or_absent", + "product/runtime/auths-gateway/src/store_retention_tests.rs#inventory_retains_the_exact_sorted_prefix_and_refuses_incomplete_scans", + "product/runtime/auths-gateway/src/store_retention_tests.rs#inventory_counts_nonclaim_entries_against_its_work_budget", "product/runtime/auths-gateway/src/engine.rs#slot_sweep_refuses_untrusted_required_time_without_deleting_state", "product/runtime/auths-gateway/src/entry_tests.rs#retained_native_authority_projection_is_required_and_bound", "product/runtime/auths-gateway/src/prerequisite_race_tests.rs#file_in_flight_prerequisite_cannot_poison_shared_parent", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index f20cb20ad..03ff93cbb 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1150,6 +1150,20 @@ required qualification with untrusted time refuses cleanup before storage work. An independently sampled wall clock must not age out a still-current effect window. This is not a new clock rollback detector or a whole-store rollback claim. +Read-only file inventory is bounded separately from expiry maintenance. It +retains at most 4,096 candidate keys in a max-heap, inspects at most 16,384 +directory entries plus one overflow probe, and observes the same cooperative +two-second work budget under the shared fence. Successful results retain the +original globally sorted smallest-key prefix. Larger output requests, excessive +directory work, unreadable entries or an expired work budget return unavailable; +they never return an apparently complete partial inventory. Irrelevant filenames +consume scan work too. Known-operation lookup, admission, replay and accounting +do not consult this inventory. The existing support-bundle consumer represents +an unavailable inventory as unavailable, distinct from a successfully empty list. +PostgreSQL keeps its existing indexed bounded query. A large file archive may +therefore require direct known-key inspection or the indexed adapter for a +complete inventory; no journal record is removed to make a query fit its budget. + Native file/PostgreSQL evidence acquires actual HTTP content using signed count/byte bounds and exact approval, then optionally performs authenticated Unix disclosure with ACK or ACK loss. Slots remain before their exact expiry diff --git a/docs/plans/0074-hosted-evidence-76d008a0.md b/docs/plans/0074-hosted-evidence-76d008a0.md new file mode 100644 index 000000000..4084344cd --- /dev/null +++ b/docs/plans/0074-hosted-evidence-76d008a0.md @@ -0,0 +1,34 @@ +# AP074 exact-head CI investigation — 76d008a0 + +Published source: `76d008a020e5b8e6c89e70bcb86ebc34e2c0e29d`, PR213. Repair: `037cb97f5bf2df186f3038ce75e5494d39230e34`, clean isolated checkout, not pushed. Main worktree, AP073 and AP070 source untouched. + +## Producer identity + +Observed PG and Python source-contract checkouts use PR merge `2507f1387b16fdc6e9da9c51b83130aaa1f32df0`. Its tree `fb2283aa7e1db3550a18ca3cc5cb49a1c532e5fa` equals the published source tree (fetched and diff verified). Source-head labels do not replace this actual producer identity. + +## Root matrix + +| Root | Hosted evidence | Repair and evidence | +| --- | --- | --- | +| Strict clippy rejects missing semicolon in test-only mutation generator | [preflight123733500686](https://github.com/auths-dev/auths-proof/actions/runs/40954513373/job/123733500686), native_differential_tests.rs:384, semicolon_if_nothing_returned | Add semicolon, no lint allowance. `cargo clippy --locked -p auths-gateway --lib --tests --all-features -- -D warnings` passes27.40s. Local log `/tmp/ap074-ci-76d0-gateway-clippy.log`. | +| Independent information crash reference loses spawned child before readiness | [PG123730998172](https://github.com/auths-dev/auths-proof/actions/runs/40954513640/job/123730998172), child spawn then parent EOFError | Retain parent ownership of Event while spawn child reconstructs its semaphore and until child exits. Exact full runner fails before change and passes22pairs after. Real SIGKILL, abandoned claim, unknown attempt, no reentry/release and conservation assertions unchanged. | +| Downstream required implementations skipped after preflight failure | [authoritative rollup123736259829](https://github.com/auths-dev/auths-proof/actions/runs/40954513373/job/123736259829), REQUIRED=true/RUN_RESULT=skipped | Fail-closed dependency rollups, not additional independent source defects. No authoritative formal/Kani/translation/compliance/security acceptance claimed. | + +## Executed evidence + +- PG job actually passed all24 explicit native selectors, including both retention fixtures, before installing the SDK and failing the new information runner. The native log is artifact12933406462, downloaded to `/tmp/ap074-ci-76d0-pg-native.zip` and extracted `/tmp/ap074-ci-76d0-native.log`. Subsequent physical/WAL restore stages were skipped after failure; these are unexecuted on this head. +- [Python source job123730999956](https://github.com/auths-dev/auths-proof/actions/runs/40954513619/job/123730999956) passed the exact native mutation generator and independent comparator:28requests,26responses,2families. Report artifact12934145521 ZIP SHA256 `a5e66619c969bc7d0067e22bff90996bbdf8fd21e9e80025813a927e832605ee`; downloaded and verified. Report `/tmp/ap074-ci-76d0-mutation-report.json`. +- [Reference job123730998799](https://github.com/auths-dev/auths-proof/actions/runs/40954513618/job/123730998799) ran104 source-only unit tests successfully, including information parser controls and mutation comparator negatives. Those synthetic parser fixtures establish rejection controls, not native execution. +- Current-head macOS wheel artifact12933058235 ZIP SHA256 `17c3659e6dbacc1459427daddbf703a3e301c5bed36250dc17b4615ba06d9456` was verified and installed without dependencies/network into `/tmp/ap074-ci-76d0-python`. Exact failed runner replay: + +```text +/tmp/ap074-ci-76d0-python/bin/python qualification/reference/ap074_information_differential.py --native-log /tmp/ap074-ci-76d0-native.log --output /tmp/ap074-ci-76d0-information-repro-current-sdk.json +``` + +Result:22pairs,2adapters. This is local repaired reference execution against actual hosted native evidence; it is not a passed hosted information comparator or fresh execution of24native cases. The unchanged AP070 reference emitted Python3.13 SQLite ResourceWarnings during focused tests; no AP070 code changed. + +## Terminal matrix + +All96checks terminal:65success,12failure,19skipped. Fourteen workflow records:11success,2failure(CI and PG),1conditional skip(custody-live). Independent Python/platform matrix, TypeScript, SDK recipes, installed demos, isolation, operator package and reference simulations pass. [Formal-fast123733500692](https://github.com/auths-dev/auths-proof/actions/runs/40954513373/job/123733500692) passed and explicitly records executed-no-qualification. [Formal-translation rollup123739605415](https://github.com/auths-dev/auths-proof/actions/runs/40954513373/job/123739605415) records REQUIRED=true/RUN_RESULT=skipped; [CI-qualified123739647628](https://github.com/auths-dev/auths-proof/actions/runs/40954513373/job/123739647628) failed closed. These are dependencies of the identified preflight failure, not additional source roots. Authoritative formal/translation/Kani and final qualified evidence did not execute successfully on this revision. No jobs rerun or cancelled. No live provider calls, unattended consent, new PR, merge or deploy. + +The two-file repair is one coherent batch. Parent owns combined source closure, independent mutation report source hashes and semantic freeze regeneration. Full AP074 acceptance remains incomplete. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 7f883e5ba..a72a731b7 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2823,6 +2823,77 @@ not a runtime protocol change. Required semantic inventory regeneration advances freeze410 with only reported identity154/public-SDK151/public-surface410 inputs. Effect/compiler/attempt schemas and translated pure predicates stay unchanged. +## Bounded inventory and first hosted differential results + +Published `76d008a020e5b8e6c89e70bcb86ebc34e2c0e29d` has real hosted progress, +not complete qualification. Python source-contract job123730999956 executed +the exact native mutation generator and independent comparison: 28 request and +26 response cases passed; report artifact12934145521 was checksum verified by +the CI subagent. PG job123730998172 executed all 24 selected native cases, +including the two new retention generators, before the new information runner +failed during spawned crash-worker startup. Its downstream restore stages were +skipped and are not passed evidence. + +The CI repair retains a parent reference to the multiprocessing Event until +the real crash worker exits; a temporary Event could lose its semaphore before +spawn unpickling. The full 22-pair information runner passed a focused reproduction +using the downloaded hosted native log and current hosted SDK wheel; no AP070 +source or SIGKILL/accounting assertion changed. Source-only reference discovery +still requires no installed SDK; its existing 104-test suite passed. Strict +repository preflight found one additional test-generator semicolon lint error; +fixing it requires no allowance or predicate change. The CI subagent's focused +all-feature gateway library/test clippy reproduction passed. Both repairs were +committed together as `037cb97f` and integrated locally as `49a5c0f0`; publication +and new exact-head hosted confirmation remain required. The independent mutation +comparison report was regenerated because it hashes that generator source. + +The next bounded-read issue was file `claimed_keys`: it collected and sorted +the entire directory before truncating. The new implementation keeps at most +4,096 candidate keys in a max-heap, preserving exactly the original sorted +smallest-key prefix when successful. It inspects at most 16,384 directory entries +plus one overflow probe, with the shared two-second cooperative work budget. +Irrelevant filenames count against work. Oversized requests or incomplete scans +fail unavailable without a partial or apparently empty inventory. Direct +known-operation loads, admission and replay are unchanged. The support consumer +already distinguishes unavailable from empty inventory. Large file archives can +exceed this explicit diagnostic-query limit; no records are discarded to fit it. + +Two controls are authored for exact prefix/cardinality, zero/excess limits, +incomplete scans, nonclaim entries and unchanged direct lookup. They have not +yet executed locally or hosted. Final A19/A21 closure still requires actual +new-head report execution and the remaining scope-specific evidence; neither +the local reproduction nor a parent workflow name replaces that evidence. + +The combined worktree's exact failed-check reproduction, +`cargo clippy --locked -p auths-gateway --lib --tests --all-features -- -D warnings`, +passed in 13.23 seconds; this checks the integrated lint repair and new inventory +source but does not execute those unit tests. Independent mutation report +construction passed again (28/26). Required source-closure construction emitted +the same `a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825`; +it is not a new Lean/Kani/translation result. Semantic inventory construction +advances freeze411 and only reported identity155/public-SDK152/public-surface411. + +The prior cohort is now terminal: 96 checks = 65 success, 12 failure, 19 skipped; +14 workflows = 11 success, CI/PG failed, custody conditionally skipped. The +required implementation/formal rollups failed closed after the identified +preflight root; formal-fast passed explicitly without qualification. All 24 +selected native cases passed in PG before the reference failure. Full provenance +and exact PR-merge/tree identities are preserved in +[the 76d report](0074-hosted-evidence-76d008a0.md). No healthy jobs were cancelled. + +Criterion-specific audit must avoid treating unrelated open gates as absent +native evidence. A09 already has 56 actual disclosure crash histories and 30 +late-ACK histories across both adapters, with 300 independently re-signed or +signature-damaged substitutions. Source `substituted_acks` exercises effect +(including operation identity), source effect, content, channel, delivery +instance, recipient/key, projection, byte ceilings/acknowledged length and +signature, asserting unchanged raw journal and charge records after every +refusal. The positive late/repeated original ACK controls refine once and +preserve charges. These native generators passed on 76d; the next exact-head +run must confirm them before current-head closure. Broader language/containment +gates remain independently mandatory under A17/A18/A22 rather than disappearing +from the full objective. + ## Phase gates | Phase | State | Outstanding gate | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 08112bc30..f5a5468ee 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -121,6 +121,10 @@ File maintenance uses a nonauthoritative iterator (4,096 inspected directory entries and a cooperative two-second work budget), not a second journal or a full-directory sort. PostgreSQL retains its indexed LIMIT and common writer fence. The engine samples the existing deployment/effect clock for both stores. +File inventory preserves its sorted-prefix contract using a bounded heap and +separate output/scan budgets (4,096 keys, 16,384 names plus one overflow probe). +If it cannot finish, it returns unavailable instead of a partial inventory; +direct journal lookup and all admission/recovery decisions remain independent. The source and native retention fixtures are recorded in the ledger; they do not establish clock rollback detection, all reserved/mutation histories or malicious whole-store rollback protection. diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index d198c91c0..91373d890 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -24,7 +24,7 @@ use base64ct::{Base64, Encoding as _}; use serde::{Deserialize, Serialize}; use sha2::{Digest as _, Sha256}; use std::{ - collections::BTreeMap, + collections::{BTreeMap, BinaryHeap}, fs::{self, File, OpenOptions}, io::{Read as _, Write as _}, path::{Component, Path, PathBuf}, @@ -48,6 +48,10 @@ const MAX_RECOVERY_ROUNDS: usize = 8; /// Maintenance work is bounded even when most directory entries are retained /// attempts or slots that have not expired. This cursor confers no authority. const MAX_FILE_SWEEP_SCAN: usize = 4_096; +/// Exact sorted inventory is read-only, never an authority lookup. Above these +/// explicit work/output bounds it refuses rather than report a partial prefix. +const MAX_FILE_INVENTORY_SCAN: usize = 16_384; +const MAX_FILE_INVENTORY_KEYS: usize = 4_096; const MAX_RECORD_BYTES: usize = auths_stores::MAX_GATEWAY_RECORD_BYTES; const MAX_BATCH_ENTRIES: usize = auths_stores::MAX_GATEWAY_BATCH_ENTRIES; /// A slot file wraps its record in base64 with its expiry. @@ -1429,7 +1433,8 @@ pub trait GatewayAttemptStore: Send + Sync { /// a digest and names no operation. /// /// # Errors - /// Returns [`GatewayAttemptError::Unavailable`] when storage fails. + /// Returns [`GatewayAttemptError::Unavailable`] when storage fails or its + /// bounded inventory cannot be completed. No partial inventory is returned. fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError>; } @@ -1446,6 +1451,10 @@ pub trait GatewayAttemptStore: Send + Sync { /// stops between entries at the common two-second cooperative work deadline. /// One transient directory cursor resumes later; reopening loses only progress. /// It never sweeps attempts, configuration, commissioning or lifetime allocations. +/// Read-only inventory keeps at most 4,096 candidate keys and scans at most +/// 16,384 directory entries plus one overflow probe. Above that bound, or after +/// the cooperative two-second work deadline, it fails without partial results. +/// Direct operation lookups remain independent of inventory size. pub struct FileGatewayAttemptStore { root: PathBuf, sweep_cursor: Mutex>, @@ -2161,9 +2170,30 @@ impl Drop for PostgresGatewayAttemptStore { impl FileGatewayAttemptStore { fn claimed_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.claimed_keys_with_budget(limit, MAX_FILE_INVENTORY_SCAN) + } + + fn claimed_keys_with_budget( + &self, + limit: usize, + scan_budget: usize, + ) -> Result, GatewayAttemptError> { + if limit > MAX_FILE_INVENTORY_KEYS { + return Err(GatewayAttemptError::Unavailable); + } + if limit == 0 { + return Ok(Vec::new()); + } let _lock = self.shared()?; - let mut keys = Vec::new(); - for entry in fs::read_dir(&self.root).map_err(|_| GatewayAttemptError::Unavailable)? { + let started = Instant::now(); + let mut keys = BinaryHeap::with_capacity(limit); + let entries = fs::read_dir(&self.root).map_err(|_| GatewayAttemptError::Unavailable)?; + for (inspected, entry) in entries.enumerate() { + if inspected >= scan_budget.min(MAX_FILE_INVENTORY_SCAN) + || started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE + { + return Err(GatewayAttemptError::Unavailable); + } let name = entry .map_err(|_| GatewayAttemptError::Unavailable)? .file_name(); @@ -2175,11 +2205,19 @@ impl FileGatewayAttemptStore { if let Some(key) = key { let mut bytes = [0_u8; 32]; hex::decode_to_slice(key, &mut bytes).map_err(|_| GatewayAttemptError::Corrupt)?; - keys.push(GatewayAttemptKey(bytes)); + let key = GatewayAttemptKey(bytes); + if keys.len() < limit { + keys.push(key); + } else if keys.peek().is_some_and(|largest| key < *largest) { + let _ = keys.pop(); + keys.push(key); + } } } - keys.sort_unstable(); - keys.truncate(limit); + let keys = keys.into_sorted_vec(); + if started.elapsed() >= auths_stores::GATEWAY_FENCE_DEADLINE { + return Err(GatewayAttemptError::Unavailable); + } Ok(keys) } } diff --git a/product/runtime/auths-gateway/src/store_retention_tests.rs b/product/runtime/auths-gateway/src/store_retention_tests.rs index 2f71f8549..8e3a228a9 100644 --- a/product/runtime/auths-gateway/src/store_retention_tests.rs +++ b/product/runtime/auths-gateway/src/store_retention_tests.rs @@ -122,3 +122,77 @@ fn corrupt_slot_is_not_treated_as_expired_or_absent() { )); assert!(store.path_for(record.kind, &record.key).exists()); } + +#[test] +fn inventory_retains_the_exact_sorted_prefix_and_refuses_incomplete_scans() { + let (_directory, store) = fixture(); + let claims: Vec<_> = [9, 1, 7, 2, 4] + .into_iter() + .map(|byte| entry(GatewayRecordKind::Attempt, byte, None)) + .collect(); + for claim in &claims { + store.insert(claim).expect("claim"); + } + store + .insert(&entry(GatewayRecordKind::Connection, 42, None)) + .expect("connection"); + let mut expected: Vec<_> = claims.iter().map(|claim| claim.key).collect(); + expected.sort_unstable(); + for limit in 0..=claims.len() + 1 { + assert_eq!( + store.attempt_keys(limit).expect("inventory"), + expected[..limit.min(expected.len())] + ); + } + assert!( + matches!( + store.claimed_keys_with_budget(2, 3), + Err(GatewayAttemptError::Unavailable) + ), + "never return a prefix from an incomplete scan" + ); + assert!(matches!( + store.attempt_keys(MAX_FILE_INVENTORY_KEYS + 1), + Err(GatewayAttemptError::Unavailable) + )); + assert_eq!( + store.claimed_keys_with_budget(0, 0).expect("zero query"), + Vec::new() + ); + for claim in &claims { + assert_eq!( + store.load(claim.kind, &claim.key).expect("direct lookup"), + Some(claim.record.clone()) + ); + } + assert_eq!( + store + .attempt_keys(claims.len()) + .expect("retry bounded read"), + expected + ); +} + +#[test] +fn inventory_counts_nonclaim_entries_against_its_work_budget() { + let (_directory, store) = fixture(); + let claim = entry(GatewayRecordKind::Attempt, 5, None); + store.insert(&claim).expect("claim"); + // An irrelevant filename must consume work too; filtering first and then + // limiting matching claims would preserve the unbounded-directory bug. + for index in 0..8 { + fs::write(store.root.join(format!("other-{index}")), b"").expect("entry"); + } + assert!(matches!( + store.claimed_keys_with_budget(1, 4), + Err(GatewayAttemptError::Unavailable) + )); + assert_eq!( + store.load(claim.kind, &claim.key).expect("retained claim"), + Some(claim.record) + ); + assert_eq!( + store.attempt_keys(1).expect("complete scan"), + vec![claim.key] + ); +} diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 75e8ef7c6..d4e5670aa 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 410 +freeze_version = 411 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 410 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 154 +"auths.identity.protocol" = 155 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 410 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 151 +"auths.product.public-sdk-contract" = 152 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 410 +"auths.release.public-surface" = 411 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index fbe008362..72b805e41 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 410, + "freezeVersion": 411, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 154, + "version": 155, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "8f8abbf6e5704af515b1da39a13b3bb17afd77e246cf698e3a266502ae571315" + "sha256": "689aa38891d2ac72a77da0fce985a2833487969c0ddf0c97d74cfcd17e5025e7" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 151, + "version": 152, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "578182fe32c85fd5a82be7a05ca35cc7750fc0ed366721ddbc4ae23fc973d564" + "sha256": "51e50cfd0e265df8b0a16d4e07326875dae9f85d435ea0a816d5f62d813a739b" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 410, + "version": 411, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "2a014b701ef419329dfea0c284c89da5d606e00c3b80360eddb6162254ae9c86" + "sha256": "dd18e8627fcc3214ec5262917dd91455f7f86d16298791a5410fe95b6ac2aef9" } ] } From 41763d5ab50dd07566bc6595dacae3599f976c08 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 22:06:43 +0000 Subject: [PATCH 098/136] fix(gateway): fence epoch activation across stale hosts --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/effect-configuration.json | 8 +- .../gateway/native-epoch-fence-file.json | 56 ++++ .../gateway/native-epoch-fence-postgres.json | 56 ++++ compliance.toml | 6 +- ...017-bound-effect-and-recovery-ownership.md | 8 +- docs/plans/0074-differential-contracts.md | 27 +- docs/plans/0074-implementation-status.md | 67 ++++- .../0009-bound-effect-and-recovery.md | 18 ++ ...ound-effects-and-recovery-state-machine.md | 9 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/bin/auths-gateway.rs | 2 +- .../auths-gateway/src/configuration.rs | 164 +++++++---- product/runtime/auths-gateway/src/effect.rs | 8 +- .../src/effect_candidate_tests.rs | 2 + .../auths-gateway/src/effect_content_tests.rs | 1 + .../src/effect_disclosure_journal_tests.rs | 1 + product/runtime/auths-gateway/src/engine.rs | 1 + .../auths-gateway/src/native_epoch_tests.rs | 261 ++++++++++++++++++ .../src/native_information_replay_tests.rs | 3 + .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/tests/candidate_cli.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 24 files changed, 645 insertions(+), 83 deletions(-) create mode 100644 bindings/fixtures/gateway/native-epoch-fence-file.json create mode 100644 bindings/fixtures/gateway/native-epoch-fence-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_epoch_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 81925c942..775ed97ef 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -72,6 +72,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::retention_tests::native_file_retention_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::retention_tests::postgres_native_retention_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::epoch_tests::native_file_epoch_fence_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::epoch_tests::postgres_native_epoch_fence_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres diff --git a/bindings/fixtures/gateway/effect-configuration.json b/bindings/fixtures/gateway/effect-configuration.json index 5783a0319..8fc8f8edc 100644 --- a/bindings/fixtures/gateway/effect-configuration.json +++ b/bindings/fixtures/gateway/effect-configuration.json @@ -1,7 +1,7 @@ { - "schema": "auths.effect-configuration-fixture/1", + "schema": "auths.effect-configuration-fixture/2", "scope": "native configuration encoding and revision identity; no entry claim", - "key_hex": "0a3bda35987386948830389c2d1906d6e256d391582a910aa5c31928bcb3af16", - "record_canonical": "{\"installation\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"qualification\":{\"bundle\":null,\"memory\":{\"accepted_index_issued_at\":0,\"accepted_revocation_sequence\":0,\"blocked\":false,\"revoked_qualifications\":[],\"revoked_signers\":[]}},\"revision\":1,\"schema\":\"auths.effect-configuration/1\"}", - "revision_token_hex": "a2585b2ebe8247f93e4dacb179e0c1e6bbf69b3301c98e4115b0b5827ee09fe1" + "configuration_key_sha256": "sha256:50533db03f8136227439a0c1a63b8e829bf48ba405b57edadb2e4f889d150bc4", + "record_canonical": "{\"epoch\":1,\"installation\":[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],\"qualification\":{\"bundle\":null,\"memory\":{\"accepted_index_issued_at\":0,\"accepted_revocation_sequence\":0,\"blocked\":false,\"revoked_qualifications\":[],\"revoked_signers\":[]}},\"revision\":1,\"schema\":\"auths.effect-configuration/2\"}", + "revision_token_sha256": "sha256:152bef9fd72de7dc523b2bb6092e438f58ded6926d614d9f06674be981e5b39c" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-epoch-fence-file.json b/bindings/fixtures/gateway/native-epoch-fence-file.json new file mode 100644 index 000000000..99f23c7bf --- /dev/null +++ b/bindings/fixtures/gateway/native-epoch-fence-file.json @@ -0,0 +1,56 @@ +{ + "schema": "auths.native-epoch-fence/1", + "adapter": "file", + "case": { + "activated_epoch": 2, + "one_shared_partition_control": true, + "cached_old_epoch_entry_refused": true, + "same_native_proof_still_authorized": true, + "old_approval_new_epoch_refused": true, + "fresh_operator_downgrade_refused": true, + "stale_operator_review_refused": true, + "old_and_new_epoch_history_retained": true, + "historical_replay_recreates_no_permit_or_charge": true, + "previous_epoch_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "current_epoch_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "lifetime_allocation_slots": [ + 0, + 1 + ], + "provider_reads": 2 + }, + "scope": "actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", + "excluded": [ + "malicious store rollback without an independent anchor", + "all protocol race schedules", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-epoch-fence-postgres.json b/bindings/fixtures/gateway/native-epoch-fence-postgres.json new file mode 100644 index 000000000..e6a0334b8 --- /dev/null +++ b/bindings/fixtures/gateway/native-epoch-fence-postgres.json @@ -0,0 +1,56 @@ +{ + "schema": "auths.native-epoch-fence/1", + "adapter": "postgres", + "case": { + "activated_epoch": 2, + "one_shared_partition_control": true, + "cached_old_epoch_entry_refused": true, + "same_native_proof_still_authorized": true, + "old_approval_new_epoch_refused": true, + "fresh_operator_downgrade_refused": true, + "stale_operator_review_refused": true, + "old_and_new_epoch_history_retained": true, + "historical_replay_recreates_no_permit_or_charge": true, + "previous_epoch_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "current_epoch_snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "lifetime_allocation_slots": [ + 0, + 1 + ], + "provider_reads": 2 + }, + "scope": "actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", + "excluded": [ + "malicious store rollback without an independent anchor", + "all protocol race schedules", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 52f60aea8..5216bc087 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1641,7 +1641,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/6", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/1", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1649,7 +1649,7 @@ signature_families = ["ed25519-v1", "p256-sha256-v1"] profiles = ["auths.mcp/2"] transports = ["uid-bound-unix-disclosure","bounded-https", "postgresql-tls", "loopback-http-development"] configuration_inputs = ["installed-effect-policy", "operator-configuration-revision-and-candidate", "commissioning-witness-file", "commissioning-binding", "commissioning-permit", "retained-commissioning-budget-floor", "operator-approved-recipe", "profile-lock", "independently-provisioned-trust", "connection-binding", "observer-anchor", "observer-signing-key", "deployment-kind", "operator-attestation", "app-capacity", "development-shared-file-store", "postgresql-store-configuration", "audit-trust-and-observer-pins", "qualification-policy", "recipe-family", "provider-contract-id", "qualification-release-inputs", "deployment-clock"] -security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] +security_state = ["immutable-recipient-authentication", "one-use-disclosure-grant","private-per-acquisition-content-keys", "protected-content-projection-and-refusal", "content-source-lifetime-allocations", "private-content-response-metadata", "recovery-credential-prerequisite-allocations", "fixed-window-recovery-call-and-response-byte-slots", "source-lifetime-recovery-count-and-byte-allocations", "typed-mutation-acquisition-disclosure-journal", "shared-effect-configuration", "monotonic-shared-admission-epoch", "monotonic-shared-qualification-memory", "configuration-saturation-denial", "permanent-commissioning-consumption", "commissioning-revocation-and-time-floor", "durable-credential-cleanup-notes", "host-generation-floor", "recipe-digest", "logical-operation-claims", "credential-reference-generation", "shared-connection-record", "credential-generation", "in-flight-entry-count", "echo-bound-provider-evidence", "observer-signing-seed", "custody-held-observer-key", "principal-separation", "key-identity-separation", "pre-entry-evidence", "relative-ceiling-basis", "gateway-record-batches", "link-subject-count-and-sum-slots", "verified-qualification-index", "remembered-revocations", "accepted-revocation-sequence", "gateway-semantic-closure"] [packages.auths-gateway.claims] # Evidence coverage: content-only-installation. @@ -1673,6 +1673,8 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", + "product/runtime/auths-gateway/src/native_epoch_tests.rs#native_file_epoch_fence_fixture_is_current", + "product/runtime/auths-gateway/src/native_epoch_tests.rs#postgres_native_epoch_fence_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/recipe/tests.rs#three_independent_recipes_compile_without_provider_code", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 03ff93cbb..faebf9468 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -240,8 +240,12 @@ not claim this final-entry guarantee. ## Shared installed configuration and permanent qualification memory The sixth closed gateway record kind, `effect-configuration`, is non-expiring. -Its key commits to namespace, partition and epoch independently of the candidate -configuration. The installed pin commits to recipe, native verifier trust, +Its key commits to namespace and partition independently of the candidate +configuration and epoch. Configuration schema `/2` stores the active epoch; +configuration-key domain `/2` makes old and new hosts contend on one control. +Operator activation cannot decrease that epoch, including with a fresh review +token. Installation manifest `/7` rejects obsolete disposable installations; +there is no old-schema reader or migration path. The installed pin commits to recipe, native verifier trust, operator effect policy, connection identity, workload, profile, qualification contract and gateway semantic closure. Bound-effect `/2` includes that pin; compiler identity `/2` rejects approvals over the earlier binding format. diff --git a/docs/plans/0074-differential-contracts.md b/docs/plans/0074-differential-contracts.md index a4577ed48..f32435fb8 100644 --- a/docs/plans/0074-differential-contracts.md +++ b/docs/plans/0074-differential-contracts.md @@ -43,7 +43,7 @@ both artifacts. The report hashes the exact native corpus and relevant source files. A checked-in report alone is not fresh execution evidence. Required hosted results must identify the actual tested source/PR-merge revision and run. -## Acquisition/disclosure comparison (authored; hosted execution pending) +## Acquisition/disclosure comparison (hosted execution on 74ce9f75) AP070 remains an independently implemented application-owned Python/SQLite reference. `ap074_information_differential.py` executes its unchanged admission, @@ -75,8 +75,21 @@ Missing, duplicated, ignored and zero-pass results refuse comparison; parser controls use explicitly synthetic logs and make no runtime claim themselves. The report records tested commit/run, native log/artifact hashes, unchanged reference source hashes and 22 paired comparisons. This avoids rerunning the -native matrices merely to perform the independent comparison. The new runner -and parser test have not yet executed; the hosted report is required evidence. +native matrices merely to perform the independent comparison. On published `74ce9f753faa6bf3f1cb065bc369f655e6c0b236`, +[PG job123745460518](https://github.com/auths-dev/auths-proof/actions/runs/40958689260/job/123745460518) +passed the required native selectors and all 22 information comparisons. Its +report identifies actual PR merge `df0cc98e6eae440db67038c4f552b74e1d64b90f`, +whose tree matches the published source. Artifact12934958430 was downloaded and +its ZIP SHA256 verified as +`c7af0195a0a6645e2cc6fa58f6b0ada451b46692c98649edfac35d4b551b08c0`. +All five recorded reference/comparator source hashes still match this checkout. +Source-only reference job123745461358 passed 104 tests including the parser +refusal controls. Python source job123745459370 separately passed native mutation +construction and the 28/26 independent comparison; artifact12933979778 has ZIP +SHA256 `3437045757e96a2f1020cb729935e280a2ad8758c125646608f9f766ec1143e0`. +Its seven recorded generator/reference/comparator source hashes also match this +checkout. These observations establish execution on that head; subsequent source +changes and the final completed PR head require their own hosted confirmation. Comparisons must preserve these differences: @@ -95,5 +108,9 @@ Comparisons must preserve these differences: Native current-authority gates and AP070 task expiry/revision are compared only on the shared fail-closed state property; their authority models are different. -All remaining A19 requirements stay open until actual hosted execution and -coverage audit establish them. No managed guarantee is claimed for AP070. +The executed corpus covers the named A19 overlap: two mutation recipes with +distinct locator/recovery capabilities, plus acquisition/disclosure state, +capacity, crash and replay contracts. Differences above are required assertions, +not unexplained drift. Final-head confirmation remains mandatory. Broader native +guard/fault schedules and installed journeys remain separately required by their +acceptance rows. No managed guarantee is claimed for AP070. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index a72a731b7..698ee1cb9 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2894,6 +2894,69 @@ run must confirm them before current-head closure. Broader language/containment gates remain independently mandatory under A17/A18/A22 rather than disappearing from the full objective. +## Native epoch control and exact-head evidence audit + +On published `74ce9f753faa6bf3f1cb065bc369f655e6c0b236`, PostgreSQL job +123745460518 executed all 24 explicit native selectors with one matched, +nonignored passing test each, then passed the independent information comparison +(22 pairs across both adapters) and physical/WAL restore controls. Python source +job123745459370 passed the native mutation generator and independent comparison +(28 request / 26 response cases); source-only reference job123745461358 passed +104 tests, including parser/contract adversarial controls. Artifact checksums and +merge-tree provenance belong in the cohort report. These are executed evidence +for that published revision, not verification of subsequent epoch changes. + +The current epoch regression first failed against the prior implementation: +configuration keys included epoch, so a new epoch selected a separate active +control. The fix keeps one control per namespace/partition, stores its active +epoch and permits only nondecreasing explicit operator activation under the +existing writer fence. Cached old hosts and old exact approvals cannot authorize +new entry after activation. Historical operation keys remain epoch-scoped; +retained facts confer no permit. Private configuration/key `/2` and installation +manifest `/7` directly reject obsolete disposable state without migration. + +Both new native artifact constructors passed locally against file and TLS +PostgreSQL (one test, zero failed/ignored each, 0.33s and 0.40s respectively). +They use actual signed proofs, exact approvals, real HTTP and two engine/store +instances, reject old-host entry and fresh-token epoch downgrade, preserve both +epochs' histories and assert lifetime allocation slots `[0, 1]`. They establish +this concrete activation order, not every concurrent schedule or malicious +store-rollback detection. The unchanged trusted-store assumption and independent +rollback-anchor exclusion remain explicit. Shared configuration conformance now +also authors epoch advancement, retained revocations and lower-epoch refusal; +its new behavior awaits hosted execution. Canonical configuration construction +passed with obsolete-schema, missing/null/zero/out-of-range epoch refusals. + +The differential coverage audit confirms that the hosted A19 corpus exercises +two mutation recipes with distinct recovery capabilities plus the declared +acquisition/disclosure overlap. All twelve generator/reference/comparator source +hashes in the downloaded information and mutation reports match the current +checkout. The contracts document now distinguishes executed74ce evidence from +pending subsequent/final-head verification instead of calling that runner unrun. + +The PostgreSQL workflow now explicitly selects both new epoch constructors in +addition to the prior 24. Existing selectors and independent comparison parser +requirements are preserved. The exact hosted strict-clippy failure reproduction +passed after factoring the longer test history into focused helpers; no lint +allowance or acceptance predicate was weakened. The stale gateway semantic +closure was regenerated and passed a rebuilt non-update verification; this +repairs the previous cohort's sole implementation root. This gateway closure is +distinct from the formal translation source closure and proves no new theorem. + +Staged Gitleaks v8.28.0 found two public configuration digests. The fixture +generator now uses explicit `sha256:` values and digest field names under private +fixture schema `/2`; regeneration and the repeated staged scan pass without a +new ignore. Semantic metadata construction advances freeze412 and only reported +identity156/public-SDK153/public-surface412. Formal translation source closure +remains unchanged; metadata generation is not fresh proof execution. + +Full AP074 completion remains open: installed authenticated managed UI/language +journeys, remaining mutation/disclosure concurrency and adverse durability cases, +complete negative/containment inventories, reconciliation limits and escalation, +generated durable histories/formal linkage, supported rollback floors, bounded +performance and all required hosted checks on the final completed head. AP070 +and the paused AP073 checkout remain unchanged by this batch. + ## Phase gates | Phase | State | Outstanding gate | @@ -2930,9 +2993,9 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / mutation reference comparison constructed; 22 paired post-authorization information comparisons authored against unchanged AP070 and native file/PostgreSQL histories / 28 request and 26 response mutation cases constructed locally, including valid JSON at/above both byte bounds; information comparison unrun | Execute new independent information runner and parser controls plus exact-head hosted mutation corpus; complete coverage audit; AP070 source stays independent without managed guarantees | +| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / independent mutation and post-authorization information comparisons against unchanged references / hosted74ce mutation 28 requests + 26 responses, information 22 pairs across both adapters and 104 source/parser controls passed | Named A19 contracts audited in the differential-contracts document; final-head confirmation remains required, with AP070 independence and divergent claims retained | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | -| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded file maintenance and shared effect clock; native read/release expiry cleanup / six file/TLS PostgreSQL histories constructed, with retained replay and unchanged recorded charges after cleanup/reopen | Hosted execution, reserved/mutation retention, epoch/stale configuration and supported rollback-floor evidence remain required | +| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded maintenance/shared clock and one active epoch control per partition / hosted74ce six native read/release cleanup histories passed; two new file/TLS PostgreSQL epoch histories constructed locally preserve replay and lifetime slots | New-head hosted epoch verification, reserved/mutation retention, concurrent epoch/configuration schedules and supported rollback-floor evidence remain required | | A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index f5a5468ee..279eb3ef6 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -808,3 +808,21 @@ Native acquisition/disclosure, full installed managed journey/UI, two mutation recipe differentials, every file/PostgreSQL concurrency/crash/fault case and all formal/performance/hosted gates remain mandatory. Google metadata, OAuth refresh and migration are deferred until explicitly productizing managed Google access. + +### One active epoch per managed partition + +Epoch activation reuses the existing canonical configuration record, operator +review token and bounded writer-fence CAS. Configuration key `/2` excludes epoch, +so changing an epoch cannot create a second independently active control for +the same namespace/partition. Record `/2` binds the active epoch and rejects a +lower candidate even with a fresh review token. Permanent qualification memory +is retained; operation replay keys remain epoch-scoped. Private manifest `/7` +rejects obsolete disposable installations without compatibility readers. + +The native file and TLS PostgreSQL constructors exercise the same signed proof +across epoch activation with two engine/store instances and real HTTP. They +refuse cached old-host entry and old approval under the new epoch, accept a new +exact approval, preserve both histories and all replay charges, and assert source +lifetime allocation slots `[0, 1]` across epochs. They do not establish every +race schedule, hostile-process containment, or an independent rollback anchor. +No new semantic abstraction, provider branch or admission journal is added. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index c70bfe5af..92effc020 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -977,6 +977,15 @@ Re-run the full native verifier, or use a mechanically justified equivalent depe Connection, trust, recipe, policy, qualification and admission epoch changes must be ordered with entry or fenced under a demonstrated version protocol. A mutable value checked before waiting for the lock is insufficient. Exact human approval must remain eligible at entry. If durable consent has a distinct validity/revocation contract, make that a separate mode with explicit evidence; never discard approval dependencies accidentally. +Each operator namespace/partition has one active configuration control across +epochs. Its key must not create a second authority when the epoch changes. +Explicit operator activation advances the epoch under the same writer fence; +a stale host or a fresh review token for a lower epoch cannot reactivate it. +Historical operation keys remain epoch-scoped, and retained facts can be read +without creating new entry authority. Advancing epochs must preserve permanent +revocation memory and source lifetime capacity. This monotonic control assumes +the declared trusted durable store; it is not an independent rollback anchor. + Initial admission also orders fresh native authority, approval, configuration, connection and qualification with publication of the claim and its charges. The file and PostgreSQL adapters use the common writer fence for one insert diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 3765767eb..1309fcfa1 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"3668a11e2d86caf152079192c2fce93d98f8b5d69a5b4c2cae212180fd266fd2"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"9704795f9d5e52547b37a595b5ea3d97be19105b28b786c0895f2e843e30097d"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"c17cd80cc7e91773d515fd4872c9db1a8bfcbaf5bf0f4284e66536335c07f292"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"3bb9e95a3e1ebb3512ea33009c4b063d8644d6abcf3d5602316d5587276d84db"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"0d8d212a1cd6d145d504ce78e91541f9c65384a1f9ff71ac6a131cd81bdbf59f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"0e85409aac8929b988a76f1629117c7126cf004cf6baa1c749c6a7c70c42358b"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"bd6103bdebad30f4f895daccf297f53b854b4dd2d12d14e95722eb9662f597f1"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"4e65e58e696a2d601430b5b9dc805dfee5cbfbb6e1a7abc53188d923e8b6fdc0"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"28cee898ae131022d9a402bfcd427cb7bb3f4fdb6e346e937bb1d5c3e31b67d6"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"5318be91f3570917384f366061d96be3d78c03d9eea6a4b3b534fc2415e3b31c"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"10650653d4b7a8c691d4cf173f4f32a19dc8e35fe1f679008e7ed2e76c162fa8"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76890f1835173adafebca6d02e8a22f367137abfc141ece97cdddc7f1ba47d55"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"eb0e488d5143daa92214cd47f3053a693f038aa2d4e0437f7dded4f1c77678ff"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 0dce2e952..fcb98146d 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -76,7 +76,7 @@ mod unix { }; use zeroize::{Zeroize as _, Zeroizing}; - const MANIFEST_SCHEMA: &str = "auths.gateway-installation/6"; + const MANIFEST_SCHEMA: &str = "auths.gateway-installation/7"; /// The directory of the state directory that holds the signed /// qualification inputs the operator imported. const QUALIFICATION_DIRECTORY: &str = "qualification"; diff --git a/product/runtime/auths-gateway/src/configuration.rs b/product/runtime/auths-gateway/src/configuration.rs index e195e97cd..fa966dd47 100644 --- a/product/runtime/auths-gateway/src/configuration.rs +++ b/product/runtime/auths-gateway/src/configuration.rs @@ -14,7 +14,7 @@ use auths_recipe_qualification::{ use serde::{Deserialize, Serialize}; use std::{collections::BTreeSet, sync::Arc}; -const SCHEMA: &str = "auths.effect-configuration/1"; +const SCHEMA: &str = "auths.effect-configuration/2"; const MAX_BYTES: usize = 131_072; const MAX_INTEGER: u64 = (1 << 53) - 1; const UNAVAILABLE: &str = "gateway.configuration.unavailable"; @@ -96,6 +96,7 @@ pub(crate) struct QualificationSnapshot { struct Record { schema: String, installation: [u8; 32], + epoch: u64, revision: u64, qualification: QualificationSnapshot, } @@ -114,6 +115,7 @@ fn decode_record(bytes: &[u8]) -> Result { } let record: Record = serde_json::from_slice(bytes).map_err(|_| UNAVAILABLE)?; if record.schema != SCHEMA + || !(1..=MAX_INTEGER).contains(&record.epoch) || !(1..=MAX_INTEGER).contains(&record.revision) || !record.qualification.memory.valid() || encode(&record)? != bytes @@ -123,9 +125,9 @@ fn decode_record(bytes: &[u8]) -> Result { Ok(record) } -fn decode(bytes: &[u8], installation: &[u8; 32]) -> Result { +fn decode(bytes: &[u8], installation: &[u8; 32], epoch: u64) -> Result { let record = decode_record(bytes)?; - if &record.installation != installation { + if &record.installation != installation || record.epoch != epoch { return Err(CHANGED); } Ok(record) @@ -147,6 +149,7 @@ pub(crate) struct SharedConfiguration { store: Arc, key: GatewayAttemptKey, installation: [u8; 32], + epoch: u64, } impl SharedConfiguration { @@ -154,11 +157,13 @@ impl SharedConfiguration { store: Arc, key: [u8; 32], installation: [u8; 32], + epoch: u64, ) -> Self { Self { store, key: GatewayAttemptKey::from_bytes(key), installation, + epoch, } } @@ -175,6 +180,7 @@ impl SharedConfiguration { let record = Record { schema: SCHEMA.to_owned(), installation: self.installation, + epoch: self.epoch, revision: 1, qualification: gate.shared_snapshot(&QualificationMemory::default()), }; @@ -202,10 +208,11 @@ impl SharedConfiguration { let current = snapshots[0] .as_deref() .ok_or(GatewayAttemptError::Corrupt)?; - let mut record = decode(current, &self.installation).map_err(|code| { - refusal = code; - GatewayAttemptError::Corrupt - })?; + let mut record = + decode(current, &self.installation, self.epoch).map_err(|code| { + refusal = code; + GatewayAttemptError::Corrupt + })?; let mut next = gate.shared_snapshot(&record.qualification.memory); if next == record.qualification { return Ok(current.to_vec()); @@ -258,10 +265,14 @@ impl SharedConfiguration { return Err(GatewayAttemptError::Conflict); } // A saturated record cannot be reactivated by a new configuration. - if record.revision == MAX_INTEGER || record.qualification.memory.blocked { + if record.revision == MAX_INTEGER + || record.qualification.memory.blocked + || self.epoch < record.epoch + { return Err(GatewayAttemptError::InvalidTransition); } record.installation = self.installation; + record.epoch = self.epoch; record.revision += 1; record.qualification = gate.shared_snapshot(&record.qualification.memory); encode(&record).map_err(|_| GatewayAttemptError::Corrupt) @@ -275,7 +286,7 @@ impl SharedConfiguration { bytes: &[u8], gate: &QualificationGate, ) -> Result { - let record = decode(bytes, &self.installation)?; + let record = decode(bytes, &self.installation, self.epoch)?; gate.entry_snapshot(&record.qualification) } @@ -285,7 +296,7 @@ impl SharedConfiguration { bytes: &[u8], gate: &QualificationGate, ) -> Result<(), &'static str> { - let record = decode(bytes, &self.installation)?; + let record = decode(bytes, &self.installation, self.epoch)?; gate.accept_shared(&record.qualification) } @@ -325,22 +336,45 @@ mod tests { let record = Record { schema: SCHEMA.to_owned(), installation: [11; 32], + epoch: 1, revision: 1, qualification: gate(VerifierState::default()) .shared_snapshot(&QualificationMemory::default()), }; let canonical = encode(&record).expect("record"); - assert_eq!(decode(&canonical, &[11; 32]).expect("decode").revision, 1); - assert!(decode(&canonical, &[12; 32]).is_err()); + assert_eq!( + decode(&canonical, &[11; 32], 1).expect("decode").revision, + 1 + ); + assert!(decode(&canonical, &[12; 32], 1).is_err()); + assert!(decode(&canonical, &[11; 32], 2).is_err()); + let value: serde_json::Value = serde_json::from_slice(&canonical).expect("record"); + for epoch in [serde_json::Value::Null, 0.into(), (MAX_INTEGER + 1).into()] { + let mut invalid = value.clone(); + invalid["epoch"] = epoch; + assert!( + decode_record(&serde_json_canonicalizer::to_vec(&invalid).expect("bytes")).is_err() + ); + } + let mut obsolete = value.clone(); + obsolete["schema"] = "auths.effect-configuration/1".into(); + assert!( + decode_record(&serde_json_canonicalizer::to_vec(&obsolete).expect("bytes")).is_err() + ); + let mut missing = value; + missing.as_object_mut().expect("object").remove("epoch"); + assert!( + decode_record(&serde_json_canonicalizer::to_vec(&missing).expect("bytes")).is_err() + ); let mut padded = canonical.clone(); padded.push(b' '); - assert!(decode(&padded, &[11; 32]).is_err()); + assert!(decode(&padded, &[11; 32], 1).is_err()); let fixture = serde_json::to_vec_pretty(&serde_json::json!({ - "schema": "auths.effect-configuration-fixture/1", + "schema": "auths.effect-configuration-fixture/2", "scope": "native configuration encoding and revision identity; no entry claim", - "key_hex": hex::encode(key), + "configuration_key_sha256": format!("sha256:{}", hex::encode(key)), "record_canonical": String::from_utf8(canonical).expect("UTF-8"), - "revision_token_hex": hex::encode(digest("auths.effect-configuration-revision/1", &record).expect("revision")), + "revision_token_sha256": format!("sha256:{}", hex::encode(digest("auths.effect-configuration-revision/1", &record).expect("revision"))), })).expect("fixture"); let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../bindings/fixtures/gateway/effect-configuration.json"); @@ -350,6 +384,45 @@ mod tests { assert_eq!(std::fs::read(path).expect("fixture"), fixture); } + fn assert_saturation_persists(candidate: &SharedConfiguration, retained: &QualificationGate) { + let saturated = VerifierState { + revoked_signers: (0..=MAX_REVOKED_SIGNERS) + .map(|n| { + QualificationSignerId::parse(format!("synthetic-signer-{n}")).expect("signer") + }) + .collect(), + ..VerifierState::default() + }; + candidate + .publish(&gate(saturated)) + .expect("durable saturated denial"); + assert!(candidate.check(retained).is_err()); + candidate + .publish(&gate(VerifierState::default())) + .expect("still saturated"); + assert!( + candidate.check(retained).is_err(), + "publishing cannot forget saturation" + ); + assert!( + candidate + .activate(candidate.current_revision().expect("revision"), retained) + .is_err(), + "activation cannot reset permanent memory" + ); + assert_eq!( + candidate + .store + .sweep_expired(u64::MAX / 2, 64) + .expect("sweep"), + 0 + ); + assert!( + candidate.current_revision().is_ok(), + "configuration never expires" + ); + } + async fn shared_configuration_conformance(backend: Backend) { let store = TestAttempts::open(backend); let (first, second) = (store.raw(), store.raw()); @@ -360,8 +433,8 @@ mod tests { &crate::OperatorNamespace::parse("shared-config").expect("namespace"), ) .expect("key"); - let original = SharedConfiguration::new(first, key, [11; 32]); - let candidate = SharedConfiguration::new(second, key, [12; 32]); + let original = SharedConfiguration::new(first, key, [11; 32], 1); + let candidate = SharedConfiguration::new(second, key, [12; 32], 1); let old_gate = gate(VerifierState::default()); assert!( original.check(&old_gate).is_err(), @@ -407,43 +480,32 @@ mod tests { let retained = gate(VerifierState::default()); candidate.check(&retained).expect("retained shared memory"); assert!(retained.verifier_state().revoked_signers.contains(&signer)); - let saturated = VerifierState { - revoked_signers: (0..=MAX_REVOKED_SIGNERS) - .map(|n| { - QualificationSignerId::parse(format!("synthetic-signer-{n}")) - .expect("signer") - }) - .collect(), - ..VerifierState::default() - }; - candidate - .publish(&gate(saturated)) - .expect("durable saturated denial"); - assert!(candidate.check(&retained).is_err()); - candidate - .publish(&gate(VerifierState::default())) - .expect("still saturated"); - assert!( - candidate.check(&retained).is_err(), - "publishing cannot forget saturation" - ); + let advanced = SharedConfiguration::new(candidate.store.clone(), key, [13; 32], 2); + assert!(advanced.initialize(&retained).is_err()); + advanced + .activate( + candidate.current_revision().expect("review epoch"), + &retained, + ) + .expect("advance epoch under same fence"); + assert_eq!(candidate.check(&retained), Err(CHANGED)); assert!( candidate - .activate(candidate.current_revision().expect("revision"), &retained) + .activate( + advanced.current_revision().expect("fresh review"), + &retained + ) .is_err(), - "activation cannot reset permanent memory" - ); - assert_eq!( - candidate - .store - .sweep_expired(u64::MAX / 2, 64) - .expect("sweep"), - 0 - ); - assert!( - candidate.current_revision().is_ok(), - "configuration never expires" + "a current review cannot authorize an epoch downgrade" ); + let candidate = advanced; + let retained = gate(VerifierState::default()); + candidate + .check(&retained) + .expect("new epoch retains memory"); + assert!(retained.verifier_state().revoked_signers.contains(&signer)); + assert_eq!(retained.verifier_state().accepted_revocation_sequence, 3); + assert_saturation_persists(&candidate, &retained); }) .await .expect("shared configuration conformance"); diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index 6802c0357..e887e35e2 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -119,11 +119,15 @@ impl EffectPolicy { ) -> Result<[u8; 32], EffectBindingError> { self.validate()?; commitment( - "auths.effect-configuration-key/1", - &canonical(&(namespace.as_str(), &self.partition, self.epoch))?, + "auths.effect-configuration-key/2", + &canonical(&(namespace.as_str(), &self.partition))?, ) } + pub(crate) const fn epoch(&self) -> u64 { + self.epoch + } + pub(crate) fn contains(&self, binding: &EffectBinding) -> bool { self.partition == binding.wire.partition && self.epoch == binding.wire.epoch } diff --git a/product/runtime/auths-gateway/src/effect_candidate_tests.rs b/product/runtime/auths-gateway/src/effect_candidate_tests.rs index 186e07115..0e7746165 100644 --- a/product/runtime/auths-gateway/src/effect_candidate_tests.rs +++ b/product/runtime/auths-gateway/src/effect_candidate_tests.rs @@ -649,6 +649,7 @@ async fn candidate_journal( .configuration_key(installed.recipe.namespace()) .expect("key"), installed.configuration, + policy.epoch(), ); configuration .initialize(&qualification) @@ -857,6 +858,7 @@ async fn candidate_journal( .configuration_key(installed.recipe.namespace()) .expect("key"), [99; 32], + policy.epoch(), ); changed .activate( diff --git a/product/runtime/auths-gateway/src/effect_content_tests.rs b/product/runtime/auths-gateway/src/effect_content_tests.rs index b4679e904..8b2841969 100644 --- a/product/runtime/auths-gateway/src/effect_content_tests.rs +++ b/product/runtime/auths-gateway/src/effect_content_tests.rs @@ -578,6 +578,7 @@ async fn native_content_journal_fixture_is_current() { Arc::clone(&store), policy.configuration_key(recipe.namespace()).expect("key"), installed.configuration, + policy.epoch(), ); configuration .initialize(&qualification) diff --git a/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs index c02aca056..21050a37c 100644 --- a/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs +++ b/product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs @@ -107,6 +107,7 @@ pub(super) async fn corpus( Arc::clone(store), policy.configuration_key(recipe.namespace()).expect("key"), [12; 32], + policy.epoch(), ); let validation = |now| { let qualification = Arc::new(crate::QualificationGate::new( diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 3a9d514b4..c43506c69 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -546,6 +546,7 @@ impl GatewayEngine { self.attempts.store(), key, pin, + self.effect_policy.epoch(), )) } diff --git a/product/runtime/auths-gateway/src/native_epoch_tests.rs b/product/runtime/auths-gateway/src/native_epoch_tests.rs new file mode 100644 index 000000000..d20378267 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_epoch_tests.rs @@ -0,0 +1,261 @@ +//! A partition has one activated epoch; old facts are not new entry authority. +use super::*; +use crate::effect::EffectPolicy; + +const PENDING: &str = "epoch-pending"; + +async fn input(engine: &GatewayEngine, operation: &str) -> Input { + let call = engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation) + .await + .expect("native call"); + let signed = tool_fixture_until(&call, NOW, NOW + 86_400).expect("native proof"); + let effect = engine + .compile_content_action(&signed.proof, &signed.action) + .await + .expect("effect"); + Input { + proof: signed.proof, + action: signed.action, + approval: Input::approval(&effect, Change::None), + } +} + +async fn acquire( + engine: &GatewayEngine, + input: &Input, +) -> Result { + engine + .acquire_content_action(&input.proof, &input.action, input.approval.clone()) + .await +} + +fn next_epoch(fixture: &Fixture) -> GatewayEngine { + let mut candidate_controls = controls(fixture.clock.clone(), 29); + candidate_controls.policy = EffectPolicy::new( + "test-partition".to_owned(), + 2, + SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + ) + .expect("epoch-two policy"); + let attempts = GatewayAttempts::new( + fixture.store.reopen().store(), + candidate_controls.policy.clone(), + ) + .expect("new epoch owner"); + let (candidate, _) = fixture.runtime.block_on(load_controlled_engine( + &fixture.setup, + "epoch-two", + attempts, + candidate_controls, + )); + candidate +} + +fn activate(fixture: &Fixture, candidate: &GatewayEngine, pending: &Input) -> ([u8; 32], [u8; 32]) { + let old_configuration = fixture.engine.shared_configuration().expect("old config"); + let new_configuration = candidate.shared_configuration().expect("new config"); + assert_eq!( + old_configuration.key(), + new_configuration.key(), + "epoch changes must share the same partition control and writer fence" + ); + assert!( + candidate.initialize_effect_configuration().is_err(), + "joining a new epoch must not create a parallel active authority" + ); + assert!( + fixture + .runtime + .block_on(candidate.compile_content_action(&pending.proof, &pending.action)) + .is_err(), + "operator activation is required" + ); + let before = candidate + .effect_configuration_revision() + .expect("operator review"); + candidate + .activate_effect_configuration(before) + .expect("activate epoch two"); + let activated = candidate + .effect_configuration_revision() + .expect("activated revision"); + assert_ne!(activated, before); + (before, activated) +} + +fn one_case(backend: Backend) -> Value { + let fixture = Fixture::new(backend); + let previous = fixture.runtime.block_on(input(&fixture.engine, SOURCE)); + let previous_result = fixture + .runtime + .block_on(acquire(&fixture.engine, &previous)) + .expect("epoch-one GET"); + let pending = fixture.runtime.block_on(input(&fixture.engine, PENDING)); + let original = fixture + .runtime + .block_on( + fixture + .engine + .compile_content_action(&pending.proof, &pending.action), + ) + .expect("old proof and approval start current"); + let old_id = original.binding().id(); + let old_witness = fixture.engine.execution_witness(); + let candidate = next_epoch(&fixture); + let (before, activated) = activate(&fixture, &candidate, &pending); + let records_before_refusals = fixture.records(); + assert!( + fixture + .runtime + .block_on(acquire(&fixture.engine, &pending)) + .is_err(), + "a cached epoch-one host cannot grant new entry" + ); + let next_effect = fixture + .runtime + .block_on(candidate.compile_content_action(&pending.proof, &pending.action)) + .expect("same native proof is still authorized in epoch two"); + assert_ne!(next_effect.binding().id(), old_id); + assert!( + fixture + .runtime + .block_on(acquire(&candidate, &pending)) + .is_err(), + "old epoch approval cannot authorize a new epoch effect" + ); + assert_eq!(fixture.records(), records_before_refusals); + assert_eq!(fixture.engine.execution_witness(), old_witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + assert!( + fixture + .engine + .activate_effect_configuration(activated) + .is_err(), + "even a fresh operator review cannot reactivate a lower epoch" + ); + assert!( + candidate.activate_effect_configuration(before).is_err(), + "stale operator tokens lose the shared CAS" + ); + assert_eq!( + candidate + .effect_configuration_revision() + .expect("no downgrade"), + activated + ); + let current = Input { + proof: pending.proof.clone(), + action: pending.action.clone(), + approval: Input::approval(&next_effect, Change::None), + }; + let current_result = fixture + .runtime + .block_on(acquire(&candidate, ¤t)) + .expect("new exact approval permits one current-epoch GET"); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 2); + retained_history( + &fixture, + &candidate, + &previous, + &previous_result, + ¤t, + ¤t_result, + ) +} + +fn retained_history( + fixture: &Fixture, + candidate: &GatewayEngine, + previous: &Input, + previous_result: &crate::AcquisitionSnapshot, + current: &Input, + current_result: &crate::AcquisitionSnapshot, +) -> Value { + let records = fixture.records(); + assert_eq!(records.len(), 2, "both epochs retain their operation facts"); + let mut allocations: Vec = records + .iter() + .map(|bytes| { + let record: Value = serde_json::from_slice(bytes).expect("retained record"); + record["state"]["facts"]["allocation"] + .as_u64() + .expect("lifetime allocation") + }) + .collect(); + allocations.sort_unstable(); + assert_eq!( + allocations, + [0, 1], + "epoch changes cannot reset source lifetime capacity" + ); + let old_witness = fixture.engine.execution_witness(); + let current_witness = candidate.execution_witness(); + assert_eq!( + fixture + .runtime + .block_on(acquire(&fixture.engine, previous)) + .expect("historical epoch-one replay"), + *previous_result + ); + assert_eq!( + fixture + .runtime + .block_on(acquire(candidate, current)) + .expect("current epoch replay"), + *current_result + ); + assert_eq!(fixture.engine.execution_witness(), old_witness); + assert_eq!(candidate.execution_witness(), current_witness); + assert_eq!(fixture.records(), records); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 2); + let raw = fixture + .store + .raw() + .load( + GatewayRecordKind::EffectConfiguration, + &candidate + .shared_configuration() + .expect("active control") + .key(), + ) + .expect("control load") + .expect("one control"); + let control: Value = serde_json::from_slice(&raw).expect("control"); + assert_eq!(control["schema"], "auths.effect-configuration/2"); + assert_eq!(control["epoch"], 2); + json!({"activated_epoch":2, "one_shared_partition_control":true, + "cached_old_epoch_entry_refused":true, "same_native_proof_still_authorized":true, + "old_approval_new_epoch_refused":true, "fresh_operator_downgrade_refused":true, + "stale_operator_review_refused":true, "old_and_new_epoch_history_retained":true, + "historical_replay_recreates_no_permit_or_charge":true, + "previous_epoch_snapshot":previous_result, "current_epoch_snapshot":current_result, + "lifetime_allocation_slots":allocations, "provider_reads":2}) +} + +fn matrix(backend: Backend) { + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-epoch-fence/1", + "adapter":backend.label(), "case":one_case(backend), + "scope":"actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", + "excluded":["malicious store rollback without an independent anchor", "all protocol race schedules", "hostile OS and live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-epoch-fence-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write artifact"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} + +#[test] +fn native_file_epoch_fence_fixture_is_current() { + matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_epoch_fence_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index 21398ff35..046b1a26c 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -29,6 +29,9 @@ const RELEASE: &str = "retained-release"; #[path = "native_retention_tests.rs"] mod retention_tests; +#[path = "native_epoch_tests.rs"] +mod epoch_tests; + #[derive(Clone, Copy, Debug)] enum Protocol { Acquisition, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index b2a9bf7cd..1325fe00b 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "b6f448e0d800b06fbde7b4efe7e88edd8dffdb6e23f8f75bc53f4fc8d198c957"; + "eb51e99dbcef8880a437ad2d651046439fb169edd223eb6d6f621e00f6c2c8e7"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/candidate_cli.rs b/product/runtime/auths-gateway/tests/candidate_cli.rs index ebb9880c8..0ec322e45 100644 --- a/product/runtime/auths-gateway/tests/candidate_cli.rs +++ b/product/runtime/auths-gateway/tests/candidate_cli.rs @@ -329,7 +329,7 @@ async fn rotation_installation( private(&root.join(name), bytes); } private(&root.join("installation.json"), &serde_json_canonicalizer::to_vec(&json!({ - "schema": "auths.gateway-installation/6", "recipe_digest": recipe.digest_hex(), + "schema": "auths.gateway-installation/7", "recipe_digest": recipe.digest_hex(), "profile_lock_sha256": hex::encode(Sha256::digest(lock)), "trusted_context_sha256": hex::encode(Sha256::digest(trust)), "effect_policy": policy, "provider": "stripe", "alias": "synthetic", "deployment": "development", "operator_attestation_sha256": null, "attempt_store": root.join("attempts"), diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index d4e5670aa..ce511be4f 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 411 +freeze_version = 412 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 411 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 155 +"auths.identity.protocol" = 156 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 125 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 411 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 12 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 152 +"auths.product.public-sdk-contract" = 153 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 19 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 411 +"auths.release.public-surface" = 412 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 72b805e41..6fcc118aa 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 411, + "freezeVersion": 412, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 155, + "version": 156, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "689aa38891d2ac72a77da0fce985a2833487969c0ddf0c97d74cfcd17e5025e7" + "sha256": "76654e9d7ea8713198f868f4cdbb06504fde6f9a692372e2a808736689a54a41" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 152, + "version": 153, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "51e50cfd0e265df8b0a16d4e07326875dae9f85d435ea0a816d5f62d813a739b" + "sha256": "47be70ee7a9f72bc6a29051e11fb35d29ee59c9bc6e4dd31d720e0777ec08cca" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 411, + "version": 412, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "dd18e8627fcc3214ec5262917dd91455f7f86d16298791a5410fe95b6ac2aef9" + "sha256": "3b1d08c2aa408702bd2e06b2ef140cab70238b740fadc35c30483c7fa7bbf700" } ] } From ab980d1028927ef7bb08159ac489153d767993d5 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 22:35:48 +0000 Subject: [PATCH 099/136] feat(demo): compose the managed owner read and disclosure journey --- .github/workflows/airtable-gateway-demo.yml | 4 + bindings/python/python/auths/testkit.py | 21 +- .../python/tests/test_identity_authoring.py | 15 +- compliance.toml | 10 +- demos/airtable-gateway/README.md | 33 +++ demos/airtable-gateway/app.py | 25 ++- demos/airtable-gateway/contract.json | 14 +- demos/airtable-gateway/managed-recipe.json | 124 +++++++++++ demos/airtable-gateway/managed-review.json | 113 ++++++++++ demos/airtable-gateway/managed_content.py | 197 ++++++++++++++++++ demos/airtable-gateway/operate.py | 76 ++++++- demos/airtable-gateway/submit.mts | 12 +- demos/airtable-gateway/tests/owner_browser.py | 122 ++++++++++- demos/airtable-gateway/tools/package.py | 2 +- demos/airtable-gateway/web/app.js | 41 +++- demos/airtable-gateway/web/index.html | 14 +- ...017-bound-effect-and-recovery-ownership.md | 14 ++ docs/plans/0074-hosted-evidence-74ce9f75.md | 151 ++++++++++++++ docs/plans/0074-implementation-status.md | 61 +++++- .../0009-bound-effect-and-recovery.md | 26 +++ release/semantic-freeze-versions.toml | 14 +- release/semantic-freeze.json | 26 +-- 22 files changed, 1044 insertions(+), 71 deletions(-) create mode 100644 demos/airtable-gateway/managed-recipe.json create mode 100644 demos/airtable-gateway/managed-review.json create mode 100644 demos/airtable-gateway/managed_content.py create mode 100644 docs/plans/0074-hosted-evidence-74ce9f75.md diff --git a/.github/workflows/airtable-gateway-demo.yml b/.github/workflows/airtable-gateway-demo.yml index 1a92288aa..9d88f5747 100644 --- a/.github/workflows/airtable-gateway-demo.yml +++ b/.github/workflows/airtable-gateway-demo.yml @@ -59,6 +59,10 @@ jobs: cp target/release/auths-gateway target/airtable-demo/auths-gateway cargo build --locked --release -p auths-gateway --features loopback-provider --bin auths-gateway cp target/release/auths-gateway target/airtable-demo/auths-gateway-simulation + target/airtable-demo/auths-gateway review \ + --recipe demos/airtable-gateway/managed-recipe.json \ + --profile-lock demos/airtable-gateway/profile.lock.json > target/airtable-demo/managed-review.json + cmp demos/airtable-gateway/managed-review.json target/airtable-demo/managed-review.json - run: npm ci working-directory: bindings/typescript - run: cargo install wasm-pack --version 0.15.0 --locked diff --git a/bindings/python/python/auths/testkit.py b/bindings/python/python/auths/testkit.py index 88239d6aa..ef7b5df09 100644 --- a/bindings/python/python/auths/testkit.py +++ b/bindings/python/python/auths/testkit.py @@ -387,8 +387,14 @@ def ephemeral_ed25519_signer() -> object: class DevelopmentEd25519IdentityKey: """Ephemeral test-only key for identity examples and conformance fixtures.""" - def __init__(self) -> None: - self._key = _DevelopmentEd25519Key.generate() + def __init__(self, seed: _Optional[bytes] = None) -> None: + if seed is not None and (type(seed) is not bytes or len(seed) != 32): + raise ValueError("development Ed25519 seed must be 32 bytes") + self._key = ( + _DevelopmentEd25519Key.generate() + if seed is None + else _DevelopmentEd25519Key.from_seed(seed) + ) @property def public_key(self) -> bytes: @@ -398,8 +404,15 @@ def sign(self, preimage: bytes, /) -> bytes: return bytes(self._key.sign(bytes(preimage))) -def development_ed25519_identity_key() -> DevelopmentEd25519IdentityKey: - return DevelopmentEd25519IdentityKey() +def development_ed25519_identity_key( + seed: _Optional[bytes] = None, +) -> DevelopmentEd25519IdentityKey: + """Test-only native key, optionally from a private local fixture seed. + + Seed import supports native recipient process demonstrations. This provides + no production custody or secret-erasure guarantee for Python byte objects. + """ + return DevelopmentEd25519IdentityKey(seed) class fixtures: diff --git a/bindings/python/tests/test_identity_authoring.py b/bindings/python/tests/test_identity_authoring.py index 49667c5cc..6d4e3d269 100644 --- a/bindings/python/tests/test_identity_authoring.py +++ b/bindings/python/tests/test_identity_authoring.py @@ -2,6 +2,8 @@ import asyncio +import pytest + from auths.identity import IdentityOk, authenticate_message, raw_key_ed25519 from auths.identity.authoring import ( create_raw_key_ed25519_identity, @@ -10,9 +12,12 @@ from auths.testkit import development_ed25519_identity_key -def test_authored_raw_key_identity_uses_the_canonical_descriptor_preimage() -> None: +@pytest.mark.parametrize("seed", [None, bytes([31]) * 32]) +def test_authored_raw_key_identity_uses_the_canonical_descriptor_preimage( + seed: bytes | None, +) -> None: async def scenario() -> None: - key = development_ed25519_identity_key() + key = development_ed25519_identity_key(seed) identity = create_raw_key_ed25519_identity(key.public_key) assert identity.method_id == "raw-key-v2" assert identity.identity_id.startswith("key:sha256-v2:") @@ -41,3 +46,9 @@ async def scenario() -> None: assert packet_result.value.identity.identity_id == identity.identity_id asyncio.run(scenario()) + + +@pytest.mark.parametrize("seed", [b"", bytes(31), bytes(33), bytearray(32), "x" * 32]) +def test_development_recipient_seed_refuses_invalid_import(seed: object) -> None: + with pytest.raises(ValueError, match="must be 32 bytes"): + development_ed25519_identity_key(seed) # type: ignore[arg-type] diff --git a/compliance.toml b/compliance.toml index 5216bc087..92bb30594 100644 --- a/compliance.toml +++ b/compliance.toml @@ -2182,15 +2182,15 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1", "auths.private-effect-review/2", "auths.private-effect-signing/2"] -wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport"] +protocol_versions = ["auths.airtable-gateway-demo/2", "auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1", "auths.private-effect-review/2", "auths.private-effect-signing/2", "auths.gateway-content-read/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclose/1", "auths.gateway-unix-disclosure-channel/1"] +wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport", "AcquisitionSnapshot", "DisclosureSnapshot"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] signature_families = ["ed25519-v1"] profiles = ["auths.mcp/2", "airtable-record-update-v1"] -transports = ["unix", "http-local-demo", "https-provider-disposable-table", "owner-review-http-local"] -configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel", "owner-loopback-origin", "private-owner-login-file", "native-review-renderer"] -security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history", "authenticated-owner-session", "withheld-exact-approval", "pending-owner-review"] +transports = ["unix", "http-local-demo", "https-provider-disposable-table", "owner-review-http-local", "native-authenticated-unix-disclosure"] +configuration_inputs = ["operator-approved-recipe", "profile-lock", "operator-issued-grants", "separate-trusted-context", "gateway-app-socket", "native-effect-policy", "private-operator-consent-channel", "owner-loopback-origin", "private-owner-login-file", "native-review-renderer", "reviewed-local-managed-recipe", "pinned-local-recipient"] +security_state = ["gateway-owned-attempts", "gateway-owned-credentials", "app-owned-signing-key", "unsigned-demo-history", "private-read-actor-grant", "finite-scripted-recovery-reviews", "candidate-acquisition-history", "authenticated-owner-session", "withheld-exact-approval", "pending-owner-review", "private-recipient-seed-and-output", "native-acquisition-history", "native-recipient-ack-history", "fixed-development-actor-simulator"] [packages.auths-airtable-gateway-demo.claims] demo-conformance-fixture = ["demos/airtable-gateway/selftest.py#test_native_refusals_replay_race_and_loss"] diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index 7ac38e896..ca2121c8b 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -268,3 +268,36 @@ Protected AWS custody, PostgreSQL/TLS, two genuine rotation PATs, verified exclu base access, current signed qualification, full crash/canary/lifecycle corpus, independent security/human review and an actual GitHub-release installation remain separate gates in AP-SPEC-066 and [AP-SPEC-068](../../docs/specs/0068-airtable-general-gateway-demo.md). + +## Managed read, recipient release and write journey + +The optional authenticated owner UI selects `managed-recipe.json` for the local +simulation. Its mutation declaration matches the maintained record-update recipe; +an additional bounded GET can retain at most 512 UTF-8 bytes from a response +bounded to 1,024 bytes. `managed-review.json` is the actual native recipe review, +reconstructed and compared by CI. The original recipe remains the live/reference +recipe. This local variant grants no managed Google or live-provider claim. + +After logging into the separate owner origin, choose the Python acquisition, +then the TypeScript acquisition. Each installed client submits a separate native +proof and exact approval. Acquisition returns redacted history and leaves content +private. Choose disclosure next: inspect and approve its separate complete native +review, including the exact recipient/channel/instance and source. The native +recipient process runs under the application UID, receives into private `0600` +files and signs the native ACK. The browser displays the gateway's retained ACK +fact after it is recorded; an ACK-send result alone is not displayed as delivery +evidence. History/replay choices never authorize another GET or release. + +The same native agent actor acquires, discloses and writes. The development +proposal simulator retains a fixed root-private copy of that actor's development +key before handing application files over, so the operator never loads an +application-writable signer configuration. Exact-effect reviewer keys remain +separate. This is explicit software simulation custody, not exclusive actor-key +custody, independent-human attention or production qualification. + +The packaged browser scenario exercises both installed SDKs, real native +HTTP/Unix transport, recipient files, external provider counters, complete +owner review, exact write and independent observation. It also exercises actual +response loss and retained unknown without reentry. Assertions check that +private sentinel content stays out of public HTTP/history. New scenarios remain +authored until their exact-head hosted result is recorded in the AP074 ledger. diff --git a/demos/airtable-gateway/app.py b/demos/airtable-gateway/app.py index 5c5531fe0..fdf80fd9f 100644 --- a/demos/airtable-gateway/app.py +++ b/demos/airtable-gateway/app.py @@ -24,6 +24,7 @@ from demo_common import Refusal, b64, canonical, decode, read, require, unb64, write from generated import CONTRACT, SetDemoStatus, FIELDS +from managed_content import EXPERIMENTS as CONTENT_EXPERIMENTS HERE = Path(__file__).resolve().parent LABELS = ('exact', 'pending', 'unsupported-value', 'record-substitution', 'path-injection', @@ -32,7 +33,7 @@ 'malformed-response', 'oversized-response', 'encoded-segment', 'typescript-positive', 'crash-before', 'crash-after', 'approval-insufficient') EXPERIMENTS = tuple('recover-' + label for label in LABELS) + LABELS + ('replay', 'fresh-replay', 'observe', 'typescript', 'recover-loss', 'recover-competing') -EXPERIMENTS += ('approval-duplicate',) +EXPERIMENTS += ('approval-duplicate',) + CONTENT_EXPERIMENTS FAULTS = ('lost-response', 'competing-writer', 'rate-limit', 'provider-error', 'malformed-response', 'oversized-response') OPERATOR_CASES = ('crash-before', 'crash-after') @@ -70,7 +71,10 @@ class Application: def __init__(self, directory, sockets): self.directory = Path(directory) self.plan = decode(read(self.directory / 'application.json')) - require(self.plan['schema'] == 'auths.airtable-gateway-demo/1', 'demo.invalid-plan') + require(self.plan['schema'] == 'auths.airtable-gateway-demo/2', 'demo.invalid-plan') + require(type(self.plan.get('managed_content')) is bool + and type(self.plan.get('recipe_source_b64')) is str + and 0 < len(unb64(self.plan['recipe_source_b64'])) <= 65536, 'demo.invalid-plan') require(set(self.plan['cases']) == set(LABELS), 'demo.invalid-cases') self.sockets = [Path(path) for path in sockets] self.clients = [GatewayClient(GatewayEndpoint(path)) for path in self.sockets] @@ -105,7 +109,9 @@ def summary(self): 'provider_credential_model': self.plan['provider_credential_model'], 'effect': 'Set DemoStatus and action-derived auths_echo; no compare-and-swap', 'grant_limits': {'budgets': 'No numeric budget capability in this reviewed profile'}, - 'experiments': [value for value in EXPERIMENTS if value not in OPERATOR_CASES], + 'experiments': [value for value in EXPERIMENTS if value not in OPERATOR_CASES + and (self.plan.get('managed_content') or value not in CONTENT_EXPERIMENTS)], + 'managed_content': self.plan.get('managed_content') is True, 'approval': self.plan['approval'], 'effect_review': self.plan['effect_review'], 'sdk_version': importlib.metadata.version('auths'), 'proposals': {label: case['arguments'] for label, case in self.plan['cases'].items()}, @@ -265,6 +271,17 @@ async def recover(self, source): async def execute(self, experiment): require(experiment in EXPERIMENTS, 'demo.unknown-experiment') + if experiment in CONTENT_EXPERIMENTS: + from managed_content import execute as content_execute + record = await content_execute(self, experiment) + result = {'schema': 'auths.airtable-gateway-demo-result/1', 'experiment': experiment, + 'action': {'operation_id': record['operation_id']}, 'records': [record], + 'decided_by': 'gateway' if record['result']['outcome'] != 'not-submitted' else 'operator-review', + 'production_qualified': False, 'display_signature': 'unsigned', 'recorded_at': int(time.time())} + require(len(self.records) < 256, 'demo.session-full') + self.records.append(result) + write(self.directory / 'results.json', canonical(self.records)) + return result if experiment.startswith('recover-'): source = experiment[len('recover-'):] source = {'loss': 'lost-response', 'competing': 'competing-writer'}.get(source, source) @@ -325,7 +342,7 @@ async def execute(self, experiment): def audit(self): return {'schema': 'auths.gateway-audit-bundle/2', - 'recipe_b64': b64(read(HERE / 'recipe.json')), + 'recipe_b64': self.plan['recipe_source_b64'], 'profile_lock_b64': b64(read(HERE / 'profile.lock.json')), 'trusted_context_b64': self.plan['contexts'][0], 'entries': list(self.entries.values()), diff --git a/demos/airtable-gateway/contract.json b/demos/airtable-gateway/contract.json index bc86f33d2..e843c1cf0 100644 --- a/demos/airtable-gateway/contract.json +++ b/demos/airtable-gateway/contract.json @@ -11,5 +11,17 @@ "simulation_evidence": "selftest.py", "browser_evidence": "tests/browser.py", "protected_qualification": false, - "budgets": "not applicable: the reviewed profile has no numeric argument or count-only capability" + "budgets": "not applicable: the reviewed profile has no numeric argument or count-only capability", + "managed_local_journey": { + "recipe_source": "demos/airtable-gateway/managed-recipe.json", + "native_review": "demos/airtable-gateway/managed-review.json", + "enabled": "authenticated owner UI in local simulation", + "authority": "one native gateway partition/control/journal for read, release and write; same native agent actor", + "evidence": "tests/owner_browser.py; authored until exact-head hosted execution", + "excluded": [ + "live managed content qualification", + "human attention", + "production signing custody" + ] + } } diff --git a/demos/airtable-gateway/managed-recipe.json b/demos/airtable-gateway/managed-recipe.json new file mode 100644 index 000000000..bf80505fe --- /dev/null +++ b/demos/airtable-gateway/managed-recipe.json @@ -0,0 +1,124 @@ +{ + "schema": "auths.gateway-recipe-source/3", + "profile_schema_digest": "72e60b43ec96354be07e5a3a15e7a12ab6aa19b7042b757ebd05dfadcc5f2a29", + "service": "airtable-gateway-demo", + "tool": "set_demo_status_v1", + "operator_namespace": "airtable-demo", + "credential": { + "kind": "bearer" + }, + "origin": "https://api.airtable.com", + "write": { + "method": "PATCH", + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appQD3Qf0YFBCW9bV" + }, + { + "kind": "fixed", + "value": "tblBx2jwe0IsPYRKT" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "body": { + "kind": "json", + "value": { + "kind": "object", + "fields": { + "fields": { + "kind": "object", + "fields": { + "DemoStatus": { + "kind": "field", + "name": "replacement" + } + } + } + } + } + } + }, + "observation": { + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appQD3Qf0YFBCW9bV" + }, + { + "kind": "fixed", + "value": "tblBx2jwe0IsPYRKT" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "json_pointer": "/fields/DemoStatus", + "expected_field": "replacement", + "maximum_response_bytes": 16384 + }, + "echo": { + "write": { + "kind": "json-pointer", + "pointer": "/fields/auths_echo" + }, + "observe": "/fields/auths_echo" + }, + "review": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.", + "A separately approved bounded GET can retain this record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } + }, + "content": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appQD3Qf0YFBCW9bV" + }, + { + "kind": "fixed", + "value": "tblBx2jwe0IsPYRKT" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 512 + } +} diff --git a/demos/airtable-gateway/managed-review.json b/demos/airtable-gateway/managed-review.json new file mode 100644 index 000000000..0bad2a3b7 --- /dev/null +++ b/demos/airtable-gateway/managed-review.json @@ -0,0 +1,113 @@ +{ + "schema": "auths.gateway-recipe-review/3", + "effect_review_contract": { + "schema": "auths.effect-review-contract/1", + "consequences": [ + "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.", + "A separately approved bounded GET can retain this record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." + ], + "fields": { + "record_id": { + "kind": "identifier", + "label": "Record id" + }, + "replacement": { + "kind": "text", + "label": "Replacement" + } + } + }, + "digest": "7b3fe9ccc12afd4c4398b944a81e42dc7a00992e8e4af176391fc204d0f0cb37", + "operator_namespace": "airtable-demo", + "service": "airtable-gateway-demo", + "tool": "set_demo_status_v1", + "origin": "https://api.airtable.com", + "method": "PATCH", + "path": [ + "v0", + "appQD3Qf0YFBCW9bV", + "tblBx2jwe0IsPYRKT", + "" + ], + "credential": { + "kind": "bearer" + }, + "maximum_body_bytes": 16384, + "has_observation": true, + "sends_idempotency_key": false, + "echo": { + "kind": "json-pointer", + "write": "/fields/auths_echo", + "observe": "/fields/auths_echo", + "disclosure": "the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets" + }, + "preconditions": null, + "recovery": { + "schema": "auths.gateway-recovery-capability/1", + "class": "linked", + "state_observation": "verified-locator", + "provider_link": "verified-locator", + "unknown_resolution": "gateway-reobservation", + "lost_claim_reentry": { + "deduplication": "none" + }, + "pre_entry_reread": false, + "write_is_conditional": false + }, + "write_is_conditional": false, + "provider_headers": null, + "credential_guard": null, + "content_acquisition": { + "declaration": { + "schema": "auths.gateway-content-read/1", + "resource_field": "record_id", + "path": [ + { + "kind": "fixed", + "value": "v0" + }, + { + "kind": "fixed", + "value": "appQD3Qf0YFBCW9bV" + }, + { + "kind": "fixed", + "value": "tblBx2jwe0IsPYRKT" + }, + { + "kind": "field", + "name": "record_id" + } + ], + "query": [], + "projection": { + "kind": "utf8" + }, + "maximum_response_bytes": 1024, + "maximum_content_bytes": 512 + }, + "method": "GET", + "disclosure": "independent native read authority and exact approval required; response remains private; release requires separate authorization and entry" + }, + "idempotency": null, + "observation": { + "locator": "verified-locator", + "path": [ + "v0", + "appQD3Qf0YFBCW9bV", + "tblBx2jwe0IsPYRKT", + "" + ], + "json_pointer": "/fields/DemoStatus", + "expected_field": "replacement", + "maximum_response_bytes": 16384 + }, + "pre_entry": null, + "account_scope": null, + "relative_ceiling": null, + "bounds": null, + "recipe_digest": "7b3fe9ccc12afd4c4398b944a81e42dc7a00992e8e4af176391fc204d0f0cb37", + "verifier_configuration": "4438003caabb21ef7848726c143782b3cb4c26adac7f609c70b23917613ef035", + "profile_policy": "mcp-arguments-v1", + "bounded_policy_extension": "bounded-policy-commitment-v1" +} diff --git a/demos/airtable-gateway/managed_content.py b/demos/airtable-gateway/managed_content.py new file mode 100644 index 000000000..a83d179bf --- /dev/null +++ b/demos/airtable-gateway/managed_content.py @@ -0,0 +1,197 @@ +"""Installed local managed journey composition; native Rust owns all decisions. + +The operator supplies a finite, separately consented native proposal. The agent +uses installed SDK acquisition/history and the native authenticated recipient. +No plaintext or ACK evidence is returned through the demo's public HTTP UI. +""" +import asyncio +from dataclasses import dataclass +import os +from pathlib import Path +import subprocess +import time + +from auths.self_hosted import ExactMcpTool, IntegerField, ObjectField, StringField +from demo_common import b64, canonical, decode, read, require, unb64, write + +CONTENT_TOOL = 'auths_gateway_content_read_v1' +DISCLOSURE_TOOL = 'auths_gateway_disclosure_v1' +CONTENT_TOOLS = (CONTENT_TOOL, DISCLOSURE_TOOL) +EXPERIMENTS = ('managed-acquire', 'managed-acquire-typescript', 'managed-disclose', + 'managed-content-history', 'managed-release-history') +SOURCE = 'managed-read-python' +RELEASE = 'managed-disclosure' + + +@dataclass(frozen=True) +class Resource: + record_id: str + + +@dataclass(frozen=True) +class ContentRead: + operation_id: str + operator_namespace: str + recipe_digest: str + content_contract: str + resource_arguments: Resource + maximum_response_bytes: int + + +@dataclass(frozen=True) +class Disclosure: + operation_id: str + operator_namespace: str + recipe_digest: str + disclosure_contract: str + source_effect: str + source_operation: str + recipient: str + channel: str + delivery_instance: str + maximum_disclosure_bytes: int + + +def contract(call): + """Public SDK authoring shape for the unchanged native-authored tool call.""" + require(call['name'] in CONTENT_TOOLS, 'demo.unlisted-content-tool') + kind = ContentRead if call['name'] == CONTENT_TOOL else Disclosure + fields = {name: StringField(min_length=1, max_length=512) + for name in kind.__annotations__} + if kind is ContentRead: + fields['resource_arguments'] = ObjectField(Resource, {'record_id': StringField(17, 43)}) + fields['maximum_response_bytes'] = IntegerField(1, 65536) + else: + fields['maximum_disclosure_bytes'] = IntegerField(0, 65536) + tool = ExactMcpTool(service=call['service'], name=call['name'], + command_type=kind, fields=fields) + return tool, tool.validate_arguments(call['arguments']) + + +def prepare(operator, kind, plan, gateway): + """One finite operator proposal, exact native review and explicit consent.""" + require(operator.owner_review is not None and kind in EXPERIMENTS[:3], + 'demo.managed-owner-review-required') + private = operator.managed_private + state = operator.managed_state + operation = RELEASE if kind == 'managed-disclose' else ( + SOURCE if kind == 'managed-acquire' else 'managed-read-typescript') + call_file = private / (operation + '.call') + if kind == 'managed-disclose': + target = private / 'managed-target.json' + gateway(operator.binary, 'effect-disclosure-call', '--state-dir', state, + '--target', target, '--operation', operation, '--call-out', call_file) + mode = ('--disclosure', target) + else: + arguments = private / (operation + '.resource') + write(arguments, canonical({'record_id': plan['cases']['exact']['arguments']['record_id']}), new=True) + gateway(operator.binary, 'effect-content-call', '--state-dir', state, + '--resource-arguments', arguments, '--operation', operation, '--call-out', call_file) + mode = ('--content',) + call = decode(read(call_file)) + proof, action = asyncio.run(operator.read_packet(call, plan, content=True)) + approved = operator.exact_approval(state, operation, proof, action, *mode, owner_consent=True) + require(approved is not None, 'demo.managed-review-refused') + directory = approved[2].parent + response = {'proof': b64(proof), 'action': b64(action), 'approval': b64(read(approved[2])), + 'binding': b64(read(directory / 'binding')), + 'literal_review': decode(read(directory / 'literal-review.json'))['literal_review']} + if kind == 'managed-disclose': + response['target'] = decode(read(private / 'managed-target.json')) + response['expected_bytes'] = call['arguments']['maximum_disclosure_bytes'] + return response + + +def view(packet, literal=None): + """Display only the native stage; this neither grants nor refines facts.""" + require(type(packet) is dict, 'demo.native-content-result-required') + if packet.get('outcome') == 'history': + stage = packet['history']['snapshot']['stage'] + else: + stage = packet.get('outcome', 'unconfirmed') + return {'outcome': stage, 'native': packet, **({'literal_review': literal} if literal else {})} + + +async def execute(application, experiment): + require(application.plan.get('managed_content') is True and experiment in EXPERIMENTS, + 'demo.managed-owner-review-required') + directory = application.directory / 'managed-content' + directory.mkdir(mode=0o700, exist_ok=True) + require(directory.stat().st_uid == os.getuid() and directory.stat().st_mode & 0o077 == 0 + and not directory.is_symlink(), 'demo.managed-private-recipient-required') + history_only = experiment in EXPERIMENTS[3:] + operation = ('managed-read-typescript' if experiment == 'managed-acquire-typescript' + else RELEASE if experiment in ('managed-disclose', 'managed-release-history') else SOURCE) + language = 'typescript' if experiment == 'managed-acquire-typescript' else 'python' + literal = None + if history_only: + packet = decode(await application.clients[0].content_history(operation)) + else: + cache = directory / (experiment + '.packet') + if cache.exists(): + approved = decode(read(cache)) + else: + approved = await application.request_review({'content': experiment}) + if set(approved) == {'code'}: + return {'operation_id': operation, 'language': language, + 'result': {'outcome': 'not-submitted', 'code': approved['code']}} + require(set(approved) == ({'proof', 'action', 'approval', 'binding', 'literal_review'} | + ({'target', 'expected_bytes'} if experiment == 'managed-disclose' else set())), + 'demo.managed-review-unavailable') + write(cache, canonical(approved), new=True) + literal = approved['literal_review'] + if experiment == 'managed-disclose': + packet = await asyncio.to_thread(receive, application, directory, approved) + else: + arguments = {name: unb64(approved[name]) for name in ('proof', 'action', 'approval')} + if language == 'typescript': + def acquire(): + result = subprocess.run(['node', str(Path(__file__).resolve().parent / 'submit.mjs'), + '--socket', str(application.sockets[0]), '--content'], input=canonical({ + name + '_b64': approved[name] for name in arguments}), + capture_output=True, timeout=90) + require(result.returncode == 0, 'demo.typescript-content-unconfirmed') + return decode(result.stdout) + packet = await asyncio.to_thread(acquire) + else: + packet = decode(await application.clients[0].acquire_content(**arguments)) + return {'operation_id': operation, 'language': language, 'result': view(packet, literal)} + + +def receive(application, directory, approved): + """Use the native recipient for identity, channel, exact bytes and ACK. + + Each invocation uses fresh output paths; retained history cannot recreate + delivery. A lost CLI reply is unconfirmed and never triggers another call. + """ + target = directory / 'target.json' + if not target.exists(): + write(target, canonical(approved['target']), new=True) + for name in ('proof', 'action', 'approval', 'binding'): + write(directory / name, unb64(approved[name]), new=True) + prefix = str(time.monotonic_ns()) + command = [str(Path(__file__).resolve().parent / 'bin' / 'auths-gateway-simulation'), + 'disclosure-receive', '--app-socket', str(application.sockets[0]), + '--target', str(target), '--expected-binding', str(directory / 'binding'), + '--expected-bytes', str(approved['expected_bytes']), + '--content-out', str(directory / (prefix + '.content')), + '--acknowledgement-out', str(directory / (prefix + '.ack')), '--recipient-seed-stdin'] + for name in ('proof', 'action', 'approval'): + command.extend(['--' + name, str(directory / name)]) + result = subprocess.run(command, input=read(application.directory / 'recipient.seed', 32), + capture_output=True, timeout=90) + require(result.returncode == 0, 'demo.recipient-unconfirmed-no-redelivery') + status = decode(result.stdout) + require(status.get('outcome') in ('recipient-ack-sent', 'history', 'refused'), + 'demo.native-recipient-result-required') + if status['outcome'] != 'recipient-ack-sent': + return status + # The recipient's ACK-send claim is not the gateway's persisted ACK fact. + async def recorded(): + for _ in range(30): + packet = decode(await application.clients[0].content_history(RELEASE)) + if packet.get('outcome') != 'history' or packet['history']['snapshot']['stage'] == 'acknowledged': + return packet + await asyncio.sleep(.1) + return packet + return asyncio.run(recorded()) diff --git a/demos/airtable-gateway/operate.py b/demos/airtable-gateway/operate.py index 84ba44175..e9911bec3 100644 --- a/demos/airtable-gateway/operate.py +++ b/demos/airtable-gateway/operate.py @@ -79,7 +79,7 @@ def gateway(binary, *arguments): return child([binary, *arguments]).stdout -async def authority(binary, resources, directory, mode): +async def authority(binary, resources, directory, mode, recipe_path): app = directory / 'app' private = directory / 'private' app.mkdir(mode=0o700) @@ -93,13 +93,17 @@ async def authority(binary, resources, directory, mode): root = load_signer_file(private / 'root.json').signer actor = load_signer_file(app / 'actor.json').signer managers = {name: load_signer_file(private / (name + '.json')).signer for name in MANAGERS} - review = decode(gateway(binary, 'review', '--recipe', HERE / 'recipe.json', + review = decode(gateway(binary, 'review', '--recipe', recipe_path, '--profile-lock', HERE / 'profile.lock.json')) now, expires = int(time.time()), int(time.time()) + 3600 audience = 'mcp://airtable-gateway-demo' permission = Permission('tools/call', audience + '/tools/set_demo_status_v1') permissions = (permission,) + tuple(Permission('tools/call', audience + '/tools/' + tool) for tool in READ_TOOLS) + managed = recipe_path.name == 'managed-recipe.json' + if managed: + from managed_content import CONTENT_TOOLS + permissions += tuple(Permission('tools/call', audience + '/tools/' + tool) for tool in CONTENT_TOOLS) policy = AssurancePolicy('raw-key-baseline', tuple(AssuranceRequirement(*row) for row in [ ('root', 'every', 'self-certifying-identifier'), ('actor', 'every', 'self-certifying-identifier'), @@ -113,6 +117,20 @@ async def authority(binary, resources, directory, mode): grants['default'] = {'bytes': b64(grant.signed_grant), 'evidence': [ {'type': item.evidence_type, 'media_type': item.media_type, 'bytes': b64(item.bytes)} for item in grant.evidence]} + if managed: + # The development proposal simulator retains this fixed actor key + # before handing files to the app. Never open an app-writable signer + # configuration from the root operator process. + write(private / 'content-actor.seed', read(app / 'actor.seed'), new=True) + write(private / 'content-actor.json', canonical({'schema': 'auths.approval-signer/1', + 'custody': 'development-ed25519', 'seed_file': 'content-actor.seed'}), new=True) + content_grant = await author_root_grant(signer=root, subject=actor.descriptor.principal, + profile=Profile('auths.mcp', 2), permissions=permissions[3:], audiences=[audience], + not_before=now - 3600, expires_at=expires, remaining_depth=0, + assurance_floor='raw-key-baseline', requested_at=now) + grants['content'] = {'bytes': b64(content_grant.signed_grant), 'evidence': [ + {'type': item.evidence_type, 'media_type': item.media_type, 'bytes': b64(item.bytes)} + for item in content_grant.evidence]} anchors = [TrustAnchor('operator-root', root.descriptor.principal, ('raw-key-v1',), (Profile('auths.mcp', 2),), permissions, (audience,), (audience,), now - 3600, expires, 1, 'raw-key-baseline')] @@ -127,7 +145,7 @@ async def authority(binary, resources, directory, mode): reader = load_signer_file(private / 'reader.json').signer try: read_grant = await author_root_grant(signer=root, subject=reader.descriptor.principal, - profile=Profile('auths.mcp', 2), permissions=permissions[1:], audiences=[audience], + profile=Profile('auths.mcp', 2), permissions=permissions[1:3], audiences=[audience], not_before=now - 3600, expires_at=expires, remaining_depth=0, assurance_floor='raw-key-baseline', requested_at=now) write(private / 'read-grant.json', canonical({'bytes': b64(read_grant.signed_grant), @@ -180,7 +198,7 @@ async def approval_bundle(label, *, fresh=False): approvals = {label: await approval_bundle(label) for label in LABELS} approvals['exact:fresh'] = await approval_bundle('exact', fresh=True) - plan = {'schema': 'auths.airtable-gateway-demo/1', 'mode': mode, + plan = {'schema': 'auths.airtable-gateway-demo/2', 'mode': mode, 'trust': 'separate operator-issued development root and actor; no production trust claim', 'expires_at': expires, 'recipe_digest': review['recipe_digest'], 'base': resources['base'], 'table': resources['table'], 'view': resources['view'], 'grants': grants, @@ -193,6 +211,12 @@ async def approval_bundle(label, *, fresh=False): 'reviews': {label: value['review'] for label, value in approvals.items() if not label.endswith(':fresh')}}, 'approvals': approvals} + plan['managed_content'] = managed + plan['recipe_source_b64'] = b64(read(recipe_path)) + if managed: + recipient_seed = secrets.token_bytes(32) + write(app / 'recipient.seed', recipient_seed, new=True) + plan['recipient_public_key'] = list(development_ed25519_identity_key(recipient_seed).public_key) write(app / 'application.json', canonical(plan), new=True) for index, context in enumerate(contexts): write(private / ('context-' + str(index) + '.cbor'), context, new=True) @@ -280,6 +304,7 @@ def operator_consent(directory, name): class Operator: def __init__(self, mode, owner_ui_port=None): require(os.getuid() == 0, 'demo.operator-root-required') + require(owner_ui_port is None or mode == 'simulation', 'demo.managed-local-simulation-required') require(not HOME.exists(), 'demo.fresh-container-required') HOME.mkdir(mode=0o755) PRIVATE.mkdir(mode=0o700) @@ -290,6 +315,8 @@ def __init__(self, mode, owner_ui_port=None): os.chown(self.sockets, 0, APP_GID) self.port = None self.effect_reviewer = development_ed25519_identity_key() + self.recipe = HERE / ('managed-recipe.json' if owner_ui_port is not None else 'recipe.json') + self.managed_private, self.managed_state = PRIVATE, HOME / 'gateway0' self.owner_review = None if owner_ui_port is not None: from owner_review import OwnerReviewServer @@ -357,7 +384,17 @@ def prepare(self): self.keys['runtime']) require(value.get('id') == record and value.get('fields', {}).get('DemoStatus') == 'Pending', 'demo.runtime-resource-access-refused') - plan = asyncio.run(authority(self.binary, resources, HOME, self.mode)) + plan = asyncio.run(authority(self.binary, resources, HOME, self.mode, self.recipe)) + if self.owner_review is not None: + from managed_content import SOURCE + # A real local response contains a sentinel. It may reach only the + # separately approved recipient's private files, never public HTTP. + self.fixture.records[resources['records'][0]]['PrivateNote'] = 'PRIVATE-MANAGED-CONTENT-SENTINEL' + write(PRIVATE / 'managed-target.json', canonical({ + 'source_operation': SOURCE, 'recipient_key': plan['recipient_public_key'], + 'channel': {'schema': 'auths.gateway-unix-disclosure-channel/1', + 'gateway_uid': 0, 'recipient_uid': APP_UID, 'channel_id': list(secrets.token_bytes(32))}, + 'delivery_instance': list(secrets.token_bytes(32))}), new=True) attempts = HOME / 'attempts' attempts.mkdir(mode=0o700) effect_policy = PRIVATE / 'effect-policy.json' @@ -365,7 +402,7 @@ def prepare(self): '--epoch', '1', '--approver-public-key', self.effect_reviewer.public_key.hex()), new=True) for host in range(3): state = HOME / ('gateway' + str(host)) - args = [self.binary, 'install', '--state-dir', state, '--recipe', HERE / 'recipe.json', + args = [self.binary, 'install', '--state-dir', state, '--recipe', self.recipe, '--profile-lock', HERE / 'profile.lock.json', '--trusted-context', PRIVATE / 'context-0.cbor', '--effect-policy', effect_policy, '--approve-digest', plan['recipe_digest'], '--provider', 'airtable', @@ -407,11 +444,17 @@ def prepare(self): self.start_recovery_reviews(plan) return plan - async def read_packet(self, call, plan): + async def read_packet(self, call, plan, *, content=False): """Managers simulate separately authorizing a native-authored read call.""" - contract, command = read_contract(call) - grant = decode(read(PRIVATE / 'read-grant.json')) - reader = load_signer_file(PRIVATE / 'reader.json').signer + if content: + from managed_content import contract as content_contract + contract, command = content_contract(call) + grant = plan['grants']['content'] + reader = load_signer_file(PRIVATE / 'content-actor.json').signer + else: + contract, command = read_contract(call) + grant = decode(read(PRIVATE / 'read-grant.json')) + reader = load_signer_file(PRIVATE / 'reader.json').signer managers = [load_signer_file(PRIVATE / (name + '.json')).signer for name in MANAGERS] try: proposal = propose_mcp_approval(contract=contract, command=command, @@ -447,6 +490,7 @@ def exact_approval(self, state, name, proof, action, *mode, review_only=False, o output = child([self.binary, 'effect-review', '--state-dir', state, '--proof', proof_path, '--action', action_path, '--not-before', str(now - 1), '--expires-at', str(now + ACTION_VALIDITY_SECONDS), '--request-out', request, + '--binding-out', directory / 'binding', *mode], check=False) if output.returncode != 0: return None @@ -562,6 +606,18 @@ def receive(length): require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') self.request.sendall(struct.pack('>I', len(raw)) + raw) return + if set(request) == {'content'}: + from managed_content import EXPERIMENTS as CONTENT_EXPERIMENTS, prepare + kind = request['content'] + require(type(kind) is str and kind in CONTENT_EXPERIMENTS[:3] + and operator.owner_review is not None, 'demo.managed-owner-review-required') + require(not counts.get('content:' + kind), 'demo.review-attempt-limit') + counts['content:' + kind] = 1 + response = prepare(operator, kind, plan, gateway) + raw = canonical(response) + require(len(raw) <= 4 * 1024 * 1024, 'demo.review-response-bound') + self.request.sendall(struct.pack('>I', len(raw)) + raw) + return require(type(request) is dict and set(request) == {'source'} and type(request['source']) is str and request['source'] in plan['cases'], 'demo.review-source-refused') diff --git a/demos/airtable-gateway/submit.mts b/demos/airtable-gateway/submit.mts index 4a6088389..edabf876b 100644 --- a/demos/airtable-gateway/submit.mts +++ b/demos/airtable-gateway/submit.mts @@ -1,8 +1,9 @@ /** Installed TypeScript gateway client. No provider API, credentials or private SDK. */ import { GatewayClient, GatewayEndpoint } from '@auths-dev/sdk/gateway'; -const [flag, socket] = process.argv.slice(2); -if (flag !== '--socket' || !socket || process.argv.length !== 4) throw new Error('demo.invalid-arguments'); +const [flag, socket, operation] = process.argv.slice(2); +if (flag !== '--socket' || !socket || ![4, 5].includes(process.argv.length) + || (operation !== undefined && operation !== '--content')) throw new Error('demo.invalid-arguments'); if (Object.keys(process.env).some(name => /AIRTABLE|PERSONAL_ACCESS_TOKEN|AWS|PYTHONPATH/.test(name))) throw new Error('demo.credential-environment'); let input = ''; for await (const chunk of process.stdin) { @@ -18,4 +19,9 @@ function bytes(value: unknown): Uint8Array { return result; } const client = new GatewayClient(new GatewayEndpoint(socket)); -console.log(JSON.stringify(await client.submit({proof: bytes(packet.proof_b64), action: bytes(packet.action_b64), approval: bytes(packet.approval_b64)}))); +const inputBytes = {proof: bytes(packet.proof_b64), action: bytes(packet.action_b64), approval: bytes(packet.approval_b64)}; +if (operation === '--content') { + process.stdout.write(await client.acquireContent(inputBytes)); +} else { + console.log(JSON.stringify(await client.submit(inputBytes))); +} diff --git a/demos/airtable-gateway/tests/owner_browser.py b/demos/airtable-gateway/tests/owner_browser.py index 87c6e3bd1..65a06a2eb 100644 --- a/demos/airtable-gateway/tests/owner_browser.py +++ b/demos/airtable-gateway/tests/owner_browser.py @@ -28,12 +28,99 @@ def native_review(name): return json.loads(private_file('/run/demo/private/' + name + '/literal-review.json')) +def provider_counts(): + entries = [json.loads(line) for line in private_file('/run/demo/provider.jsonl').splitlines()] + return {kind: sum(entry['kind'] == kind for entry in entries) for kind in ('read', 'write')} + + +def recipient_files(): + # Inspect the actual authorized recipient account, not an HTTP export. + code = """import json,stat +from pathlib import Path +files=list(Path('/run/demo/app/managed-content').glob('*.content')) +for path in files: + assert stat.S_IMODE(path.stat().st_mode)==0o600 + assert json.loads(path.read_bytes())['fields']['PrivateNote']=='PRIVATE-MANAGED-CONTENT-SENTINEL' +print(json.dumps({'files':len(files),'private_mode':'0600'})) +""" + return json.loads(subprocess.check_output(['docker', 'exec', '--user', '62004:62005', CONTAINER, + '/opt/consumer/bin/python', '-c', code])) + + +def managed_journey(owner, agent, before): + baseline = provider_counts() + assert recipient_files()['files'] == 0 + reviews = [] + for experiment, operation, language in [ + ('managed-acquire', 'managed-read-python', 'python'), + ('managed-acquire-typescript', 'managed-read-typescript', 'typescript')]: + prior = witness() + agent.locator('#experiment').select_option(experiment) + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + native = native_review(operation) + assert owner.locator('#literal').text_content() == native['literal_review'] + literal = json.loads(native['literal_review']) + assert literal['native']['protocol'] == 'acquisition' + assert literal['native']['method'] == 'GET' + assert literal['binding']['operation'] == operation + assert witness() == prior, 'content review entered custody or transport' + assert recipient_files()['files'] == 0, 'acquisition disclosed without independent consent' + owner.locator('#approve').click() + expect(agent.locator('#outcome')).to_have_text('ACQUISITION · RESPONSE-RECORDED', timeout=45000) + result = json.loads(agent.locator('#result-json').text_content()) + assert result['records'][0]['language'] == language + snapshot = result['records'][0]['result']['native']['history']['snapshot'] + assert snapshot['reserved_calls'] == 1 and snapshot['reserved_bytes'] == 1024 + assert snapshot['content_projection']['kind'] == 'ready' + assert witness()['read_transport_entries'] == prior['read_transport_entries'] + 1 + assert recipient_files()['files'] == 0 + reviews.append(literal) + after_acquisitions = witness() + counts = provider_counts() + assert counts == {'read': baseline['read'] + 2, 'write': baseline['write']} + agent.locator('#experiment').select_option('managed-disclose') + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + native = native_review('managed-disclosure') + assert owner.locator('#literal').text_content() == native['literal_review'] + disclosure = json.loads(native['literal_review']) + assert disclosure['native']['protocol'] == 'disclosure' + assert disclosure['binding']['operation'] == 'managed-disclosure' + assert witness() == after_acquisitions and provider_counts() == counts + assert recipient_files()['files'] == 0 + owner.locator('#approve').click() + expect(agent.locator('#outcome')).to_have_text('DISCLOSURE · ACKNOWLEDGED', timeout=45000) + assert recipient_files() == {'files': 1, 'private_mode': '0600'} + assert provider_counts() == counts, 'recipient release refetched or mutated provider data' + after = witness() + for experiment, outcome in [('managed-content-history', 'ACQUISITION · RESPONSE-RECORDED'), + ('managed-release-history', 'DISCLOSURE · ACKNOWLEDGED'), + ('managed-acquire', 'ACQUISITION · RESPONSE-RECORDED'), + ('managed-disclose', 'DISCLOSURE · ACKNOWLEDGED')]: + agent.locator('#experiment').select_option(experiment) + agent.locator('#submit').click() + expect(agent.locator('#outcome')).to_have_text(outcome, timeout=45000) + expect(agent.locator('#submit')).to_be_enabled() + assert witness() == after and provider_counts() == counts + assert recipient_files()['files'] == 1, 'retained history redelivered content' + for endpoint in ('/api/status', '/api/audit'): + with urllib.request.urlopen(APP + endpoint) as response: + assert b'PRIVATE-MANAGED-CONTENT-SENTINEL' not in response.read() + assert 'PRIVATE-MANAGED-CONTENT-SENTINEL' not in agent.locator('body').text_content() + assert after['write_transport_entries'] == before['write_transport_entries'] + return after, reviews, disclosure + + def test_installed_authenticated_owner_review_and_native_recovery(): # Read through the trusted operator account, never an application endpoint. credential = private_file('/run/demo/private/owner-login').decode() - denied = subprocess.run(['docker', 'exec', '--user', '62004:62005', CONTAINER, - 'cat', '/run/demo/private/owner-login'], capture_output=True) - assert denied.returncode != 0 and not denied.stdout + for path in ('/run/demo/private/owner-login', '/run/demo/private/content-actor.seed', + '/run/demo/private/root.seed'): + subprocess.run(['docker', 'exec', CONTAINER, 'test', '-f', path], check=True) + denied = subprocess.run(['docker', 'exec', '--user', '62004:62005', CONTAINER, + 'cat', path], capture_output=True) + assert denied.returncode != 0 and not denied.stdout plan = json.loads(private_file('/run/demo/app/application.json')) assert plan['effect_approvals'] == {}, 'the agent received a preapproved effect' try: @@ -70,6 +157,8 @@ def test_installed_authenticated_owner_review_and_native_recovery(): expect(agent.locator('#outcome')).to_have_text('NOT-SUBMITTED', timeout=45000) assert witness() == before, 'declined effect entered the native runtime' + before, managed_reviews, disclosure_review = managed_journey(owner, agent, before) + agent.locator('#experiment').select_option('exact') agent.locator('#submit').click() expect(owner.locator('#review')).to_be_visible(timeout=45000) @@ -77,6 +166,9 @@ def test_installed_authenticated_owner_review_and_native_recovery(): native = native_review('owner-mutation-exact') assert owner.locator('#literal').text_content() == native['literal_review'], 'review changed or truncated' effect_id = json.loads(native['literal_review'])['effect_id_hex'] + assert all(review['native']['actors'] == json.loads(native['literal_review'])['native']['actors'] + for review in managed_reviews), 'managed content used a different agent actor' + assert disclosure_review['native']['actors'] == managed_reviews[0]['native']['actors'] assert witness() == before status = owner.evaluate('''async () => (await fetch('/api/decision', { method:'POST',headers:{'Content-Type':'application/json', @@ -121,6 +213,24 @@ def test_installed_authenticated_owner_review_and_native_recovery(): '/opt/consumer/bin/python', '/opt/demo/app.py', 'submit', '--experiment', 'replay']) assert json.loads(fresh)['records'][0]['result']['outcome'] == 'observed-by-provider' assert witness() == after_read, 'fresh client replay recreated execution' + # A distinct, consented operation loses its actual provider response. + # The UI must retain unknown and an explicit replay must not send again. + loss_before, counts_before = witness(), provider_counts() + agent.locator('#experiment').select_option('lost-response') + agent.locator('#submit').click() + expect(owner.locator('#review')).to_be_visible(timeout=45000) + assert witness() == loss_before and provider_counts() == counts_before + owner.locator('#approve').click() + expect(agent.locator('#outcome')).to_have_text('UNKNOWN', timeout=45000) + expect(agent.locator('#submit')).to_be_enabled() + expect(agent.locator('#explanation')).to_contain_text('no automatic retry') + loss_after, counts_after = witness(), provider_counts() + assert loss_after['write_transport_entries'] == loss_before['write_transport_entries'] + 1 + assert counts_after['write'] == counts_before['write'] + 1 + agent.locator('#submit').click() + expect(agent.locator('#outcome')).to_have_text('UNKNOWN', timeout=45000) + expect(agent.locator('#submit')).to_be_enabled() + assert witness() == loss_after and provider_counts() == counts_after agent.screenshot(path='/evidence/owner-journey.png', full_page=True) assert all('authorization' not in h and 'cookie' not in h for h in app_headers) browser.close() @@ -132,9 +242,13 @@ def test_installed_authenticated_owner_review_and_native_recovery(): 'substituted_review_refused': True, 'application_cannot_read_owner_credential': True, 'owner_auth_not_sent_to_application': True, 'one_exact_write': True, 'independent_exact_read': True, 'replay_no_extra_execution': True, + 'installed_python_and_typescript_acquisition': True, 'independent_disclosure_consent': True, + 'native_recipient_ack_retained': True, 'recipient_content_mode': '0600', + 'public_http_excludes_private_content': True, 'one_disclosure_no_replay_redelivery': True, + 'same_agent_actor_read_disclosure_write': True, 'unknown_response_loss_no_reentry': True, 'fresh_process_replay_no_new_consent_or_execution': True, 'scope': 'installed packages and native runtime; browser-simulated authenticated owner; local provider', - 'excluded': ['content acquisition/disclosure journey', 'human attention', 'production custody', + 'excluded': ['human attention', 'production custody', 'live provider qualification', 'hostile operating system']}, indent=2)) diff --git a/demos/airtable-gateway/tools/package.py b/demos/airtable-gateway/tools/package.py index 5d866e6b8..d55787a13 100644 --- a/demos/airtable-gateway/tools/package.py +++ b/demos/airtable-gateway/tools/package.py @@ -21,7 +21,7 @@ def main(): source = Path(__file__).resolve().parents[1] repository = source.parents[1] files = {} - for name in ['app.py', 'operate.py', 'owner_review.py', 'demo_common.py', 'double.py', 'selftest.py', 'generated.py', + for name in ['app.py', 'operate.py', 'owner_review.py', 'managed_content.py', 'managed-recipe.json', 'managed-review.json', 'demo_common.py', 'double.py', 'selftest.py', 'generated.py', 'profile.toml', 'profile.lock.json', 'recipe.json', 'vectors.json', 'Dockerfile', 'README.md', 'package.json', 'contract.json', 'launch.py']: files[name] = ((source / name).read_bytes(), 0o644) diff --git a/demos/airtable-gateway/web/app.js b/demos/airtable-gateway/web/app.js index 670b7a690..e0c7d658a 100644 --- a/demos/airtable-gateway/web/app.js +++ b/demos/airtable-gateway/web/app.js @@ -4,24 +4,39 @@ const descriptions = { 'observed-by-provider': 'A fresh provider read matched the verified value and this action’s echo. The link assumes no other writer copied the echo.', observed: 'The gateway read the declared field. Value equality alone does not link that value to this action or establish its effect.', 'recovery-report': 'A separately authorized read completed. Inspect the original write stage, read facts and evidence disposition below; a state match alone is not causation.', - refused: 'The gateway refused this recovery action. No new write was authorized.', + refused: 'The gateway refused this request. Retained history is unchanged; this is no permission to retry an uncertain operation.', + acknowledged: 'The gateway retained the exact recipient acknowledgement. It is a disclosure fact, separate from a provider response or a write observation.', + 'entry-granted': 'A durable acquisition grant exists. Provider entry may have occurred, but no response is recorded yet; no new read is authorized by this history.', reserved: 'The operation is reserved. Another process may still be working; this is not permission to repeat delivery.', - 'response-recorded': 'The gateway recorded an HTTP response. This alone does not establish an effect.', + 'response-recorded': 'The gateway recorded an HTTP response. An acquisition response retains private content; it does not establish recipient delivery. A write response alone does not establish its effect.', unknown: 'The outcome remains unknown. The provider may have received the write; its response or matching fresh value and echo is unavailable. Authority remains consumed; no automatic retry is allowed.', 'not-entered': 'The gateway refused before write transport. A provider-read guard may already have acquired a credential and read evidence.', denied: 'Native proof verification refused this exact action.', indeterminate: 'Native verification could not establish authority.', 'transport-unconfirmed': 'The app lost its gateway exchange. Entry may have occurred. Inspect through the operator; do not retry a write automatically.', 'signed-observation': 'The gateway returned signed stored-outcome bytes. This is an observation, not a new provider write.', - 'not-submitted': 'Native approval collection stopped before the gateway. Simulator state alone cannot authorize an action.', + 'not-submitted': 'The requested review or approval stopped before native submission. Earlier operation history is unchanged.', }; let token; function display(record) { - const outcomes = record.records.map(item => item.result.outcome); - element('outcome').textContent = record.records.map(item => item.result.outcome === 'observed' - ? (item.result.matched === false ? 'FIELD READ · VALUE MISMATCH' : 'FIELD READ · UNLINKED') - : item.result.outcome.toUpperCase()).join(' / '); - element('explanation').textContent = outcomes.map(value => descriptions[value] || 'Inspect the exact gateway result below.').join(' '); + element('outcome').textContent = record.records.map(item => { + if (item.result.native?.outcome === 'history') { + return `${item.result.native.history.kind.toUpperCase()} · ${item.result.outcome.toUpperCase()}`; + } + return item.result.outcome === 'observed' + ? (item.result.matched === false ? 'FIELD READ · VALUE MISMATCH' : 'FIELD READ · UNLINKED') + : item.result.outcome.toUpperCase(); + }).join(' / '); + element('explanation').textContent = record.records.map(item => { + const kind = item.result.native?.history?.kind; + if (kind === 'disclosure' && item.result.outcome === 'unknown') { + return 'Disclosure is unknown: bytes may have reached the recipient, but the exact ACK is not retained. Allocations remain charged; no automatic redelivery is allowed.'; + } + if (kind === 'acquisition' && item.result.outcome === 'unknown') { + return 'Acquisition is unknown: provider entry may have happened without a retained response. This does not authorize a new read or any recipient release.'; + } + return descriptions[item.result.outcome] || 'Inspect the exact native facts below.'; + }).join(' '); element('result-json').textContent = JSON.stringify(record, null, 2); const reviewed = record.records.find(item => item.result.literal_review); if (reviewed) element('approval-review').textContent = reviewed.result.literal_review; @@ -52,16 +67,22 @@ async function initialize() { element('experiment').querySelector(`[value="${value}"]`).disabled = true; } } + for (const option of element('experiment').options) { + if (option.value.startsWith('managed-')) option.disabled = !status.managed_content; + } element('submit').disabled = Date.now() >= status.expires_at * 1000; if (status.records.length) display(status.records.at(-1)); function proposal() { const value = element('experiment').value; const original = value === 'recover-loss' ? 'lost-response' : value === 'recover-competing' ? 'competing-writer' : 'exact'; const action = status.proposals[value] || status.proposals[original]; - element('proposal').textContent = `${action.record_id} → ${action.replacement} · operation ${action.operation_id}`; + const managed = value.startsWith('managed-'); + element('proposal').textContent = managed + ? `Native bounded acquisition or separate disclosure of record ${action.record_id}. History actions perform no provider or recipient I/O.` + : `${action.record_id} → ${action.replacement} · operation ${action.operation_id}`; const source = value.startsWith('recover-') ? value.slice(8) : value; const review = status.effect_review.reviews[source] || (['replay', 'typescript', 'observe'].includes(value) ? status.effect_review.reviews.exact : null); - element('approval-review').textContent = value.startsWith('recover-') ? 'A separate native read review and operator consent are required. The exact read review is retained with its result.' : review || 'Native review refused this hostile input. This experiment substitutes another effect’s approval and must be rejected.'; + element('approval-review').textContent = managed ? 'Each new acquisition or disclosure requires its own complete native review and authenticated owner consent. The browser displays facts only; content stays in the authorized recipient’s private files.' : value.startsWith('recover-') ? 'A separate native read review and operator consent are required. The exact read review is retained with its result.' : review || 'Native review refused this hostile input. This experiment substitutes another effect’s approval and must be rejected.'; const link = element('provider-link'); link.hidden = status.mode !== 'live' || !/^rec[A-Za-z0-9]{14}$/.test(action.record_id); if (!link.hidden) { diff --git a/demos/airtable-gateway/web/index.html b/demos/airtable-gateway/web/index.html index a02b347fa..ea2c37ba4 100644 --- a/demos/airtable-gateway/web/index.html +++ b/demos/airtable-gateway/web/index.html @@ -5,7 +5,8 @@

Exact authority. A separate execution boundary.

Let the app propose a status.
Keep the Airtable token out of its hands.

Set one record’s DemoStatus in a fixed disposable table. -The app submits proof and the exact action. The general gateway owns the PATCH and token.

+The app submits proof and the exact action. The general gateway owns the PATCH and token. +With the authenticated owner UI, separately approve bounded private acquisition and release to the local agent.

Checking the demo…

Approved authority

Fixed base
—
Fixed table
—
@@ -29,15 +30,20 @@

Let the app propose a status.
Keep the Airtable token out of its hands.Provider returns 429 -

Each experiment fixes its record, operation and signed arguments.

+ + + + + +

Each experiment fixes its record, operation and signed arguments.

The native review binds the exact action, authority and expiry.

Run the exact update before replay. Recovery requests a separate native proof and exact approval for a bounded read. Replaying the original operation only inspects retained history. Wait three seconds after response loss before observing again. The local simulator supplies signed responses only for this closed fixture; its UI state is never authority.

Measured native result

No action submitted

-
  1. Verify proof
  2. Claim operation
  3. Enter provider
  4. Record response
  5. Observe value + echo
-

Authorization, a recorded HTTP response and a matching fresh value/echo are separate facts.

+
  1. Verify authority
  2. Approve exact effect
  3. Admit and grant
  4. Enter provider or recipient
  5. Record response or ACK
  6. Observe separately
+

Authorization, an acquisition response, a recipient ACK and a matching fresh value/echo are separate facts.

{}
Inspect the evidence →

What this run can establish

This is a development demo, not protected production qualification. Simulation never reaches Airtable. diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index faebf9468..ec903e7c8 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -131,6 +131,20 @@ times or create an entry permit. This remains a simulation demonstration with hosted tests authored; complete installed acquisition/disclosure UI, broader containment and exact-head evidence remain required. +The installed local owner journey now composes an additional data-only reviewed +recipe with the existing content capability. It uses one native control/journal +for acquisitions, separate recipient release and writes, and the same native +agent actor. Python and TypeScript submit native acquisition inputs; the native +recipient CLI owns the authenticated channel, exact byte check and ACK. The +application stores authorized plaintext only in recipient-private files and +shows the gateway's retained facts. No Python/TypeScript effect hash, permit, +accounting decision, ACK codec or second admission owner is introduced. The +root-private development actor simulator uses a fixed copy created before app +file ownership changes; it never opens an app-writable signer configuration as +root. Local recipe selection is an explicit capability choice, with no legacy +reader or alternate runtime implementation. Exact-head hosted execution and +broader containment/adverse-path obligations remain required. + Recovery exposes bounded observation work, retained charges and escalation. Administrative annotations are not provider evidence; no administrative path can convert post-grant uncertainty into non-entry or silently release capacity. diff --git a/docs/plans/0074-hosted-evidence-74ce9f75.md b/docs/plans/0074-hosted-evidence-74ce9f75.md new file mode 100644 index 000000000..e4387e1bf --- /dev/null +++ b/docs/plans/0074-hosted-evidence-74ce9f75.md @@ -0,0 +1,151 @@ +# AP074 hosted evidence — 74ce9f75 + +This report records execution for published source +`74ce9f753faa6bf3f1cb065bc369f655e6c0b236` on draft PR #213. It does not +establish completion of AP074 or qualify later source changes. The remaining +source defect is the stale gateway semantic closure; its repair belongs to +the subsequent epoch and metadata batch. + +## Producer identity + +The PostgreSQL, Python source-contract and external-consumer jobs checked out +PR merge `df0cc98e6eae440db67038c4f552b74e1d64b90f`, merging the published +head into `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b`. Both the merge and +published source have Git tree +`bdc10c7f90813049c0b973327f51e5adf3f4f622`, verified by fetching the merge +and comparing the trees. Workflow source labels do not replace this actual +producer identity. + +## Failure and repaired prior failures + +[Authoritative implementation job 123749843777](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123749843777) +failed `semantic_closure::tests::semantic_closure_is_current`. The gateway +slice finished with 269 passed, 1 failed and 43 ignored tests. The +[authoritative rollup](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123754086228) +failed for that same cause. + +A read-only comparison found stale manifest hashes for +`effect_native_tests.rs`, `engine.rs`, `native_information_replay_tests.rs`, +`scenario_tests.rs` and `store.rs`; the manifest also omitted +`native_differential_tests.rs`, `native_retention_tests.rs` and +`store_retention_tests.rs`. No entries had been removed. The native generator +must regenerate the gateway manifest and compiled digest from the subsequent +combined source, followed by a rebuilt non-update check. The unchanged formal +source closure below is a distinct identity and does not satisfy this gate. + +Both earlier CI roots were verified repaired on this head: + +- [Repository preflight 123746949082](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123746949082) + passed strict workspace lint, including the native differential generator. +- [PostgreSQL job 123745460518](https://github.com/auths-dev/auths-proof/actions/runs/40958689260/job/123745460518) + executed the repaired spawned reference worker, actual SIGKILL and unchanged + conservation assertions as part of the successful information comparison. + +## Native, differential and restore evidence + +The PostgreSQL workflow ran all 24 explicit native selectors exactly once. +Each selector's actual output was followed by `1 passed; 0 failed; 0 ignored`. +This comprises the CLI process-capacity case and 23 exact file/PostgreSQL +library cases, including both nested retention fixtures. The uploaded log +was downloaded and checked against the selectors in this revision's workflow. + +After installing this checkout's native Python SDK, the same job executed +**22 independent information pairs across both adapters**. The report records +source commit `df0cc98e6eae440db67038c4f552b74e1d64b90f`, run `40958689260`, +attempt `1`. Its scope remains post-authorization application state: it does +not establish AP070 managed authorization, recipient-ACK equivalence or live +Google behavior. + +[Python source-contract job 123745459370](https://github.com/auths-dev/auths-proof/actions/runs/40958688998/job/123745459370) +executed the exact native mutation generator and the independent comparator: +**28 requests, 26 responses and 2 families**. This retains the documented +boundary between native compilation/classification and independent domain +references; it is not provider execution qualification. + +[Reference simulation job 123745461358](https://github.com/auths-dev/auths-proof/actions/runs/40958688981/job/123745461358) +passed **104 source-only tests**, including mutation-contract negatives and +information-log parser controls. Synthetic malformed logs prove rejection +behavior; they are not native execution evidence. + +Both differential artifacts were downloaded and their ZIP SHA-256 values +verified against GitHub: + +| Artifact | ID | ZIP SHA-256 | +| --- | --- | --- | +| Information report and native log, run 40958689260 attempt 1 | 12934958430 | `c7af0195a0a6645e2cc6fa58f6b0ada451b46692c98649edfac35d4b551b08c0` | +| Mutation report and native corpus, run 40958688998 attempt 1 | 12933979778 | `3437045757e96a2f1020cb729935e280a2ad8758c125646608f9f766ec1143e0` | + +The PostgreSQL job then passed the physical-backup/WAL point-in-time restore +exercise: the pre-target value was retained and the post-target value was +excluded. Its report explicitly records `replay_continuity_claim: false`; +restore success does not establish replay continuity. + +## Formal evidence + +[Translation job 123749843927](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123749843927) +passed validated reuse from successful source `d9618a56`, run `40942189152`, +attempt `1`. Current phase artifact `12935932042` was downloaded and verified +with ZIP SHA-256 +`0a7c6b905104cd086c5aa247322d28f8764a73c09ca22ddc032636aa685bc76d`. +It records `execution: reused-pr-run`, `reproduction_count: 2` and these +identities: + +| Identity | SHA-256 | +| --- | --- | +| Formal source closure | `a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825` | +| Planned translation closure | `a5a98c9c76bde8f03021fd572008961e2c425d11a8eb9ba2080b270b4a65c519` | +| Toolchain closure | `baff1cabbf9c83ffca0f4bdb1b8dda685a5ac59638e95d6d12e57f5d5bda9633` | +| Evidence closure | `cbc4400d316703bd0a0af4136f65c580047835a03144353343d051214233269f` | + +[Authoritative Lean job 123756976236](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123756976236) +passed its clean rebuild: 329 compiled claims and reviewed transitive axioms, +4 reviewed external links with 0 compiled external axioms, and 4 Rust +refinement tests. [Kani job 123749843917](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123749843917) +recorded 49 successful verifications. The separate formal-fast feedback job +also passed; it is not qualification evidence. + +[Final formal evidence job 123766644169](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123766644169) +passed exact-revision aggregation of translation, clean Lean and Kani. +[Formal-translation rollup 123769550016](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123769550016) +also passed. Final evidence artifact `12938720181` was downloaded and verified +with ZIP SHA-256 +`9611da85b53cfdac51ee1c90a2c9667157845962daf82189865dc3abfaf9cd0f`. + +## Terminal result + +All **96 checks** are terminal: **85 passed, 3 failed and 8 conditionally +skipped**. The three failures are the authoritative implementation, its +rollup and [CI qualified 123769584918](https://github.com/auths-dev/auths-proof/actions/runs/40958689238/job/123769584918). +The final qualified gate records `AUTHORITATIVE: failure`; its formal, +compliance, dependency, secret and required live-reference inputs succeeded. +These three failures share the single stale gateway-closure root above. + +The **14 workflows** ended with **12 passed, 1 failed (CI) and 1 conditional +skip (custody live)**. Python's complete supported interpreter/platform +matrix and installed native harnesses passed, as did packed TypeScript and +both installed demos. No platform was removed or retried. + +## Workflow inventory + +| Workflow | Run | Result | +| --- | --- | --- | +| CI | [40958689238](https://github.com/auths-dev/auths-proof/actions/runs/40958689238) | Failed: stale gateway closure | +| PostgreSQL lifecycle | [40958689260](https://github.com/auths-dev/auths-proof/actions/runs/40958689260) | Passed | +| Python SDK | [40958688998](https://github.com/auths-dev/auths-proof/actions/runs/40958688998) | Passed | +| TypeScript SDK | [40958689256](https://github.com/auths-dev/auths-proof/actions/runs/40958689256) | Passed | +| SDK recipes | [40958689237](https://github.com/auths-dev/auths-proof/actions/runs/40958689237) | Passed | +| Recipe qualification | [40958688981](https://github.com/auths-dev/auths-proof/actions/runs/40958688981) | Passed non-live stages; live qualification stages skipped | +| Operator package | [40958689233](https://github.com/auths-dev/auths-proof/actions/runs/40958689233) | Passed | +| Isolation | [40958689244](https://github.com/auths-dev/auths-proof/actions/runs/40958689244) | Passed | +| Airtable installed demo | [40958689243](https://github.com/auths-dev/auths-proof/actions/runs/40958689243) | Passed | +| Stripe installed demo | [40958689266](https://github.com/auths-dev/auths-proof/actions/runs/40958689266) | Passed | +| Independent Google images | [40958689239](https://github.com/auths-dev/auths-proof/actions/runs/40958689239) | Passed application-owned reference | +| Git signing protocol | [40958688983](https://github.com/auths-dev/auths-proof/actions/runs/40958688983) | Passed | +| Branch-protection action | [40958689248](https://github.com/auths-dev/auths-proof/actions/runs/40958689248) | Passed | +| Custody live | [40958689252](https://github.com/auths-dev/auths-proof/actions/runs/40958689252) | Conditional skip | + +No workflows were rerun or cancelled during this investigation. No provider +calls, unattended operator consent, AP070/AP073 source changes, merge or +deployment were performed. Conditional skips are not passed live evidence. +The final source head still requires its own applicable CI and acceptance +checks after the gateway closure and epoch changes. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 698ee1cb9..1c48d5600 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2957,14 +2957,69 @@ generated durable histories/formal linkage, supported rollback floors, bounded performance and all required hosted checks on the final completed head. AP070 and the paused AP073 checkout remain unchanged by this batch. +## Installed managed owner/agent journey (authored) + +The previous published74ce cohort is fully terminal: 85 passed, 3 failed and +8 conditionally skipped checks across 14 workflows (12 succeeded, CI failed, +custody conditionally skipped). The three failures share the stale gateway +semantic closure root repaired in local epoch commit `41763d5a`. Actual formal +aggregation passed after 329 compiled Lean claims, 49 Kani verifications and the +four native Rust refinement tests. Translation evidence is validated reuse under +unchanged a002 source, not a new translation. Full exact identities, artifact +checksums and scoped behavioral evidence are in +[the 74ce report](0074-hosted-evidence-74ce9f75.md). No healthy jobs were cancelled. + +The next source increment composes the existing native content capability into +the installed authenticated owner journey. A separate local data-only managed +recipe retains the original mutation declaration and adds a bounded fixed-record +GET (response1,024/content512 bytes). The maintained live/reference recipe stays +unchanged. Native recipe-review construction completed successfully and produced +`demos/airtable-gateway/managed-review.json`; the hosted packaging workflow now +reconstructs and compares it. This is actual pure compilation/review evidence, +not an executed read/disclosure or new provider qualification. + +The private demonstration plan advances directly to `/2`; old disposable plans +are refused rather than read through compatibility fallbacks. + +Installed Python and TypeScript clients each submit a separately authorized +acquisition. A separate complete native owner review gates release to a pinned +local recipient. The native CLI runs as the application UID and owns recipient +identity, channel authentication, exact binding/bytes and ACK. The browser shows +native acquisition/ACK facts and preserves the difference between sending an ACK +and the gateway recording it. Authorized recipient output is confined to recipient-private +files; public history does not return it. The actor is the same native agent for +read, disclosure and write. The development proposal simulator retains a fixed +root-private actor-key copy before app ownership changes, never loads a mutable +app signer configuration as root, and remains explicitly separate from exact +reviewer keys. A thin testkit seed import calls the existing native Ed25519 +implementation; no Python signing/hash/ACK or admission semantics are added. + +The source-free browser scenario is expanded to assert actual provider counters, +review-before-entry, both installed language acquisitions, no content release on +acquisition, separate disclosure consent, native recorded ACK, private0600 files, +public sentinel exclusion and replay without new calls or files. It then performs +the reviewed write, independently authorized observation and a distinct real +response-loss/unknown control with no reentry. These new runtime/browser/SDK cases +are authored and have not executed locally or hosted. Exact-head hosted results, +remaining negative/containment scope, file/PostgreSQL adverse schedules, generated +concurrent histories, rollback floors and bounded performance remain mandatory. +AP070 remains independent and AP073 untouched. + +Semantic metadata construction advances freeze413 and only the generator-reported +identity157, portable-ABI126, mechanism-profile13, public-SDK154, +simplified-waist20 and public-surface413 identities. The gateway Rust source +closure remains the repaired epoch commitment; the formal translation source +closure remains a002. These metadata updates do not execute the new browser/SDK +cases and are not a fresh formal proof. + ## Phase gates | Phase | State | Outstanding gate | | --- | --- | --- | | P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | -| P1 | Binding, approval and native review contract wired | Installed authenticated approval journey, frontend rendering and integration evidence | +| P1 | Binding, approval and native review contract wired; installed write/recovery owner UI executed on74ce | New complete content journey and remaining adversarial review/binding parity evidence | | P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition/disclosure runtime, call authoring and CLI process composition wired | Installed managed bindings/authenticated UI and full native read/release evidence; AP070 stays independent | +| P3 | Acquisition/disclosure runtime, call authoring and CLI composition wired; installed Python/TypeScript acquisitions and native recipient UI authored | New exact-head installed journey execution and remaining native adverse read/release cases; AP070 stays independent | | P4 | Partial CLI process journey | Differential, full faults/adapters, installed bindings/UI, formal/performance links and CI | ## Acceptance ledger @@ -2996,7 +3051,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / independent mutation and post-authorization information comparisons against unchanged references / hosted74ce mutation 28 requests + 26 responses, information 22 pairs across both adapters and 104 source/parser controls passed | Named A19 contracts audited in the differential-contracts document; final-head confirmation remains required, with AP070 independence and divergent claims retained | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | | A21 | Tombstones, stale state, supported rollback floors | Partial / bounded maintenance/shared clock and one active epoch control per partition / hosted74ce six native read/release cleanup histories passed; two new file/TLS PostgreSQL epoch histories constructed locally preserve replay and lifetime slots | New-head hosted epoch verification, reserved/mutation retention, concurrent epoch/configuration schedules and supported rollback-floor evidence remain required | -| A22 | Installed single-human/single-agent full journey/UI | Partial / real daemon and CLI / read, recipient disclosure, exact write and independent observation executed with simulated signing | Installed language packages, authenticated human UI and hostile isolated agent still required | +| A22 | Installed single-human/single-agent full journey/UI | Partial / native daemon/CLI journey executed; installed authenticated write/recovery UI passed74ce; full same-actor Python/TypeScript acquisition/native disclosure/write/observation/unknown journey now authored | Execute the expanded source-free browser/package journey on the new head; complete hostile interface inventory and remaining adverse/negative integration evidence | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 279eb3ef6..277e333bb 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -826,3 +826,29 @@ exact approval, preserve both histories and all replay charges, and assert sourc lifetime allocation slots `[0, 1]` across epochs. They do not establish every race schedule, hostile-process containment, or an independent rollback anchor. No new semantic abstraction, provider branch or admission journal is added. + +### Installed owner/agent content composition + +The local Airtable owner demonstration consumes the already admitted content +capability through a separate data-only `managed-recipe.json`. Its fixed-record +GET shares the native partition/control/journal with the reviewed PATCH; it does +not turn the independent reference into managed execution or change that +reference's recipe. Native recipe review construction bounds response/content +to 1,024/512 bytes. No new shared semantic extraction is proposed. + +Public SDK frozen dataclasses represent native-authored content/release calls; +they do not interpret provider fields or select lifecycle transitions. Both +installed language clients call native acquisition. The native recipient CLI +receives into app-UID private files and owns key authentication, channel, binding, +exact bytes and ACK. History polling distinguishes ACK sent from ACK retained, +performs no external I/O and cannot issue another permit. Public HTTP exports +only native redacted facts and the already reviewed proposal. + +The browser scenario authors same-actor acquisition/disclosure/write, separate +authenticated owner consent, real provider counters and native Unix delivery, +private sentinel checks, replay without new calls/files, independent recovery +and actual unknown response-loss presentation. It is not yet hosted evidence. +The development simulator retains a fixed actor key copy before app ownership +changes, separately from exact reviewer keys; production/exclusive signing +custody, human attention and hostile-OS claims remain excluded. The maintained +AP070 reference and every remaining AP074 gate are unchanged. diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index ce511be4f..ea914b811 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 412 +freeze_version = 413 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,9 +45,9 @@ freeze_version = 412 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 156 +"auths.identity.protocol" = 157 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 125 +"auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -58,13 +58,13 @@ freeze_version = 412 "auths.product.github-issue-address-v2" = 4 "auths.product.lifecycle" = 17 "auths.product.mcp-closed-execution" = 32 -"auths.product.mechanism-profile-conformance" = 12 +"auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 153 +"auths.product.public-sdk-contract" = 154 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 -"auths.product.simplified-waist" = 19 +"auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 412 +"auths.release.public-surface" = 413 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 6fcc118aa..f7d2858bb 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 412, + "freezeVersion": 413, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 156, + "version": 157, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "76654e9d7ea8713198f868f4cdbb06504fde6f9a692372e2a808736689a54a41" + "sha256": "747673b3a22a4943b17a9b469f3850e70494ab0f455a0bbbdf4e2ebda42c004b" }, { "id": "auths.modular-components", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 125, + "version": 126, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "26330f8e6c0b586b5a410e85bb1365eb99c0d1e2534d2ea0a5d2a975b84b9cfb" + "sha256": "2ff3683341e747635d0e4c0a9d806ed1cd9c5d73fccbbe58fe40ce66dd1a9cbb" }, { "id": "auths.product.bounded-domains", @@ -827,7 +827,7 @@ }, { "id": "auths.product.mechanism-profile-conformance", - "version": 12, + "version": 13, "classification": "frozen-meaning", "categories": [ "contract-inventory", @@ -845,7 +845,7 @@ "product/conformance/v2/mechanism-profile-conformance.json", "xtask/src/mechanism_conformance.rs" ], - "sha256": "e244fa56d6e665d11baa9b5a21d3d09e737e768ef27d08788d420323d14105e1" + "sha256": "7791fe4bf36b4ddd221b50f15a4241ec319e9c5c2e17d3f130973c342757af84" }, { "id": "auths.product.operations", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 153, + "version": 154, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "47be70ee7a9f72bc6a29051e11fb35d29ee59c9bc6e4dd31d720e0777ec08cca" + "sha256": "5a51215a85bdcf83dbc78c206b54772d55488823427383d495e82537013c1b08" }, { "id": "auths.product.receipts", @@ -927,7 +927,7 @@ }, { "id": "auths.product.simplified-waist", - "version": 19, + "version": 20, "classification": "frozen-meaning", "categories": [ "product-waist-invariants", @@ -943,7 +943,7 @@ "product/conformance/v1/simplified-product-waist.json", "xtask/src/product_waist.rs" ], - "sha256": "585e9e8d553a9d4317f5e6b97d9ce868d19d169fc7c1459e15df0f7869facae5" + "sha256": "fed7f48b980bd1219c3301f46e0e5681c5bd5ba980d75fdc72cda7424f4493dd" }, { "id": "auths.product.vocabulary", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 412, + "version": 413, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "3b1d08c2aa408702bd2e06b2ef140cab70238b740fadc35c30483c7fa7bbf700" + "sha256": "1f511dc268f546ef880a6ff964fa80e4599e375a8c914252a587683f3faee3e9" } ] } From 25c937091f3a77f012d0a1eb1868ee4f2b7674b9 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:00:36 +0000 Subject: [PATCH 100/136] fix(demo): complete installed managed owner journey --- .github/workflows/airtable-gateway-demo.yml | 1 + demos/airtable-gateway/README.md | 5 ++-- demos/airtable-gateway/double.py | 5 ++++ demos/airtable-gateway/managed-recipe.json | 5 ++-- demos/airtable-gateway/managed-review.json | 9 ++++--- demos/airtable-gateway/tests/owner_browser.py | 14 ++++++++-- .../tests/test_provider_ledger.py | 27 +++++++++++++++++++ 7 files changed, 56 insertions(+), 10 deletions(-) create mode 100644 demos/airtable-gateway/tests/test_provider_ledger.py diff --git a/.github/workflows/airtable-gateway-demo.yml b/.github/workflows/airtable-gateway-demo.yml index 9d88f5747..e293ab63f 100644 --- a/.github/workflows/airtable-gateway-demo.yml +++ b/.github/workflows/airtable-gateway-demo.yml @@ -85,6 +85,7 @@ jobs: run: | python demos/airtable-gateway/tests/test_launch.py python demos/airtable-gateway/tests/test_owner_review.py + python demos/airtable-gateway/tests/test_provider_ledger.py - name: Construct the source-free demo handoff run: | python demos/airtable-gateway/tools/package.py \ diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index ca2121c8b..3a34a7883 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -273,8 +273,9 @@ remain separate gates in AP-SPEC-066 and [AP-SPEC-068](../../docs/specs/0068-air The optional authenticated owner UI selects `managed-recipe.json` for the local simulation. Its mutation declaration matches the maintained record-update recipe; -an additional bounded GET can retain at most 512 UTF-8 bytes from a response -bounded to 1,024 bytes. `managed-review.json` is the actual native recipe review, +an additional bounded GET projects the `/fields/PrivateNote` JSON string into +at most 512 private UTF-8 bytes from an `application/json` response bounded to +1,024 bytes. `managed-review.json` is the actual native recipe review, reconstructed and compared by CI. The original recipe remains the live/reference recipe. This local variant grants no managed Google or live-provider claim. diff --git a/demos/airtable-gateway/double.py b/demos/airtable-gateway/double.py index aae7b4be5..1cf90d2ca 100644 --- a/demos/airtable-gateway/double.py +++ b/demos/airtable-gateway/double.py @@ -2,6 +2,7 @@ import hashlib import hmac import json +import os import socket import threading import time @@ -21,6 +22,10 @@ def record_ids(): class Fixture: def __init__(self, ledger, fixture_token): + # An empty owned ledger is positive evidence of zero requests. Never + # truncate retained evidence or let counter readers infer missing = zero. + descriptor = os.open(ledger, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + os.close(descriptor) self.lock, self.ledger, self.token = threading.Lock(), ledger, fixture_token self.records = {record: {'DemoStatus': 'Pending', 'auths_echo': ''} for record in record_ids()} self.hidden_until = {} diff --git a/demos/airtable-gateway/managed-recipe.json b/demos/airtable-gateway/managed-recipe.json index bf80505fe..b748ca6d1 100644 --- a/demos/airtable-gateway/managed-recipe.json +++ b/demos/airtable-gateway/managed-recipe.json @@ -80,7 +80,7 @@ "schema": "auths.effect-review-contract/1", "consequences": [ "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.", - "A separately approved bounded GET can retain this record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." + "A separately approved bounded GET can retain the PrivateNote string of this JSON record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." ], "fields": { "record_id": { @@ -116,7 +116,8 @@ ], "query": [], "projection": { - "kind": "utf8" + "kind": "json-string", + "pointer": "/fields/PrivateNote" }, "maximum_response_bytes": 1024, "maximum_content_bytes": 512 diff --git a/demos/airtable-gateway/managed-review.json b/demos/airtable-gateway/managed-review.json index 0bad2a3b7..52412c9e4 100644 --- a/demos/airtable-gateway/managed-review.json +++ b/demos/airtable-gateway/managed-review.json @@ -4,7 +4,7 @@ "schema": "auths.effect-review-contract/1", "consequences": [ "Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.", - "A separately approved bounded GET can retain this record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." + "A separately approved bounded GET can retain the PrivateNote string of this JSON record as private UTF-8 content. Releasing it to the exact local recipient requires a separate native disclosure proof, exact approval and authenticated channel; acquisition does not disclose it." ], "fields": { "record_id": { @@ -17,7 +17,7 @@ } } }, - "digest": "7b3fe9ccc12afd4c4398b944a81e42dc7a00992e8e4af176391fc204d0f0cb37", + "digest": "88f9e64b3f82ff6d369a31082d9e2b00890b0d676bb1c0c8e3610e961b1769eb", "operator_namespace": "airtable-demo", "service": "airtable-gateway-demo", "tool": "set_demo_status_v1", @@ -81,7 +81,8 @@ ], "query": [], "projection": { - "kind": "utf8" + "kind": "json-string", + "pointer": "/fields/PrivateNote" }, "maximum_response_bytes": 1024, "maximum_content_bytes": 512 @@ -106,7 +107,7 @@ "account_scope": null, "relative_ceiling": null, "bounds": null, - "recipe_digest": "7b3fe9ccc12afd4c4398b944a81e42dc7a00992e8e4af176391fc204d0f0cb37", + "recipe_digest": "88f9e64b3f82ff6d369a31082d9e2b00890b0d676bb1c0c8e3610e961b1769eb", "verifier_configuration": "4438003caabb21ef7848726c143782b3cb4c26adac7f609c70b23917613ef035", "profile_policy": "mcp-arguments-v1", "bounded_policy_extension": "bounded-policy-commitment-v1" diff --git a/demos/airtable-gateway/tests/owner_browser.py b/demos/airtable-gateway/tests/owner_browser.py index 65a06a2eb..9a28f8f0a 100644 --- a/demos/airtable-gateway/tests/owner_browser.py +++ b/demos/airtable-gateway/tests/owner_browser.py @@ -40,7 +40,7 @@ def recipient_files(): files=list(Path('/run/demo/app/managed-content').glob('*.content')) for path in files: assert stat.S_IMODE(path.stat().st_mode)==0o600 - assert json.loads(path.read_bytes())['fields']['PrivateNote']=='PRIVATE-MANAGED-CONTENT-SENTINEL' + assert path.read_bytes()==b'PRIVATE-MANAGED-CONTENT-SENTINEL' print(json.dumps({'files':len(files),'private_mode':'0600'})) """ return json.loads(subprocess.check_output(['docker', 'exec', '--user', '62004:62005', CONTAINER, @@ -63,12 +63,19 @@ def managed_journey(owner, agent, before): literal = json.loads(native['literal_review']) assert literal['native']['protocol'] == 'acquisition' assert literal['native']['method'] == 'GET' + assert literal['native']['content']['projection'] == { + 'kind': 'json-string', 'pointer': '/fields/PrivateNote'} + assert literal['native']['content']['required_media_type'] == 'application/json' assert literal['binding']['operation'] == operation assert witness() == prior, 'content review entered custody or transport' assert recipient_files()['files'] == 0, 'acquisition disclosed without independent consent' owner.locator('#approve').click() + # Both clients produce the same outcome label; wait for this request's + # completion before reading its result instead of accepting the prior one. + expect(agent.locator('#submit')).to_be_enabled(timeout=45000) expect(agent.locator('#outcome')).to_have_text('ACQUISITION · RESPONSE-RECORDED', timeout=45000) result = json.loads(agent.locator('#result-json').text_content()) + assert result['records'][0]['operation_id'] == operation assert result['records'][0]['language'] == language snapshot = result['records'][0]['result']['native']['history']['snapshot'] assert snapshot['reserved_calls'] == 1 and snapshot['reserved_bytes'] == 1024 @@ -85,7 +92,10 @@ def managed_journey(owner, agent, before): native = native_review('managed-disclosure') assert owner.locator('#literal').text_content() == native['literal_review'] disclosure = json.loads(native['literal_review']) - assert disclosure['native']['protocol'] == 'disclosure' + assert disclosure['binding']['protocol']['kind'] == 'disclosure' + assert disclosure['native']['disclosure']['schema'] == 'auths.gateway-disclosure/1' + assert disclosure['native']['disclosure'] == disclosure['semantic']['disclosure'] + assert disclosure['native']['disclosure']['source_operation'] == 'managed-read-python' assert disclosure['binding']['operation'] == 'managed-disclosure' assert witness() == after_acquisitions and provider_counts() == counts assert recipient_files()['files'] == 0 diff --git a/demos/airtable-gateway/tests/test_provider_ledger.py b/demos/airtable-gateway/tests/test_provider_ledger.py new file mode 100644 index 000000000..8086582cb --- /dev/null +++ b/demos/airtable-gateway/tests/test_provider_ledger.py @@ -0,0 +1,27 @@ +"""Regression for actual hosted owner-journey counter initialization failure.""" +from pathlib import Path +import sys +import tempfile +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from double import Fixture + + +class ProviderLedger(unittest.TestCase): + def test_owned_counter_log_exists_before_any_provider_request(self): + with tempfile.TemporaryDirectory() as directory: + ledger = Path(directory) / 'provider.jsonl' + fixture = Fixture(ledger, 'public-fixture-control') + self.assertEqual(ledger.read_bytes(), b'') + self.assertEqual(ledger.stat().st_mode & 0o777, 0o600) + fixture.append({'kind': 'read', 'status': 200}) + retained = ledger.read_bytes() + self.assertTrue(retained.endswith(b'\n')) + with self.assertRaises(FileExistsError): + Fixture(ledger, 'public-fixture-control') + self.assertEqual(ledger.read_bytes(), retained, 'startup overwrote counter evidence') + + +if __name__ == '__main__': + unittest.main() From 87554f7496cf73937cbf866c5454c69d0a1d657b Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:22:11 +0000 Subject: [PATCH 101/136] test(gateway): prove native capacity races and retained reservations --- .github/workflows/postgres-lifecycle.yml | 4 + ...ative-disclosure-window-capacity-file.json | 131 +++ ...e-disclosure-window-capacity-postgres.json | 131 +++ .../native-mutation-window-capacity-file.json | 128 +++ ...ive-mutation-window-capacity-postgres.json | 128 +++ compliance.toml | 4 + ...017-bound-effect-and-recovery-ownership.md | 21 + docs/plans/0074-ci-repair-ab980d10.md | 57 ++ docs/plans/0074-implementation-status.md | 67 +- .../0009-bound-effect-and-recovery.md | 25 + .../auths-gateway/semantic-closure.json | 2 +- .../src/native_disclosure_budget_tests.rs | 828 ++++++++++++++++++ .../src/native_disclosure_crash_tests.rs | 3 + .../src/native_mutation_budget_tests.rs | 783 +++++++++++++++++ .../src/native_mutation_crash_tests.rs | 3 + .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 18 files changed, 2323 insertions(+), 16 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-window-capacity-file.json create mode 100644 bindings/fixtures/gateway/native-disclosure-window-capacity-postgres.json create mode 100644 bindings/fixtures/gateway/native-mutation-window-capacity-file.json create mode 100644 bindings/fixtures/gateway/native-mutation-window-capacity-postgres.json create mode 100644 docs/plans/0074-ci-repair-ab980d10.md create mode 100644 product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_budget_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 775ed97ef..23942fe3f 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -63,6 +63,10 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::native_file_mutation_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_native_mutation_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::window_capacity_tests::native_file_disclosure_window_capacity_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::window_capacity_tests::postgres_native_disclosure_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current diff --git a/bindings/fixtures/gateway/native-disclosure-window-capacity-file.json b/bindings/fixtures/gateway/native-disclosure-window-capacity-file.json new file mode 100644 index 000000000..719cf00a9 --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-window-capacity-file.json @@ -0,0 +1,131 @@ +{ + "schema": "auths.native-disclosure-window-capacity/1", + "adapter": "file", + "cases": [ + { + "limit": "count", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 0, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 2, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + }, + { + "limit": "byte-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 2, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 4, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 2, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 4, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + } + ], + "reserved_cases": [ + { + "limit": "count", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 1, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + }, + { + "limit": "byte-sum", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 2, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 2, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + } + ], + "scope": "actual native proofs/exact approvals; prefix and two independent OS contenders, each hosting gateway and recipient tasks over real same-UID Unix sockets; file/TLS PostgreSQL and one real HTTP acquisition; fixed public test keys and controlled maintained clock", + "excluded": [ + "hostile recipient/OS containment", + "independent gateway and recipient OS processes within each contender", + "new admission across windows", + "unsupported whole-store rollback", + "durability faults", + "live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-disclosure-window-capacity-postgres.json b/bindings/fixtures/gateway/native-disclosure-window-capacity-postgres.json new file mode 100644 index 000000000..d1edc49ef --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-window-capacity-postgres.json @@ -0,0 +1,131 @@ +{ + "schema": "auths.native-disclosure-window-capacity/1", + "adapter": "postgres", + "cases": [ + { + "limit": "count", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 0, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 2, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + }, + { + "limit": "byte-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 2, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 4, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "recorded_acks": 2, + "reserved_deliveries": 2, + "recipient_released_bytes": 42, + "reserved_bytes": 42, + "count_slots": 2, + "sum_slots": 2, + "source_provider_reads": 1, + "disclosure_performs_no_provider_io_or_credential_lease": true, + "reopen_replay_preserves_attempts_and_charges": true, + "reopen_replay_releases_no_bytes_or_acks": true, + "expired_window_slots_removed": 4, + "permanent_allocations_and_attempts_survive_cleanup": true, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_redeliver_or_charge": true + } + ], + "reserved_cases": [ + { + "limit": "count", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 1, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + }, + { + "limit": "byte-sum", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 2, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + }, + { + "limit": "count-and-byte-sum", + "window_seconds": 60, + "actual_native_reservation_ack": true, + "entry_grants": 0, + "recipient_released_bytes": 0, + "source_provider_reads": 1, + "expired_window_slots_removed": 2, + "lifetime_rows_retained": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_and_allocation_bytes_retained": true, + "reopen_cannot_redeliver_or_recharge": true + } + ], + "scope": "actual native proofs/exact approvals; prefix and two independent OS contenders, each hosting gateway and recipient tasks over real same-UID Unix sockets; file/TLS PostgreSQL and one real HTTP acquisition; fixed public test keys and controlled maintained clock", + "excluded": [ + "hostile recipient/OS containment", + "independent gateway and recipient OS processes within each contender", + "new admission across windows", + "unsupported whole-store rollback", + "durability faults", + "live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-window-capacity-file.json b/bindings/fixtures/gateway/native-mutation-window-capacity-file.json new file mode 100644 index 000000000..764336b4f --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-window-capacity-file.json @@ -0,0 +1,128 @@ +{ + "schema": "auths.native-mutation-window-capacity/1", + "adapter": "file", + "cases": [ + { + "limit": "count", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 0, + "amount_per_mutation": 500, + "policy_sum_amount": null, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 2, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + }, + { + "limit": "amount-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 2, + "amount_per_mutation": 500, + "policy_sum_amount": 1000, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 4, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + }, + { + "limit": "count-and-amount-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 2, + "amount_per_mutation": 500, + "policy_sum_amount": 1000, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 4, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + } + ], + "reserved_cases": [ + { + "limit": "count", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 1, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + }, + { + "limit": "amount-sum", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + }, + { + "limit": "count-and-amount-sum", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + } + ], + "scope": "maintained plain Stripe native mutation recipe, full proof/exact approval, prefix and two independent OS contenders with separate custody; real file/TLS PostgreSQL transactions and counting HTTP; public fixture keys and controlled maintained clock", + "excluded": [ + "guarded/prerequisite Stripe", + "disclosure contention", + "new admission across windows", + "unsupported whole-store rollback", + "durability faults", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-window-capacity-postgres.json b/bindings/fixtures/gateway/native-mutation-window-capacity-postgres.json new file mode 100644 index 000000000..10d977f44 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-window-capacity-postgres.json @@ -0,0 +1,128 @@ +{ + "schema": "auths.native-mutation-window-capacity/1", + "adapter": "postgres", + "cases": [ + { + "limit": "count", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 0, + "amount_per_mutation": 500, + "policy_sum_amount": null, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 2, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + }, + { + "limit": "amount-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.sum-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 2, + "amount_per_mutation": 500, + "policy_sum_amount": 1000, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 4, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + }, + { + "limit": "count-and-amount-sum", + "window_seconds": 60, + "prefix": 1, + "contenders": 2, + "independent_worker_processes": true, + "final_winners": 1, + "refusal_code": "gateway.policy.window-exhausted", + "durable_grants": 2, + "count_slots": 2, + "sum_slots": 2, + "amount_per_mutation": 500, + "policy_sum_amount": 1000, + "actual_http_writes": 2, + "no_implicit_reads": true, + "exact_admitted_bodies_once": true, + "reopen_replay_preserves_attempt_and_counter_bytes": true, + "reopen_replay_leases_and_sends_nothing": true, + "expired_window_slots_removed": 4, + "terminal_attempts_unchanged_after_sweep": 3, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "post_expiry_reopen_cannot_reenter_or_charge": true + } + ], + "reserved_cases": [ + { + "limit": "count", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 1, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + }, + { + "limit": "amount-sum", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + }, + { + "limit": "count-and-amount-sum", + "window_seconds": 60, + "actual_sigkill_after_reservation_ack": true, + "durable_reservations": 1, + "entry_grants": 0, + "actual_http_writes": 0, + "expired_window_slots_removed": 2, + "original_proof_and_approval_time_still_current": true, + "new_window_binding_requires_new_approval": true, + "reserved_attempt_bytes_retained": true, + "reopen_old_reserved_operation_cannot_enter_or_recharge": true + } + ], + "scope": "maintained plain Stripe native mutation recipe, full proof/exact approval, prefix and two independent OS contenders with separate custody; real file/TLS PostgreSQL transactions and counting HTTP; public fixture keys and controlled maintained clock", + "excluded": [ + "guarded/prerequisite Stripe", + "disclosure contention", + "new admission across windows", + "unsupported whole-store rollback", + "durability faults", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 92bb30594..d77676e96 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1821,6 +1821,10 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#postgres_native_independent_recovery_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#native_file_mutation_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#postgres_native_mutation_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs#native_file_disclosure_window_capacity_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs#postgres_native_disclosure_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_commit_tests.rs#postgres_native_commit_reply_loss_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index ec903e7c8..d43adf5a3 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1219,3 +1219,24 @@ mutation-refusal and real read-only install/acquisition/disclosure process journey. Google metadata, token refresh custody and AP070 owner migration are deferred integration work. Supporting a content-only recipe establishes neither those optional provider capabilities nor AP070 equivalence. + +## Native fixed-window contention and retained reservation evidence + +The existing native admission owner is exercised by independent OS contenders +for mutation count/amount-sum and disclosure count/byte-sum capacity on file and +TLS PostgreSQL. A prefix leaves exactly one unit; two separately approved native +operations contend and exactly one wins. The counting HTTP provider performs no +idempotent deduplication. Native recipient authentication and ACK retain typed +disclosure facts, with no provider refetch or credential lease at release. Each +disclosure contender hosts gateway/recipient tasks over same-UID Unix sockets; +this is independent admission-process evidence, not hostile-process containment. + +The short signed window expires while original proof and approval times remain +eligible. Native recompilation selects a new window-bound identity; old exact +approval cannot authorize it. Cleanup removes only old fixed-window slots and +keeps original attempt/allocation bytes. Terminal replay and reserved restart +create no new grant, send, recipient bytes or recorded charge. Mutation reserved +histories include SIGKILL after actual reservation acknowledgement. Disclosure +reservation-only admission returns data and no permit. These tests add no +production owner or new semantic abstraction. Source-specific adverse schedules, +rollback floors, installed containment and final hosted evidence remain required. diff --git a/docs/plans/0074-ci-repair-ab980d10.md b/docs/plans/0074-ci-repair-ab980d10.md new file mode 100644 index 000000000..bf6c913dc --- /dev/null +++ b/docs/plans/0074-ci-repair-ab980d10.md @@ -0,0 +1,57 @@ +# AP074 holistic CI repair — ab980d10 + +Published source: `ab980d1028927ef7bb08159ac489153d767993d5`, PR #213. +Child repair: `31f71657190af6f5ad8348cdaa6db4dbd2742328`, one coherent seven-file commit, not pushed by child. Main integrates separately. Main/AP073/AP070 source and shared metadata/index were not modified by this investigation. + +## Root matrix and repairs + +| Root | Actual evidence | Repair | +| --- | --- | --- | +| Fresh owner container lacks counting ledger before its first provider request | [Airtable installed job123776995604](https://github.com/auths-dev/auths-proof/actions/runs/40967090762/job/123776995604): owner_browser.py calls provider_counts(), strict docker cat fails because provider.jsonl does not exist | Create the owned fixture ledger exclusively at startup with mode0600; refuse an existing path, never truncate retained counts. Counter readers remain strict. Add a regression proving initial empty evidence, mode, append and restart refusal; invoke it in the package workflow. | +| Managed recipe declares UTF-8/text/plain but actual Airtable-shaped response is application/json | Full installed owner reproduction reaches Python acquisition and native history rejects it with gateway.content.response-media-type | Use the existing native json-string projection at /fields/PrivateNote; regenerate the native review and document the narrower projection. Keep native media-type rejection and all bounds. Recipient assertion requires exact sentinel bytes rather than interpreting the entire record as content. | +| Second acquisition has the same rendered outcome label as the first | Reproduction reaches both native acquisitions but reads the first rendered Python result before the TypeScript response completes | Wait for the submit control to re-enable; require exact current operation_id and language. Keep outcome, counters, withheld-content and full native literal-review assertions. | +| Disclosure review assertion expects a nonexistent native.protocol field | Reproduction reaches separately approved disclosure review and raises KeyError | Require actual binding.protocol.kind=disclosure, native versioned disclosure schema, exact source operation and native/semantic disclosure equality. Native renderer output remains byte-for-byte unchanged. | + +## Exact installed reproduction + +Original package artifact `12939290801`, run `40967090762`, has ZIP SHA-256 +`a2032da2971a0edcdcf118271b8a5eb6c9bb73cce45e068940583bbc8a6ad8e4`. +The ZIP, nested tar checksum, source_commit=ab980d10 and all41 manifest file hashes were verified before overlaying repairs. Package directory: +`/tmp/ap074-ci-ab980-airtable-package/airtable-gateway-demo`. + +The Docker reproduction uses that package's original Linux x86_64 shipping and simulation gateways, wheel, npm/WASM artifacts and compiled TypeScript client. Only repaired demo payloads and browser assertions are overlaid. Host browser is Playwright1.62.0 with its installed Chromium; test driver changes only owned container name/output paths beyond the committed assertion repairs. This is local patched-payload evidence, not hosted success for the new commit. + +Actual native review generation uses the original hosted shipping binary: + +```text +auths-gateway review --recipe managed-recipe.json --profile-lock profile.lock.json +``` + +New managed recipe digest: `88f9e64b3f82ff6d369a31082d9e2b00890b0d676bb1c0c8e3610e961b1769eb`. + +Results: + +- `python3 demos/airtable-gateway/tests/test_provider_ledger.py`:1passed. +- Source-free Docker `--selftest`:36cases passed, production_qualification=false. Log `/tmp/ap074-ci-ab980-selftest.log`. +- Standard installed desktop/mobile browser:passed, log `/tmp/ap074-ci-ab980-browser.log`. +- Full installed owner browser:passed, log `/tmp/ap074-ci-ab980-owner-browser-disclosure.log` and artifact `/tmp/ap074-ci-ab980-owner-evidence/owner-journey.json`. +- The owner artifact asserts native literal renderer equality, withheld approval before consent, decline/substitution refusals, private operator files, separate owner origin, installed Python and TypeScript acquisition, separate disclosure consent, retained native ACK, exact0600 recipient bytes, no public HTTP content, no replay redelivery/refetch, same agent actor, exact write, independent recovery, unknown response loss and fresh-process replay without new entry. +- Both owned browser containers were stopped and removed. The disposable selftest container was automatically removed. Parent and unrelated PostgreSQL containers were untouched. + +No native outcome, security deadline, media-type check, counter assertion, signature or consent requirement was weakened. No live-provider or human-attention qualification claim follows. No redundant broad local suites, secret scan, workflow reruns or cancellations were performed. + +## Current hosted evidence + +PG/source-contract jobs checked out PR merge `de85f0ffc03f6bc29244a2c69c8d74c071da453b`. Merge and published source have identical tree `3a4b23482a6a5fd7efc87692233405409fa44002`, fetched and compared. + +[PG123774214713](https://github.com/auths-dev/auths-proof/actions/runs/40967090703/job/123774214713) passed all26 explicit native selectors exactly once, each1passed/0failed/0ignored, including both new epoch cases. Then installed-SDK information comparison22pairs and physical/WAL restore passed; restore retains replay_continuity_claim=false. [Python source123774214528](https://github.com/auths-dev/auths-proof/actions/runs/40967090693/job/123774214528) passed native mutation generator plus28request/26response comparisons. + +Downloaded artifact ZIPs and checksums verified: + +- Information/native-log12938568979: `c1be7c1114d6bbe8ec39214d05f849aea981bfa97e0a97e45c6cd32197fc9f55`. +- Mutation12937534434: `0aeef604c259ff01e79c131ddbe7ceddd8bad7da4443e7575d8f624902c71781`. + +Per-selector evidence: `/tmp/ap074-ci-ab980-native-executions.json`. +Reports: `/tmp/ap074-ci-ab980-information-report.json`, `/tmp/ap074-ci-ab980-mutation-report.json`. + +At repair handoff the only observed hosted failure is the Airtable owner journey. Main authoritative implementation, Kani and authoritative Lean are still running; final qualification is not yet established. Continued holistic observation will produce a terminal cohort report. Parent owns metadata regeneration and coordinated publication. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 1c48d5600..372139da1 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3012,6 +3012,67 @@ closure remains the repaired epoch commitment; the formal translation source closure remains a002. These metadata updates do not execute the new browser/SDK cases and are not a fresh formal proof. +## Native mutation/disclosure capacity and retention continuation + +CI inspection, reproduction and repair belong to the existing CI subagent, per +user instruction. The main agent continues core implementation and required +artifact construction. The subagent's coherent installed-demo repair was +integrated as `25c93709` from `31f71657`, preserving the identical pending provider +ledger regression. It creates the owned counter log exclusively at startup, +uses the existing native JSON-string projection at `/fields/PrivateNote` for +an application/json response, and correlates browser completion/operation IDs +and the native versioned disclosure contract correctly. Native media checks, +all counter/consent/privacy assertions and the original reference recipe remain +unchanged. The private recipient receives the exact selected string, not a +reinterpretation of the complete provider JSON as text/plain. + +The subagent reports successful full source-free local reproduction against the +exact hosted ab980 SDK/native package plus the repaired payloads: 36 semantic +cases, ordinary browser and complete authenticated owner content/write/recovery/ +unknown journey. Package labels still identify the original hosted ab980 source; +this is repaired local execution, not a passed new-head hosted job. Precise +producer identity, artifact hashes, repairs and limitations are in +[the repair report](0074-ci-repair-ab980d10.md). New-head hosted confirmation +remains required; the main agent does not duplicate the subagent's CI checks. + +Four new native constructors execute 24 histories across file and TLS PostgreSQL: +three final-unit mutation races and three disclosure races per adapter, plus +three reserved-retention histories for each protocol/adapter. Each race admits +a prefix then starts two distinct OS contenders against shared durable state. +Exactly one contender wins the last count/amount-sum or delivery/byte-sum unit. +Native signed proofs and exact approvals are used, with actual HTTP mutation +capture and authenticated same-UID Unix recipient delivery/ACK. Counter records, +permanent lifetime rows and attempt bytes are inspected directly; replay after +reopen creates no custody/transport entry, recipient content or new recorded +charge. The disclosure contenders each host gateway and recipient tasks in one +OS process; this proves independent admission contention, not hostile-recipient +isolation or separate gateway/recipient processes within each contender. + +A 60-second window lets cleanup occur while original proofs and approval times +remain eligible. Full native recompilation remains authorized but produces a +new window-bound identity, and the old exact approval refuses it. Only expired +window slots disappear. Terminal and reserved attempts and permanent allocations +remain byte-identical; reopening cannot remint entry or re-charge old operations. +Mutation reservation cases use actual SIGKILL after durable reservation ACK; +disclosure cases use native reservation-only admission, which returns no permit. +No synthetic grant, alternative journal, callback or second decision owner is +introduced. Counts and byte/amount units remain distinct. + +Required local artifact construction passed each exact selector with one matched, +nonignored test: mutation file1.61s/PG3.34s and disclosure file2.83s/PG5.60s. +Each constructor contains three race and three reserved cases. The PostgreSQL +workflow preserves all previous 26 selected native cases and adds these four +for 30 explicit selectors. This is not new-head hosted execution or full A04/A21 +closure: dependency-change/entry races, remaining adverse durability schedules, +supported rollback floors, complete containment/binding negatives, generated +concurrent histories/formal linkage and bounded performance remain mandatory. + +Native source-closure construction and its rebuilt non-update verification both +passed after these Rust test changes. Semantic inventory construction advances +freeze414 and only reported identity158/public-SDK155/public-surface414; other +identity counters remain unchanged. Formal translation source closure remains +a002. These construction results are not new hosted/formal acceptance. + ## Phase gates | Phase | State | Outstanding gate | @@ -3033,7 +3094,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A01 | Same bound identity and exact request across review/approval/send | Partial / native review/compiler and real mutation replay corpus / ten file/TLS PostgreSQL histories send the exact reviewed PATCH body | Full installed review-completeness and authenticated human/UI evidence pending | | A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus and native retained-input controls / distinct valid proof/action, damaged approval, changed resource and changed recipient rejected during file/TLS PostgreSQL replay | Complete independent substitutions for every binding dimension and installed surface remain required | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / real native process lifetime and fixed-window acquisition histories on file/TLS PostgreSQL / lifetime count/bytes plus six fixed-window count/byte-sum contention histories executed | Mutation/disclosure fixed-window contention and complete adverse schedules still required | +| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | @@ -3050,8 +3111,8 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / independent mutation and post-authorization information comparisons against unchanged references / hosted74ce mutation 28 requests + 26 responses, information 22 pairs across both adapters and 104 source/parser controls passed | Named A19 contracts audited in the differential-contracts document; final-head confirmation remains required, with AP070 independence and divergent claims retained | | A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | -| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded maintenance/shared clock and one active epoch control per partition / hosted74ce six native read/release cleanup histories passed; two new file/TLS PostgreSQL epoch histories constructed locally preserve replay and lifetime slots | New-head hosted epoch verification, reserved/mutation retention, concurrent epoch/configuration schedules and supported rollback-floor evidence remain required | -| A22 | Installed single-human/single-agent full journey/UI | Partial / native daemon/CLI journey executed; installed authenticated write/recovery UI passed74ce; full same-actor Python/TypeScript acquisition/native disclosure/write/observation/unknown journey now authored | Execute the expanded source-free browser/package journey on the new head; complete hostile interface inventory and remaining adverse/negative integration evidence | +| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded maintenance/shared clock and stable epoch control; native terminal/reserved mutation/disclosure cleanup now constructed on both stores with original authority/approval times still current and unchanged permanent rows | New-head hosted confirmation, concurrent epoch/configuration schedules and supported rollback-floor evidence remain required | +| A22 | Installed single-human/single-agent full journey/UI | Partial / native CLI journey and hosted74ce write/recovery UI; CI subagent reports repaired source-free full Python/TypeScript acquisition/native disclosure/write/observation/unknown reproduction passed against original ab980 package plus repaired payloads | Exact new-head hosted confirmation, complete hostile interface inventory and remaining adverse/negative integration evidence | ## Deployment assumptions retained diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 277e333bb..9fae047f1 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -852,3 +852,28 @@ The development simulator retains a fixed actor key copy before app ownership changes, separately from exact reviewer keys; production/exclusive signing custody, human attention and hostile-OS claims remain excluded. The maintained AP070 reference and every remaining AP074 gate are unchanged. + +### Native mutation/disclosure capacity and retention histories + +New test-only vertical histories consume the existing approval, admission, +transaction, grant and sweep owners. They introduce no shipping capability or +semantic extraction. Plain Stripe mutation count/amount-sum and content-release +count/byte-sum each have count-only, sum-only and combined cases on file/TLS +PostgreSQL. A real prefix precedes two independent OS contenders. Raw records, +exact native mutation bodies, actual authenticated recipient content/ACK, and +provider/custody counters establish the corresponding unit conservation. + +Each protocol also has reserved-state expiry controls. Mutation kills the native +worker after durable reservation ACK; disclosure calls native reservation-only +admission. Original proof and approval times remain eligible after a short window +expires, but the new window changes the exact binding and requires fresh approval. +Only expired slots are removed; attempts and lifetime allocations remain intact. +Reopen/replay creates no grant, resend, redelivery or new recorded charge. These +are actual local constructor histories, not new-head hosted evidence, malicious +rollback detection or hostile-process containment. The disclosure contenders +each host gateway/recipient tasks in one process over real same-UID Unix sockets. + +The pending acceptance gates still include dependency-race/adverse schedules, +supported floors, complete public binding/containment negatives, generated +concurrent histories/formal links, bounded performance and final hosted results. +AP070 remains independently application-owned; AP073 is untouched. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 1309fcfa1..78a4d2d30 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76890f1835173adafebca6d02e8a22f367137abfc141ece97cdddc7f1ba47d55"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"823c284649dd3211bcc87ae8f80f6e8e5902c54f118414e3cc019dddc5a59ba5"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"eb0e488d5143daa92214cd47f3053a693f038aa2d4e0437f7dded4f1c77678ff"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"f52454a68d644f01277a471a8243f50e0a2ce9dde5fe06d8d549423d04416308"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76890f1835173adafebca6d02e8a22f367137abfc141ece97cdddc7f1ba47d55"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"eb0e488d5143daa92214cd47f3053a693f038aa2d4e0437f7dded4f1c77678ff"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"13a7294191d2f627f3a9c623805c23f30a5498b7acf7dd9a084a44127e2f7ea1"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs new file mode 100644 index 000000000..7aaad20be --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs @@ -0,0 +1,828 @@ +//! Disclosure count/byte contention through actual native grants and local +//! recipient authentication. Each OS contender owns a gateway and recipient task; +//! same-UID sockets establish no hostile-process containment claim. +use super::*; +use crate::effect::ExactEffectApproval; +use crate::harness::authoring::tool_fixture_in_window; +use crate::{ArgumentCeilingPolicy, GatewayExecutionWitness, LogicalOperationId}; +use std::{ + io::{Read as _, Write as _}, + net::TcpStream, + sync::Arc, + thread, + time::{Duration, Instant}, +}; + +const OPERATIONS: [&str; 3] = ["release-prefix", "release-left", "release-right"]; +const WORKER: &str = "AUTHS_AP074_DISCLOSURE_WINDOW_PEER"; +const WINDOW: u64 = 60; + +#[derive(Clone, Copy)] +enum Limit { + Count, + Bytes, + Both, +} +impl Limit { + const fn label(self) -> &'static str { + match self { + Self::Count => "count", + Self::Bytes => "byte-sum", + Self::Both => "count-and-byte-sum", + } + } + const fn sum(self) -> bool { + !matches!(self, Self::Count) + } + const fn refusal(self) -> &'static str { + if matches!(self, Self::Bytes) { + "gateway.policy.sum-exhausted" + } else { + "gateway.policy.window-exhausted" + } + } + fn policy(self) -> ArgumentCeilingPolicy { + let policy = ArgumentCeilingPolicy::new( + "maximum_disclosure_bytes", + CONTENT.len() as u64, + WINDOW, + if matches!(self, Self::Bytes) { 16 } else { 2 }, + ) + .expect("native count"); + if self.sum() { + policy + .with_sum(CONTENT.len() as u64 * 2, None) + .expect("native bytes") + } else { + policy + } + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerSetup { + installation: Setup, + operation: String, +} +#[derive(Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Delivery { + snapshot: DisclosureSnapshot, + recipient_bytes: u64, + recipient_ack_sent: bool, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + process: u32, + delivery: Delivery, + witness: GatewayExecutionWitness, +} + +fn channel(setup: &Setup) -> UnixDisclosurePolicy { + let uid = std::fs::metadata(&setup.root).expect("owner").uid(); + UnixDisclosurePolicy::new(uid, uid, [57; 32]) +} +async fn target(engine: &GatewayEngine, setup: &Setup, operation: &str) -> DisclosureTarget { + let index = OPERATIONS + .iter() + .position(|value| *value == operation) + .expect("closed operation"); + engine + .disclosure_target( + SOURCE, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + channel(setup).commitment().expect("channel"), + [u8::try_from(71 + index).expect("instance"); 32], + ) + .await + .expect("retained native source") +} +async fn inputs( + engine: &GatewayEngine, + setup: &Setup, + operation: &'static str, + limit: Limit, +) -> Charges { + let target = target(engine, setup, operation).await; + let call = target + .authorization_call( + &crate::native_process_tests::recipe(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("native release call"); + let signed = tool_fixture_in_window(&call, NOW, NOW - 10, NOW + 3600, Some(&limit.policy())) + .expect("bounded native proof"); + let effect = engine + .compile_disclosure_effect(&target, &signed.proof, &signed.action) + .await + .expect("native effect"); + let request = effect + .approval_request(NOW, NOW + 300) + .expect("exact review"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + for (suffix, bytes) in [ + ("proof", signed.proof), + ("action", signed.action), + ( + "approval", + request + .with_signature(signature) + .to_private_bytes() + .expect("approval") + .to_vec(), + ), + ( + "binding", + effect + .binding() + .to_private_bytes() + .expect("binding") + .to_vec(), + ), + ] { + private(&setup.root.join(format!("{operation}.{suffix}")), &bytes); + } + let charges = Charges::native( + effect.binding(), + operation, + "disclosure-count", + "disclosure-bytes", + CONTENT.len() as u64, + ); + assert_eq!(charges.fixed.len(), 1 + usize::from(limit.sum())); + charges +} + +async fn deliver(engine: &GatewayEngine, setup: &Setup, operation: &str) -> Delivery { + let target = target(engine, setup, operation).await; + let load = |suffix: &str| { + std::fs::read(setup.root.join(format!("{operation}.{suffix}"))).expect("native input") + }; + let binding = EffectBinding::from_private_bytes(&load("binding")).expect("expected binding"); + let approval = + ExactEffectApproval::from_private_bytes(&load("approval")).expect("exact approval"); + let policy = channel(setup); + let recipient = SigningKey::from_bytes(&[47; 32]); + let (server, client) = UnixStream::pair().expect("actual local channel"); + let receiver = async { + match crate::disclosure_transport::receive_disclosure( + DisclosureConnection::new(client, policy.clone()), + &binding, + CONTENT.len() as u64, + &recipient, + ) + .await + { + Ok(received) => { + assert_eq!(received.content(), CONTENT); + let bytes = received.content().len() as u64; + received + .acknowledge(&recipient) + .await + .expect("native exact ACK"); + (bytes, true) + } + Err(code) => { + // Capacity refusal and retained replay close without a delivery. + // Authentication/frame failures are never accepted as quota loss. + assert_eq!(code, "gateway.disclosure.read"); + (0, false) + } + } + }; + let proof = load("proof"); + let action = load("action"); + let (result, (recipient_bytes, recipient_ack_sent)) = tokio::join!( + engine.disclose( + &target, + &proof, + &action, + approval, + DisclosureConnection::new(server, policy.clone()) + ), + receiver + ); + Delivery { + snapshot: result.expect("native retained disclosure facts"), + recipient_bytes, + recipient_ack_sent, + } +} + +#[test] +fn native_disclosure_window_peer() { + let Some(input) = std::env::var_os(WORKER) else { + return; + }; + let setup: WorkerSetup = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("typed setup"); + assert!(OPERATIONS.contains(&setup.operation.as_str())); + let store = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + &setup.operation, + store.attempts().clone(), + controls(Gate::Current), + )); + let mut signal = + TcpStream::connect(("127.0.0.1", setup.installation.barrier_port)).expect("barrier"); + signal + .set_read_timeout(Some(Duration::from_secs(15))) + .expect("deadline"); + signal.write_all(b"R").expect("ready"); + let mut start = [0]; + signal.read_exact(&mut start).expect("release"); + assert_eq!(start, *b"G"); + let result = WorkerResult { + process: std::process::id(), + delivery: runtime.block_on(deliver(&engine, &setup.installation, &setup.operation)), + witness: engine.execution_witness(), + }; + private( + &setup + .installation + .root + .join(format!("{}.result", setup.operation)), + &serde_json::to_vec(&result).expect("result"), + ); +} + +fn release(barrier: &TcpListener) { + let mut signals = Vec::new(); + let deadline = Instant::now() + Duration::from_secs(20); + while signals.len() < 2 { + match barrier.accept() { + Ok((mut stream, _)) => { + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut ready = [0]; + stream.read_exact(&mut ready).expect("ready"); + assert_eq!(ready, *b"R"); + signals.push(stream); + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "native worker timeout"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("barrier: {error}"), + } + } + for mut stream in signals { + stream.write_all(b"G").expect("release"); + } +} +fn contend(setup: &Setup, barrier: &TcpListener) -> Vec { + let mut peers = Vec::new(); + for operation in &OPERATIONS[1..] { + let input = setup.root.join(format!("{operation}.setup")); + private( + &input, + &serde_json::to_vec(&json!({"installation":setup,"operation":operation})) + .expect("setup"), + ); + peers.push(Peer::start( + &input, + "native_disclosure_crash_tests::window_capacity_tests::native_disclosure_window_peer", + WORKER, + )); + } + release(barrier); + for peer in &mut peers { + peer.finish(); + } + let results = OPERATIONS[1..] + .iter() + .map(|operation| { + serde_json::from_slice( + &std::fs::read(setup.root.join(format!("{operation}.result"))).expect("result"), + ) + .expect("worker result") + }) + .collect::>(); + assert_ne!(results[0].process, results[1].process); + assert!( + results + .iter() + .all(|result| result.process != std::process::id()) + ); + for result in &results { + assert_eq!(result.witness.credential_lease_calls, 0); + assert_eq!(result.witness.write_transport_entries, 0); + assert_eq!(result.witness.read_transport_entries, 0); + } + results +} + +type Retained = Vec<(GatewayRecordKind, GatewayAttemptKey, Vec)>; +fn retained(store: &TestAttempts, source: &Charges, releases: &Charges, limit: Limit) -> Retained { + let raw = store.raw(); + let keys = raw.attempt_keys(8).expect("keys"); + assert_eq!(keys.len(), 4, "one source plus three release attempts"); + let mut retained = Vec::new(); + let mut acknowledged = 0; + let mut refused = 0; + for key in keys { + let bytes = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("attempt"); + let record: Value = serde_json::from_slice(&bytes).expect("record"); + if record["operation_id"] != SOURCE { + assert_eq!(record["state"]["protocol"], "disclosure"); + let facts = &record["state"]["facts"]; + if record["entry"].is_null() { + assert_eq!(facts["phase"]["stage"], "not-entered"); + assert_eq!(facts["phase"]["code"], limit.refusal()); + assert!(facts["allocation"].is_null()); + assert!(facts["counters"].as_array().expect("counters").is_empty()); + refused += 1; + } else { + assert_eq!(facts["phase"]["stage"], "acknowledged"); + assert_eq!( + facts["counters"].as_array().expect("counters").len(), + releases.fixed.len() + ); + acknowledged += 1; + } + } + retained.push((GatewayRecordKind::Attempt, key, bytes)); + } + assert_eq!((acknowledged, refused), (2, 1)); + retained.extend(charge_rows(store, source, releases, 2)); + retained +} + +fn charge_rows( + store: &TestAttempts, + source: &Charges, + releases: &Charges, + deliveries: u64, +) -> Retained { + let raw = store.raw(); + let mut retained = Vec::new(); + let mut rows = vec![(GatewayRecordKind::EffectAllocation, source.lifetime, 1)]; + rows.push(( + GatewayRecordKind::EffectAllocation, + releases.lifetime, + deliveries, + )); + rows.extend( + releases + .fixed + .iter() + .map(|(kind, key)| (*kind, *key, deliveries)), + ); + for (kind, digest, count) in rows { + let derive = if kind == GatewayRecordKind::SumSlot { + crate::bounds::sum_slot_key + } else { + crate::bounds::count_slot_key + }; + for slot in 0..count { + let key = GatewayAttemptKey::from_bytes(derive(&digest, slot)); + let bytes = raw.load(kind, &key).expect("charge").expect("present"); + let value: Value = serde_json::from_slice(&bytes).expect("charge"); + assert_eq!(value["slot"], slot); + if kind == GatewayRecordKind::EffectAllocation { + assert_eq!(value["calls"], 1); + assert_eq!( + value["bytes"], + if digest == source.lifetime { + 1024 + } else { + CONTENT.len() as u64 + } + ); + } else { + assert_eq!(value["window_seconds"], WINDOW); + assert_eq!(value["window_index"], NOW / WINDOW); + assert!(OPERATIONS.contains(&value["operation_id"].as_str().expect("operation"))); + if kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], CONTENT.len() as u64); + assert_eq!(value["cumulative"], (slot + 1) * CONTENT.len() as u64); + } + } + retained.push((kind, key, bytes)); + } + assert!( + raw.load(kind, &GatewayAttemptKey::from_bytes(derive(&digest, count))) + .expect("no overflow") + .is_none() + ); + } + retained +} + +struct DisclosureRace { + _directory: tempfile::TempDir, + setup: Setup, + store: TestAttempts, + provider: Provider, + barrier: TcpListener, + runtime: tokio::runtime::Runtime, + engine: GatewayEngine, + clock: Arc, + source: Charges, +} +impl DisclosureRace { + fn new(backend: Backend) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::controlled(None); + let barrier = TcpListener::bind("127.0.0.1:0").expect("barrier"); + barrier.set_nonblocking(true).expect("poll"); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: barrier.local_addr().expect("port").port(), + }; + let runtime = runtime(); + let controls = controls(Gate::Current); + let clock = controls.clock.clone(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "release-window-parent", + store.attempts().clone(), + controls, + )); + runtime + .block_on( + SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ) + .insert(&connection), + ) + .expect("connection"); + engine.initialize_effect_configuration().expect("control"); + let binding = runtime.block_on(kit::authorize_source(&engine)); + let source = Charges::native( + &binding, + SOURCE, + "acquisition-count", + "response-bytes", + 1024, + ); + assert_eq!(provider.calls.load(Ordering::SeqCst), 1); + Self { + _directory: directory, + setup, + store, + provider, + barrier, + runtime, + engine, + clock, + source, + } + } + fn replay(&self, results: &[Delivery], retained: &Retained, now: u64) { + let controls = controls(Gate::Current); + controls.clock.set(now); + let (engine, _) = self.runtime.block_on(load_controlled_engine( + &self.setup, + &format!("release-reopened-{now}"), + self.store.reopen(), + controls, + )); + let witness = engine.execution_witness(); + for (operation, expected) in OPERATIONS.iter().zip(results) { + let actual = self + .runtime + .block_on(deliver(&engine, &self.setup, operation)); + assert_eq!(actual.snapshot, expected.snapshot); + assert_eq!( + (actual.recipient_bytes, actual.recipient_ack_sent), + (0, false) + ); + } + assert_eq!(engine.execution_witness(), witness); + assert_eq!(self.provider.calls.load(Ordering::SeqCst), 1); + for (kind, key, bytes) in retained { + assert_eq!( + self.store + .raw() + .load(*kind, key) + .expect("retained") + .as_ref(), + Some(bytes) + ); + } + } + fn assert_current_authority_and_new_window(&self, operations: &[&str], expiry: u64) { + for operation in operations { + let load = |suffix: &str| { + std::fs::read(self.setup.root.join(format!("{operation}.{suffix}"))) + .expect("original input") + }; + let binding = EffectBinding::from_private_bytes(&load("binding")).expect("binding"); + let approval = + ExactEffectApproval::from_private_bytes(&load("approval")).expect("approval"); + binding + .validate_recorded_approval(&approval, expiry) + .expect("original approval remains time eligible"); + let target = self + .runtime + .block_on(target(&self.engine, &self.setup, operation)); + let fresh = self + .runtime + .block_on(self.engine.compile_disclosure_effect( + &target, + &load("proof"), + &load("action"), + )) + .expect("original native proof still authorized"); + assert_ne!( + fresh.binding().id(), + binding.id(), + "window index is part of exact approval" + ); + assert!( + fresh + .approve( + approval, + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + expiry + ) + .is_err() + ); + } + } + fn expiry_cleanup(&self, results: &[Delivery], retained: &Retained, limit: Limit) { + let expiry = (NOW / WINDOW + 2) * WINDOW; + let witness = self.engine.execution_witness(); + self.clock.set(expiry - 1); + assert_eq!( + self.runtime.block_on(self.engine.sweep_expired_slots()), + Ok(0) + ); + self.clock.set(expiry); + assert!(expiry < NOW + 300); + self.assert_current_authority_and_new_window(&OPERATIONS, expiry); + assert_eq!( + self.runtime.block_on(self.engine.sweep_expired_slots()), + Ok(2 + 2 * usize::from(limit.sum())) + ); + let mut permanent = Vec::new(); + for (kind, key, bytes) in retained { + let actual = self.store.raw().load(*kind, key).expect("after cleanup"); + if matches!( + kind, + GatewayRecordKind::CountSlot | GatewayRecordKind::SumSlot + ) { + assert!(actual.is_none()); + } else { + assert_eq!(actual.as_ref(), Some(bytes)); + permanent.push((*kind, *key, bytes.clone())); + } + } + assert_eq!(self.engine.execution_witness(), witness); + self.replay(results, &permanent, expiry); + } +} + +fn one_case(backend: Backend, limit: Limit) -> Value { + let case = DisclosureRace::new(backend); + let mut charges: Option = None; + for operation in OPERATIONS { + let next = case + .runtime + .block_on(inputs(&case.engine, &case.setup, operation, limit)); + if let Some(previous) = &charges { + assert_eq!(previous.lifetime, next.lifetime); + assert_eq!(previous.fixed, next.fixed); + } + charges = Some(next); + } + let charges = charges.expect("native charges"); + let prefix = case + .runtime + .block_on(deliver(&case.engine, &case.setup, OPERATIONS[0])); + assert_eq!(prefix.snapshot.stage, DisclosureStage::Acknowledged); + assert_eq!(prefix.recipient_bytes, CONTENT.len() as u64); + let contenders = contend(&case.setup, &case.barrier); + assert_eq!( + contenders + .iter() + .filter(|result| result.delivery.snapshot.stage == DisclosureStage::Acknowledged) + .count(), + 1 + ); + assert_eq!( + contenders + .iter() + .filter(|result| result.delivery.snapshot.stage == DisclosureStage::NotEntered) + .count(), + 1 + ); + let mut results = vec![prefix]; + results.extend(contenders.into_iter().map(|result| result.delivery)); + assert_eq!( + results + .iter() + .map(|result| result.recipient_bytes) + .sum::(), + CONTENT.len() as u64 * 2 + ); + assert_eq!( + results + .iter() + .filter(|result| result.recipient_ack_sent) + .count(), + 2 + ); + assert_eq!( + results + .iter() + .map(|result| result.snapshot.reserved_deliveries) + .sum::(), + 2 + ); + assert_eq!( + results + .iter() + .map(|result| result.snapshot.reserved_bytes) + .sum::(), + CONTENT.len() as u64 * 2 + ); + let retained = retained(&case.store, &case.source, &charges, limit); + case.replay(&results, &retained, NOW); + case.expiry_cleanup(&results, &retained, limit); + json!({"limit":limit.label(),"window_seconds":WINDOW,"prefix":1,"contenders":2,"independent_worker_processes":true, + "final_winners":1,"refusal_code":limit.refusal(),"recorded_acks":2,"reserved_deliveries":2, + "recipient_released_bytes":CONTENT.len()*2,"reserved_bytes":CONTENT.len()*2, + "count_slots":2,"sum_slots":if limit.sum(){2}else{0},"source_provider_reads":1, + "disclosure_performs_no_provider_io_or_credential_lease":true, + "reopen_replay_preserves_attempts_and_charges":true,"reopen_replay_releases_no_bytes_or_acks":true, + "expired_window_slots_removed":2+2*usize::from(limit.sum()), + "permanent_allocations_and_attempts_survive_cleanup":true, + "original_proof_and_approval_time_still_current":true,"new_window_binding_requires_new_approval":true,"post_expiry_reopen_cannot_redeliver_or_charge":true}) +} +fn reserved_rows(case: &DisclosureRace, releases: &Charges) -> Retained { + let raw = case.store.raw(); + let keys = raw.attempt_keys(4).expect("keys"); + assert_eq!(keys.len(), 2); + let mut rows = Vec::new(); + for key in keys { + let bytes = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"); + let record: Value = serde_json::from_slice(&bytes).expect("record"); + if record["operation_id"] != SOURCE { + assert_eq!(record["operation_id"], OPERATIONS[0]); + assert!(record["entry"].is_null()); + assert_eq!(record["state"]["facts"]["phase"]["stage"], "reserved"); + assert_eq!(record["state"]["facts"]["allocation"], 0); + assert_eq!( + record["state"]["facts"]["counters"] + .as_array() + .expect("counters") + .len(), + releases.fixed.len() + ); + } + rows.push((GatewayRecordKind::Attempt, key, bytes)); + } + rows.extend(charge_rows(&case.store, &case.source, releases, 1)); + rows +} + +fn reserved_case(backend: Backend, limit: Limit) -> Value { + let case = DisclosureRace::new(backend); + let operation = OPERATIONS[0]; + let charges = case + .runtime + .block_on(inputs(&case.engine, &case.setup, operation, limit)); + let target = case + .runtime + .block_on(target(&case.engine, &case.setup, operation)); + let load = |suffix: &str| { + std::fs::read(case.setup.root.join(format!("{operation}.{suffix}"))).expect("native input") + }; + let witness = case.engine.execution_witness(); + let snapshot = case + .runtime + .block_on(case.engine.admit_disclosure( + &target, + &load("proof"), + &load("action"), + ExactEffectApproval::from_private_bytes(&load("approval")).expect("approval"), + )) + .expect("native admission ACK"); + assert_eq!(snapshot.stage, DisclosureStage::Reserved); + assert_eq!( + (snapshot.reserved_deliveries, snapshot.reserved_bytes), + (1, CONTENT.len() as u64) + ); + assert_eq!(case.engine.execution_witness(), witness); + let retained = reserved_rows(&case, &charges); + let permanent = retained + .iter() + .filter(|(kind, _, _)| { + !matches!( + kind, + GatewayRecordKind::CountSlot | GatewayRecordKind::SumSlot + ) + }) + .cloned() + .collect(); + let expiry = (NOW / WINDOW + 2) * WINDOW; + case.clock.set(expiry - 1); + assert_eq!( + case.runtime.block_on(case.engine.sweep_expired_slots()), + Ok(0) + ); + for (kind, key, bytes) in &retained { + assert_eq!( + case.store + .raw() + .load(*kind, key) + .expect("before expiry") + .as_ref(), + Some(bytes) + ); + } + case.clock.set(expiry); + assert!(expiry < NOW + 300); + case.assert_current_authority_and_new_window(&[operation], expiry); + assert_eq!( + case.runtime.block_on(case.engine.sweep_expired_slots()), + Ok(charges.fixed.len()) + ); + for (kind, digest) in &charges.fixed { + let key = GatewayAttemptKey::from_bytes(if *kind == GatewayRecordKind::CountSlot { + crate::bounds::count_slot_key(digest, 0) + } else { + crate::bounds::sum_slot_key(digest, 0) + }); + assert!( + case.store + .raw() + .load(*kind, &key) + .expect("expired") + .is_none() + ); + } + assert_eq!(case.engine.execution_witness(), witness); + case.replay( + &[Delivery { + snapshot, + recipient_bytes: 0, + recipient_ack_sent: false, + }], + &permanent, + expiry, + ); + json!({"limit":limit.label(),"window_seconds":WINDOW,"actual_native_reservation_ack":true, + "entry_grants":0,"recipient_released_bytes":0,"source_provider_reads":1, + "expired_window_slots_removed":charges.fixed.len(),"lifetime_rows_retained":2, + "original_proof_and_approval_time_still_current":true,"new_window_binding_requires_new_approval":true, + "reserved_attempt_and_allocation_bytes_retained":true,"reopen_cannot_redeliver_or_recharge":true}) +} + +fn matrix(backend: Backend) { + let cases = [Limit::Count, Limit::Bytes, Limit::Both] + .into_iter() + .map(|limit| one_case(backend, limit)) + .collect::>(); + let reserved_cases = [Limit::Count, Limit::Bytes, Limit::Both] + .into_iter() + .map(|limit| reserved_case(backend, limit)) + .collect::>(); + let bytes = serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-window-capacity/1","adapter":backend.label(),"cases":cases,"reserved_cases":reserved_cases, + "scope":"actual native proofs/exact approvals; prefix and two independent OS contenders, each hosting gateway and recipient tasks over real same-UID Unix sockets; file/TLS PostgreSQL and one real HTTP acquisition; fixed public test keys and controlled maintained clock", + "excluded":["hostile recipient/OS containment", "independent gateway and recipient OS processes within each contender", "new admission across windows", "unsupported whole-store rollback", "durability faults", "live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-disclosure-window-capacity-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} +#[test] +fn native_file_disclosure_window_capacity_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_disclosure_window_capacity_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs index 2e75ed5ea..18c33a8b1 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs @@ -34,6 +34,9 @@ use tokio::{ mod kit; use kit::{CrashSetup, Input, Recipient, Role, controls, key}; +#[path = "native_disclosure_budget_tests.rs"] +mod window_capacity_tests; + const SOURCE: &str = "crash-release-source"; const RELEASE: &str = "crash-release"; diff --git a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs new file mode 100644 index 000000000..22ebf49ea --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs @@ -0,0 +1,783 @@ +//! Native final-unit mutation contention. One prefix and two independent OS +//! workers share actual file/TLS PostgreSQL state and a counting HTTP provider. +use super::*; +use crate::GatewayExecutionWitness; +use std::{collections::BTreeMap, net::TcpStream, time::Instant}; + +const OPERATIONS: [&str; 3] = ["mutation-prefix", "mutation-left", "mutation-right"]; +const WORKER: &str = "AUTHS_AP074_MUTATION_WINDOW_PEER"; +const WINDOW: u64 = 60; +const AMOUNT: u64 = 500; + +#[derive(Clone, Copy)] +enum Limit { + Count, + Sum, + Both, +} +impl Limit { + const fn label(self) -> &'static str { + match self { + Self::Count => "count", + Self::Sum => "amount-sum", + Self::Both => "count-and-amount-sum", + } + } + const fn sum(self) -> bool { + !matches!(self, Self::Count) + } + const fn refusal(self) -> &'static str { + if matches!(self, Self::Sum) { + "gateway.policy.sum-exhausted" + } else { + "gateway.policy.window-exhausted" + } + } + fn policy(self) -> ArgumentCeilingPolicy { + let policy = ArgumentCeilingPolicy::new( + "amount", + AMOUNT, + WINDOW, + if matches!(self, Self::Sum) { 16 } else { 2 }, + ) + .expect("native count policy"); + if self.sum() { + policy + .with_sum(2 * AMOUNT, None) + .expect("native amount sum") + } else { + policy + } + } +} + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum WorkerMode { + Contend, + CrashAfterReservation, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerSetup { + installation: Setup, + operation: String, + mode: WorkerMode, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + process: u32, + result: GatewaySubmitResult, + witness: GatewayExecutionWitness, +} + +async fn inputs( + engine: &GatewayEngine, + root: &Path, + operation: &str, + limit: Limit, +) -> Vec { + let base = Flavor::StripePlain.call(); + let mut arguments = base.arguments().clone(); + arguments.insert("operation_id".to_owned(), json!(operation)); + arguments.insert( + "payment_intent".to_owned(), + json!(format!("pi_{}", operation.replace('-', "_"))), + ); + let call = McpToolCall::new(base.service(), base.name(), arguments).expect("native call"); + let signed = tool_fixture_in_window(&call, NOW, NOW - 10, NOW + 3600, Some(&limit.policy())) + .expect("native bounded grant and proof"); + let effect = engine + .compile_effect(&signed.proof, &signed.action) + .await + .expect("native effect"); + let binding: Value = + serde_json::from_slice(&effect.binding().to_private_bytes().expect("binding")) + .expect("binding JSON"); + let counters = binding["reservations"] + .as_array() + .expect("reservations") + .iter() + .map(|wire| { + let kind = match wire["unit"].as_str().expect("unit") { + "mutation-count" => GatewayRecordKind::CountSlot, + "mutation-sum" => GatewayRecordKind::SumSlot, + _ => panic!("wrong protocol unit"), + }; + Counter { + kind, + digest: serde_json::from_value(wire["key"].clone()).expect("counter key"), + } + }) + .collect::>(); + assert_eq!(counters.len(), 1 + usize::from(limit.sum())); + let request = effect + .approval_request(NOW, NOW + 300) + .expect("exact request"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + for (suffix, bytes) in [ + ("proof", signed.proof), + ("action", signed.action), + ( + "binding", + effect + .binding() + .to_private_bytes() + .expect("binding") + .to_vec(), + ), + ( + "approval", + request + .with_signature(signature) + .to_private_bytes() + .expect("approval") + .to_vec(), + ), + ] { + private(&root.join(format!("{operation}.{suffix}")), &bytes); + } + private( + &root.join(format!("{operation}.body")), + effect.private_request().expect("mutation").body(), + ); + counters +} + +async fn execute(engine: &GatewayEngine, root: &Path, operation: &str) -> GatewaySubmitResult { + let load = + |suffix: &str| std::fs::read(root.join(format!("{operation}.{suffix}"))).expect("input"); + engine + .submit( + &load("proof"), + &load("action"), + ExactEffectApproval::from_private_bytes(&load("approval")).expect("native approval"), + ) + .await +} + +#[test] +fn native_mutation_window_peer() { + let Some(input) = std::env::var_os(WORKER) else { + return; + }; + let setup: WorkerSetup = + serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("typed setup"); + assert!(OPERATIONS.contains(&setup.operation.as_str())); + let store = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let operation = OPERATIONS + .into_iter() + .find(|value| *value == setup.operation) + .expect("closed operation"); + let attempts = match setup.mode { + WorkerMode::Contend => store.attempts().clone(), + WorkerMode::CrashAfterReservation => { + let policy = crate::effect::fixture_policy().expect("policy"); + let key = GatewayAttemptKey::for_operation( + &policy, + Flavor::StripePlain.recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key"); + GatewayAttempts::new( + Arc::new(PausedStore::new( + store.raw(), + key, + operation, + CrashProtocol::Mutation, + Some(Point::AfterReservationCommit), + setup.installation.barrier_port, + )), + policy, + ) + .expect("paused owner") + } + }; + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + &setup.operation, + attempts, + Flavor::StripePlain.controls(), + )); + if matches!(setup.mode, WorkerMode::Contend) { + let mut signal = + TcpStream::connect(("127.0.0.1", setup.installation.barrier_port)).expect("barrier"); + signal + .set_read_timeout(Some(Duration::from_secs(15))) + .expect("deadline"); + signal.write_all(b"R").expect("ready"); + let mut start = [0]; + signal.read_exact(&mut start).expect("release"); + assert_eq!(start, *b"G"); + } + let result = WorkerResult { + process: std::process::id(), + result: runtime.block_on(execute(&engine, &setup.installation.root, &setup.operation)), + witness: engine.execution_witness(), + }; + private( + &setup + .installation + .root + .join(format!("{}.result", setup.operation)), + &serde_json::to_vec(&result).expect("result"), + ); +} + +fn release(barrier: &TcpListener) { + let deadline = Instant::now() + Duration::from_secs(20); + let mut signals = Vec::new(); + while signals.len() < 2 { + match barrier.accept() { + Ok((mut stream, _)) => { + stream.set_nonblocking(false).expect("blocking"); + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .expect("deadline"); + let mut ready = [0]; + stream.read_exact(&mut ready).expect("ready"); + assert_eq!(ready, *b"R"); + signals.push(stream); + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "native worker readiness timeout"); + thread::sleep(Duration::from_millis(2)); + } + Err(error) => panic!("barrier: {error}"), + } + } + for mut signal in signals { + signal.write_all(b"G").expect("release"); + } +} + +fn contend(setup: &Setup, barrier: &TcpListener) -> Vec { + let mut peers = Vec::new(); + for operation in &OPERATIONS[1..] { + let input = setup.root.join(format!("{operation}.setup")); + // Test setup is closed and separate from every production protocol. + let worker: WorkerSetup = serde_json::from_value( + json!({"installation":setup,"operation":operation,"mode":"contend"}), + ) + .expect("setup"); + private(&input, &serde_json::to_vec(&worker).expect("setup")); + peers.push(Peer::start( + &input, + "native_mutation_crash_tests::window_capacity_tests::native_mutation_window_peer", + WORKER, + )); + } + release(barrier); + for peer in &mut peers { + peer.finish(); + } + let results = OPERATIONS[1..] + .iter() + .map(|operation| { + serde_json::from_slice( + &std::fs::read(setup.root.join(format!("{operation}.result"))).expect("result"), + ) + .expect("worker result") + }) + .collect::>(); + assert_ne!(results[0].process, results[1].process); + assert!( + results + .iter() + .all(|result| result.process != std::process::id()) + ); + assert_eq!( + results + .iter() + .map(|result| result.witness.write_transport_entries) + .sum::(), + 1 + ); + assert_eq!( + results + .iter() + .map(|result| result.witness.credential_lease_calls) + .sum::(), + 1 + ); + results +} + +type Retained = Vec<(GatewayRecordKind, GatewayAttemptKey, Vec)>; +fn retained(store: &TestAttempts, counters: &[Counter], limit: Limit) -> Retained { + let raw = store.raw(); + let keys = raw.attempt_keys(8).expect("keys"); + assert_eq!(keys.len(), 3); + let mut retained = Vec::new(); + let mut grants = 0; + for key in keys { + let bytes = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"); + let record: Value = serde_json::from_slice(&bytes).expect("record"); + let facts = &record["state"]["facts"]; + assert_eq!(record["state"]["protocol"], "mutation"); + if record["entry"].is_null() { + assert_eq!(facts["stage"], "not-entered"); + assert_eq!(facts["refusal"], limit.refusal()); + assert!(facts["counters"].is_null(), "refusal owns no slot"); + } else { + grants += 1; + assert_eq!(facts["stage"], "response-recorded"); + assert_eq!( + facts["counters"].as_array().expect("counters").len(), + counters.len() + ); + } + retained.push((GatewayRecordKind::Attempt, key, bytes)); + } + assert_eq!(grants, 2); + for counter in counters { + for slot in 0..2 { + let key = counter.key(slot); + let bytes = raw + .load(counter.kind, &key) + .expect("slot") + .expect("present"); + let value: Value = serde_json::from_slice(&bytes).expect("slot"); + assert_eq!(value["window_seconds"], WINDOW); + assert_eq!(value["window_index"], NOW / WINDOW); + assert_eq!(value["window_end"], (NOW / WINDOW + 1) * WINDOW); + assert_eq!(value["slot"], slot); + assert!(OPERATIONS.contains(&value["operation_id"].as_str().expect("operation"))); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], AMOUNT); + assert_eq!(value["cumulative"], (slot + 1) * AMOUNT); + } + retained.push((counter.kind, key, bytes)); + } + assert!( + raw.load(counter.kind, &counter.key(2)) + .expect("no overflow") + .is_none() + ); + } + retained +} + +fn replay( + setup: &Setup, + store: &TestAttempts, + provider: &Provider, + results: &[GatewaySubmitResult], + retained: &Retained, + now: u64, + expected_calls: usize, +) { + let runtime = runtime(); + let controls = Flavor::StripePlain.controls(); + controls.clock.set(now); + let (engine, _) = runtime.block_on(load_controlled_engine( + setup, + &format!("reopened-window-{now}"), + store.reopen(), + controls, + )); + let witness = engine.execution_witness(); + for (operation, expected) in OPERATIONS.iter().zip(results) { + assert_eq!( + &runtime.block_on(execute(&engine, &setup.root, operation)), + expected + ); + } + assert_eq!(engine.execution_witness(), witness); + assert_eq!(provider.calls(), expected_calls); + for (kind, key, expected) in retained { + assert_eq!( + store.raw().load(*kind, key).expect("retained").as_ref(), + Some(expected) + ); + } +} + +struct MutationRace { + _directory: tempfile::TempDir, + store: TestAttempts, + provider: Provider, + barrier: TcpListener, + setup: Setup, + runtime: tokio::runtime::Runtime, + engine: GatewayEngine, + clock: Arc, +} +impl MutationRace { + fn new(backend: Backend) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::new(Flavor::StripePlain, None); + let barrier = TcpListener::bind("127.0.0.1:0").expect("barrier"); + barrier.set_nonblocking(true).expect("poll"); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: barrier.local_addr().expect("port").port(), + }; + let runtime = runtime(); + let controls = Flavor::StripePlain.controls(); + let clock = controls.clock.clone(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "window-parent", + store.attempts().clone(), + controls, + )); + runtime + .block_on( + SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ) + .insert(&connection), + ) + .expect("connection"); + engine.initialize_effect_configuration().expect("control"); + Self { + _directory: directory, + store, + provider, + barrier, + setup, + runtime, + engine, + clock, + } + } + fn assert_current_authority_and_new_window(&self, operations: &[&str], expiry: u64) { + for operation in operations { + let load = |suffix: &str| { + std::fs::read(self.setup.root.join(format!("{operation}.{suffix}"))) + .expect("original input") + }; + let binding = crate::effect::EffectBinding::from_private_bytes(&load("binding")) + .expect("binding"); + let approval = + ExactEffectApproval::from_private_bytes(&load("approval")).expect("approval"); + binding + .validate_recorded_approval(&approval, expiry) + .expect("original approval remains time eligible"); + let fresh = self + .runtime + .block_on(self.engine.compile_effect(&load("proof"), &load("action"))) + .expect("original native proof still authorized"); + assert_ne!( + fresh.binding().id(), + binding.id(), + "window index is part of exact approval" + ); + assert!( + fresh + .approve( + approval, + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + expiry + ) + .is_err() + ); + } + } + fn expiry_cleanup(&self, results: &[GatewaySubmitResult], retained: &Retained, limit: Limit) { + let witness = self.engine.execution_witness(); + let expiry = (NOW / WINDOW + 2) * WINDOW; + self.clock.set(expiry - 1); + assert_eq!( + self.runtime.block_on(self.engine.sweep_expired_slots()), + Ok(0) + ); + for (kind, key, bytes) in retained { + assert_eq!( + self.store + .raw() + .load(*kind, key) + .expect("before expiry") + .as_ref(), + Some(bytes) + ); + } + self.clock.set(expiry); + assert!(expiry < NOW + 300); + self.assert_current_authority_and_new_window(&OPERATIONS, expiry); + assert_eq!( + self.runtime.block_on(self.engine.sweep_expired_slots()), + Ok(2 + 2 * usize::from(limit.sum())) + ); + let mut attempts = Vec::new(); + for (kind, key, bytes) in retained { + let actual = self.store.raw().load(*kind, key).expect("after expiry"); + if *kind == GatewayRecordKind::Attempt { + assert_eq!( + actual.as_ref(), + Some(bytes), + "retained full attempts are replay tombstones" + ); + attempts.push((*kind, *key, bytes.clone())); + } else { + assert!(actual.is_none(), "only expired window slots were removed"); + } + } + assert_eq!(attempts.len(), 3); + assert_eq!( + self.engine.execution_witness(), + witness, + "maintenance grants no custody or transport access" + ); + replay( + &self.setup, + &self.store, + &self.provider, + results, + &attempts, + expiry, + 2, + ); + } +} + +fn one_case(backend: Backend, limit: Limit) -> Value { + let case = MutationRace::new(backend); + let (store, provider, barrier, setup, runtime, engine) = ( + &case.store, + &case.provider, + &case.barrier, + &case.setup, + &case.runtime, + &case.engine, + ); + let mut expected = BTreeMap::new(); + let mut counters = Vec::new(); + for operation in OPERATIONS { + let candidate = runtime.block_on(inputs(engine, &setup.root, operation, limit)); + assert!( + counters.is_empty() + || counters + .iter() + .zip(&candidate) + .all( + |(left, right): (&Counter, &Counter)| left.kind == right.kind + && left.digest == right.digest + ) + ); + counters = candidate; + expected.insert( + operation, + std::fs::read(setup.root.join(format!("{operation}.body"))).expect("request"), + ); + } + let prefix = runtime.block_on(execute(engine, &setup.root, OPERATIONS[0])); + assert_eq!( + prefix, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!(provider.calls(), 1); + let contenders = contend(setup, barrier); + assert_eq!( + contenders + .iter() + .filter(|result| matches!( + result.result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + )) + .count(), + 1 + ); + assert_eq!(contenders.iter().filter(|result| matches!(&result.result, GatewaySubmitResult::NotEntered { code } if code == limit.refusal())).count(), 1); + let mut results = vec![prefix]; + results.extend(contenders.into_iter().map(|result| result.result)); + let requests = provider.requests.lock().expect("requests"); + assert_eq!(requests.len(), 2); + for (operation, result) in OPERATIONS.iter().zip(&results) { + if matches!(result, GatewaySubmitResult::ResponseRecorded { .. }) { + assert_eq!( + requests + .iter() + .filter(|request| request.body == expected[operation]) + .count(), + 1, + "each admitted exact body sent once" + ); + } + } + drop(requests); + let retained = retained(store, &counters, limit); + replay(setup, store, provider, &results, &retained, NOW, 2); + case.expiry_cleanup(&results, &retained, limit); + json!({"limit":limit.label(), "window_seconds":WINDOW, "prefix":1, "contenders":2, + "independent_worker_processes":true, "final_winners":1, "refusal_code":limit.refusal(), + "durable_grants":2, "count_slots":2, "sum_slots":if limit.sum(){2}else{0}, + "amount_per_mutation":AMOUNT, "policy_sum_amount":if limit.sum(){Some(2*AMOUNT)}else{None}, + "actual_http_writes":2, "no_implicit_reads":true, "exact_admitted_bodies_once":true, + "reopen_replay_preserves_attempt_and_counter_bytes":true, + "reopen_replay_leases_and_sends_nothing":true, + "expired_window_slots_removed":2+2*usize::from(limit.sum()), + "terminal_attempts_unchanged_after_sweep":3, "original_proof_and_approval_time_still_current":true, + "new_window_binding_requires_new_approval":true, "post_expiry_reopen_cannot_reenter_or_charge":true}) +} + +fn reserved_rows(case: &MutationRace, counters: &[Counter]) -> Retained { + let raw = case.store.raw(); + let keys = raw.attempt_keys(4).expect("keys"); + assert_eq!(keys.len(), 1); + let key = keys[0]; + let bytes = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("reserved"); + let record: Value = serde_json::from_slice(&bytes).expect("record"); + assert_eq!(record["operation_id"], OPERATIONS[0]); + assert!(record["entry"].is_null()); + assert_eq!(record["state"]["facts"]["stage"], "reserved"); + assert_eq!(record["revision"], 1); + assert_eq!( + record["state"]["facts"]["counters"] + .as_array() + .expect("counters") + .len(), + counters.len() + ); + let mut rows = vec![(GatewayRecordKind::Attempt, key, bytes)]; + for counter in counters { + let bytes = raw + .load(counter.kind, &counter.key(0)) + .expect("slot") + .expect("allocated"); + let value: Value = serde_json::from_slice(&bytes).expect("slot"); + assert_eq!(value["operation_id"], OPERATIONS[0]); + assert_eq!(value["slot"], 0); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(value["cumulative"], AMOUNT); + } + assert!( + raw.load(counter.kind, &counter.key(1)) + .expect("no second charge") + .is_none() + ); + rows.push((counter.kind, counter.key(0), bytes)); + } + rows +} + +fn reserved_case(backend: Backend, limit: Limit) -> Value { + let case = MutationRace::new(backend); + let operation = OPERATIONS[0]; + let counters = case + .runtime + .block_on(inputs(&case.engine, &case.setup.root, operation, limit)); + let input = case.setup.root.join("reserved-crash.setup"); + private( + &input, + &serde_json::to_vec(&json!({"installation":case.setup,"operation":operation, + "mode":"crash-after-reservation"})) + .expect("setup"), + ); + let mut peer = Peer::start( + &input, + "native_mutation_crash_tests::window_capacity_tests::native_mutation_window_peer", + WORKER, + ); + let _paused = peer.await_pause(&case.barrier); + peer.kill(); + assert_eq!(case.provider.calls(), 0); + let retained = reserved_rows(&case, &counters); + let permanent = retained + .iter() + .filter(|(kind, _, _)| *kind == GatewayRecordKind::Attempt) + .cloned() + .collect(); + let expiry = (NOW / WINDOW + 2) * WINDOW; + let witness = case.engine.execution_witness(); + case.clock.set(expiry - 1); + assert_eq!( + case.runtime.block_on(case.engine.sweep_expired_slots()), + Ok(0) + ); + for (kind, key, bytes) in &retained { + assert_eq!( + case.store + .raw() + .load(*kind, key) + .expect("retained") + .as_ref(), + Some(bytes) + ); + } + case.clock.set(expiry); + assert!(expiry < NOW + 300); + case.assert_current_authority_and_new_window(&[operation], expiry); + assert_eq!( + case.runtime.block_on(case.engine.sweep_expired_slots()), + Ok(counters.len()) + ); + for counter in &counters { + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(0)) + .expect("expired") + .is_none() + ); + } + assert_eq!(case.engine.execution_witness(), witness); + replay( + &case.setup, + &case.store, + &case.provider, + &[GatewaySubmitResult::Reserved { revision: 1 }], + &permanent, + expiry, + 0, + ); + json!({"limit":limit.label(),"window_seconds":WINDOW,"actual_sigkill_after_reservation_ack":true, + "durable_reservations":1,"entry_grants":0,"actual_http_writes":0, + "expired_window_slots_removed":counters.len(),"original_proof_and_approval_time_still_current":true, + "new_window_binding_requires_new_approval":true,"reserved_attempt_bytes_retained":true, + "reopen_old_reserved_operation_cannot_enter_or_recharge":true}) +} + +fn matrix(backend: Backend) { + let cases = [Limit::Count, Limit::Sum, Limit::Both] + .into_iter() + .map(|limit| one_case(backend, limit)) + .collect::>(); + let reserved_cases = [Limit::Count, Limit::Sum, Limit::Both] + .into_iter() + .map(|limit| reserved_case(backend, limit)) + .collect::>(); + let bytes = serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-window-capacity/1", "adapter":backend.label(), "cases":cases,"reserved_cases":reserved_cases, + "scope":"maintained plain Stripe native mutation recipe, full proof/exact approval, prefix and two independent OS contenders with separate custody; real file/TLS PostgreSQL transactions and counting HTTP; public fixture keys and controlled maintained clock", + "excluded":["guarded/prerequisite Stripe", "disclosure contention", "new admission across windows", "unsupported whole-store rollback", "durability faults", "hostile OS and live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-mutation-window-capacity-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} +#[test] +fn native_file_mutation_window_capacity_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_window_capacity_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs index 9ecba1209..a22dd94e0 100644 --- a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs @@ -34,6 +34,9 @@ const OPERATION: &str = "crash-write"; const RESPONSE: &[u8] = b"{\"id\":\"public-crash-response\"}"; const ENVIRONMENT: &str = "AUTHS_AP074_MUTATION_CRASH_PEER"; +#[path = "native_mutation_budget_tests.rs"] +mod window_capacity_tests; + #[derive(Clone, Copy, Debug, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] enum Flavor { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 1325fe00b..afc0a09b7 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "eb51e99dbcef8880a437ad2d651046439fb169edd223eb6d6f621e00f6c2c8e7"; + "3a439c92b1fedcc1e85d39e4955d11240cc9568877f73c7e0d46343b54a21e1b"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index ea914b811..9f13c2cfc 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 413 +freeze_version = 414 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 413 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 157 +"auths.identity.protocol" = 158 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 413 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 154 +"auths.product.public-sdk-contract" = 155 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 413 +"auths.release.public-surface" = 414 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index f7d2858bb..13fd85118 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 413, + "freezeVersion": 414, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 157, + "version": 158, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "747673b3a22a4943b17a9b469f3850e70494ab0f455a0bbbdf4e2ebda42c004b" + "sha256": "bd10dc8d6008550d6ca3a977ffdcc1925dcb9380aa48d6fdfeca84eaae7c65b2" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 154, + "version": 155, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "5a51215a85bdcf83dbc78c206b54772d55488823427383d495e82537013c1b08" + "sha256": "8c9ba669e13a06c6f1345951b676bdae893534660d932346f701b12cabc5baba" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 413, + "version": 414, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "1f511dc268f546ef880a6ff964fa80e4599e375a8c914252a587683f3faee3e9" + "sha256": "0bfcd0f8c0b753184eb77f1462e80c436227f498109b4e862b4df8957857cf67" } ] } From e19e85e5dffaec57de213f19e4ff6faccd733f3a Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:36:20 +0000 Subject: [PATCH 102/136] fix(gateway): reject foreign recipe provenance and scope substitutions --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-managed-scope-file.json | 302 ++++++++++ .../native-managed-scope-postgres.json | 302 ++++++++++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 25 + docs/plans/0074-implementation-status.md | 53 +- .../0009-bound-effect-and-recovery.md | 16 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/engine.rs | 6 +- .../src/native_information_replay_tests.rs | 3 + .../auths-gateway/src/native_process_tests.rs | 21 +- .../auths-gateway/src/native_scope_tests.rs | 527 ++++++++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 15 files changed, 1267 insertions(+), 18 deletions(-) create mode 100644 bindings/fixtures/gateway/native-managed-scope-file.json create mode 100644 bindings/fixtures/gateway/native-managed-scope-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_scope_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 23942fe3f..e9aa6999f 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -78,6 +78,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::retention_tests::postgres_native_retention_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::epoch_tests::native_file_epoch_fence_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::epoch_tests::postgres_native_epoch_fence_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::scope_tests::native_file_managed_scope_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::scope_tests::postgres_native_managed_scope_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres diff --git a/bindings/fixtures/gateway/native-managed-scope-file.json b/bindings/fixtures/gateway/native-managed-scope-file.json new file mode 100644 index 000000000..5cb39d985 --- /dev/null +++ b/bindings/fixtures/gateway/native-managed-scope-file.json @@ -0,0 +1,302 @@ +{ + "schema": "auths.native-managed-scope/1", + "adapter": "file", + "signed_contract_substitutions": [ + { + "field": "task", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "scope", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "participants", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "ancestors", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "charges", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "partition", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "epoch", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "operator_namespace", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "recipe_digest", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "content_contract", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "maximum_response_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + } + ], + "cross_partition": { + "same_valid_native_proof": true, + "different_partition_effect_identity": true, + "foreign_exact_approval_refused": true, + "foreign_history_refused": true, + "foreign_disclosure_source_refused": true, + "original_replay_retained": true, + "provider_reads": 1, + "retained_attempts": 1 + }, + "disclosure_substitutions": [ + { + "field": "task", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "scope", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "participants", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "ancestors", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "charges", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "partition", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "epoch", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "operator_namespace", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "recipe_digest", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "content_contract", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "maximum_response_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "disclosure_contract", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "source_effect", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "source_operation", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "recipient", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "channel", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "delivery_instance", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "maximum_disclosure_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + } + ], + "original_disclosure_acknowledged": true, + "cross_recipe": { + "same_namespace_partition_epoch_actor_resource": true, + "explicit_operator_activation": true, + "old_native_proof_still_authorized": true, + "activation_without_connection_reapproval_refused": true, + "native_connection_rotation_cas": true, + "old_recipe_compile_refused": true, + "old_approval_refused": true, + "fresh_approval_cannot_overwrite_retained_operation": true, + "foreign_history_and_disclosure_source_refused": true, + "original_history_retained": true, + "new_exact_operation_succeeds": true, + "provider_reads": 2, + "retained_attempts": 3 + }, + "scope": "native verification, managed compilation and entry over one durable adapter with independent engine configurations and actual local HTTP", + "excluded": [ + "multi-agent task semantics", + "hostile OS containment", + "installed language framing", + "all binding dimensions" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-managed-scope-postgres.json b/bindings/fixtures/gateway/native-managed-scope-postgres.json new file mode 100644 index 000000000..41b3b4342 --- /dev/null +++ b/bindings/fixtures/gateway/native-managed-scope-postgres.json @@ -0,0 +1,302 @@ +{ + "schema": "auths.native-managed-scope/1", + "adapter": "postgres", + "signed_contract_substitutions": [ + { + "field": "task", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "scope", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "participants", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "ancestors", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "charges", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "partition", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "epoch", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "operator_namespace", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "recipe_digest", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "content_contract", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + }, + { + "field": "maximum_response_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "entry_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "provider_reads": 0 + } + ], + "cross_partition": { + "same_valid_native_proof": true, + "different_partition_effect_identity": true, + "foreign_exact_approval_refused": true, + "foreign_history_refused": true, + "foreign_disclosure_source_refused": true, + "original_replay_retained": true, + "provider_reads": 1, + "retained_attempts": 1 + }, + "disclosure_substitutions": [ + { + "field": "task", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "scope", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "participants", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "ancestors", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "charges", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "partition", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "epoch", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "operator_namespace", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "recipe_digest", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "content_contract", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "maximum_response_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "disclosure_contract", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "source_effect", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "source_operation", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "recipient", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "channel", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "delivery_instance", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + }, + { + "field": "maximum_disclosure_bytes", + "native_authorized": true, + "managed_compile_refused": true, + "reservation_refused": true, + "journal_unchanged": true, + "credential_leases": 0, + "additional_provider_reads": 0 + } + ], + "original_disclosure_acknowledged": true, + "cross_recipe": { + "same_namespace_partition_epoch_actor_resource": true, + "explicit_operator_activation": true, + "old_native_proof_still_authorized": true, + "activation_without_connection_reapproval_refused": true, + "native_connection_rotation_cas": true, + "old_recipe_compile_refused": true, + "old_approval_refused": true, + "fresh_approval_cannot_overwrite_retained_operation": true, + "foreign_history_and_disclosure_source_refused": true, + "original_history_retained": true, + "new_exact_operation_succeeds": true, + "provider_reads": 2, + "retained_attempts": 3 + }, + "scope": "native verification, managed compilation and entry over one durable adapter with independent engine configurations and actual local HTTP", + "excluded": [ + "multi-agent task semantics", + "hostile OS containment", + "installed language framing", + "all binding dimensions" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index d77676e96..c21d5a4aa 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1675,6 +1675,8 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", "product/runtime/auths-gateway/src/native_epoch_tests.rs#native_file_epoch_fence_fixture_is_current", "product/runtime/auths-gateway/src/native_epoch_tests.rs#postgres_native_epoch_fence_fixture_is_current", + "product/runtime/auths-gateway/src/native_scope_tests.rs#native_file_managed_scope_fixture_is_current", + "product/runtime/auths-gateway/src/native_scope_tests.rs#postgres_native_managed_scope_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/recipe/tests.rs#three_independent_recipes_compile_without_provider_code", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index d43adf5a3..7b7553c53 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1240,3 +1240,28 @@ histories include SIGKILL after actual reservation acknowledgement. Disclosure reservation-only admission returns data and no permit. These tests add no production owner or new semantic abstraction. Source-specific adverse schedules, rollback floors, installed containment and final hosted evidence remain required. + +## Native unscoped contract and partition evidence + +The native verifier and managed compiler retain different responsibilities. +Freshly signed acquisition and disclosure calls can be valid native authority +while proposing unsupported task, participant, ancestor or charge inputs, or +substituting the closed compiler contract. The managed compiler refuses these +calls before admission. File and TLS PostgreSQL histories inspect unchanged +attempt bytes and execution witnesses, then execute the original exact read and +authenticated same-UID disclosure/ACK as positive controls. + +Two independently configured operator partitions share the physical adapter but +have different effect identities and control keys. The same valid proof does not +let an exact approval cross partitions, nor let a partition read or release the +other's retained content. Original history remains replayable without new entry. +An activated replacement recipe also requires an independently approved native +connection rotation/CAS; activation alone cannot reuse the old descriptor. Even +fresh proof and approval cannot overwrite the original operation. A separately +approved new operation remains possible under the replacement. The proposal +getter now checks the retained recipe digest before returning provenance; the +compiler and entry fence retain their own existing installation checks. +These tests exercise the present single-agent, unscoped protocol; they introduce +no task protocol, alternate admission authority or AP073 dependency. Installed +language framing, all binding dimensions and hostile OS containment remain +separate acceptance obligations. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 372139da1..96aaab76f 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3073,6 +3073,55 @@ freeze414 and only reported identity158/public-SDK155/public-surface414; other identity counters remain unchanged. Formal translation source closure remains a002. These construction results are not new hosted/formal acceptance. +## Native valid-authority scope and recipe checkpoint + +Two new artifact constructors cover file and TLS PostgreSQL. Each independently +verifies eleven acquisition and eighteen disclosure substitutions with the ordinary +native verifier before requiring managed compilation/admission refusal. These are +fresh, genuinely signed proofs under the installed trust: unsupported task/scope, +participant/ancestor/charge fields, caller partition/epoch, and substitutions for +the closed namespace/recipe/content or disclosure contract, source, recipient, +channel, delivery instance and byte ceiling. The expected compiler binding refusal +and unchanged raw attempt records/execution witness are asserted. No credential +lease or provider request follows a refused call. Original exact acquisition and +authenticated same-UID recipient delivery/ACK are positive controls. + +Each adapter also runs shared-store cross-partition and cross-recipe histories +with identical actor, resource and logical operation names. Different operator +partitions compile the same valid native proof to different effect identities; +the old exact approval cannot cross them, and foreign history/disclosure source +cannot resolve. The original approval still executes and replays without new +entry. A replacement recipe requires explicit activation plus native connection +rotation/CAS. Activation alone cannot bypass the old pinned descriptor. Old proof +and approval cannot authorize the new recipe; even fresh proof/approval cannot +overwrite the retained operation. A separately approved new operation succeeds. +Original recipe history remains available under its original recipe. + +The cross-recipe constructor exposed a missing recipe check in the disclosure +proposal getter: compilation and entry already rejected foreign provenance, but +the getter could return a proposal. `GatewayEngine::disclosure_target` now compares +the validated retained binding's recipe digest before returning provenance, using +the existing binding and refusal code. The regression requires immediate refusal, +with no journal or execution changes. This adds no authority owner or task system. +The test-only engine loader can initialize an explicit credential generation; +the replacement record is checked for exact equality with the ordinary native +generation-incrementing rotation result before the existing connection CAS. + +Required local artifact construction passed both exact selectors with one matched, +nonignored test: file0.79s and TLS PostgreSQL2.25s. The two artifacts contain 58 +valid-authority substitutions plus four partition/recipe histories. The PostgreSQL +workflow retains all 30 preceding selectors and adds two for 32 explicit native +selectors. These are constructor results, not new-head hosted acceptance. Same-UID +local transport proves no hostile OS containment. Complete binding-dimension, +installed language/UI and concurrent dependency/fault obligations remain; A02/A16 +remain partial. AP070 and the paused AP073 worktree are untouched. CI inspection, +holistic repairs and publication timing remain with the requested CI subagent. + +Native source-closure construction and rebuilt non-update verification passed. +Semantic inventory construction advances freeze415 and only the reported changed +identity159/public-SDK156/public-surface415 subjects. Formal translation source +closure remains a002; these construction results are not fresh formal proofs. + ## Phase gates | Phase | State | Outstanding gate | @@ -3092,7 +3141,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | Case | Required evidence | Implementation / authored / executed | Limitation or next work | | --- | --- | --- | --- | | A01 | Same bound identity and exact request across review/approval/send | Partial / native review/compiler and real mutation replay corpus / ten file/TLS PostgreSQL histories send the exact reviewed PATCH body | Full installed review-completeness and authenticated human/UI evidence pending | -| A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus and native retained-input controls / distinct valid proof/action, damaged approval, changed resource and changed recipient rejected during file/TLS PostgreSQL replay | Complete independent substitutions for every binding dimension and installed surface remain required | +| A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus, native retained-input controls and 58 valid-authority acquisition/disclosure substitutions on file/TLS PostgreSQL / closed scope/contract/source/recipient/channel/delivery substitutions refused without admission or I/O | Complete independent substitutions for every binding dimension and installed surface remain required | | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | @@ -3106,7 +3155,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native independent-process approval/authority/observer lock-wait cases / file/TLS PostgreSQL positive/stale observer controls executed at the exact freshness boundary and one second beyond | Full mutation/disclosure and installed/adverse evidence remain required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | | A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | -| A16 | Cross-task/recipe/partition substitution | Partial / adapter cases / no | Full task-scope and installed boundary evidence | +| A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | | A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / independent mutation and post-authorization information comparisons against unchanged references / hosted74ce mutation 28 requests + 26 responses, information 22 pairs across both adapters and 104 source/parser controls passed | Named A19 contracts audited in the differential-contracts document; final-head confirmation remains required, with AP070 independence and divergent claims retained | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 9fae047f1..142dbdaf8 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -877,3 +877,19 @@ The pending acceptance gates still include dependency-race/adverse schedules, supported floors, complete public binding/containment negatives, generated concurrent histories/formal links, bounded performance and final hosted results. AP070 remains independently application-owned; AP073 is untouched. + +Native scope histories additionally compare ordinary verifier authorization with +managed compiler refusal. Fresh signed acquisition/disclosure calls carrying +unsupported delegation, participant or charge fields never reach admission; +independent operator partitions sharing one adapter cannot exchange approvals, +history or disclosure provenance. Original exact acquisition and recipient ACK +are positive controls. These test-only histories use existing owners and create +no reusable semantic mechanism, task implementation or second decision system. +The evidence covers file/TLS PostgreSQL engines and local HTTP/same-UID sockets; +installed language boundaries and hostile OS containment remain separate gates. +The cross-recipe history exposed a missing provenance-getter recipe check. +The engine now refuses a foreign recipe before returning its disclosure proposal; +existing compilation/entry checks remain. The positive replacement uses native +generation-incrementing connection rotation and the existing CAS, checks that +activation alone is insufficient, and requires a new operation rather than +overwriting retained facts. No new semantic owner is extracted. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 78a4d2d30..0a4c8d5e3 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"76890f1835173adafebca6d02e8a22f367137abfc141ece97cdddc7f1ba47d55"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"eb0e488d5143daa92214cd47f3053a693f038aa2d4e0437f7dded4f1c77678ff"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"13a7294191d2f627f3a9c623805c23f30a5498b7acf7dd9a084a44127e2f7ea1"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"d07c43b9a1e770ce372a61bfdcdb9b8fa85ec33e0a5dfab7c172dc4781c6f551"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"b976fd7cd38015ee92541a36cf65a536e85b983b91b1308ec9defa548109ad17"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"13a7294191d2f627f3a9c623805c23f30a5498b7acf7dd9a084a44127e2f7ea1"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index c43506c69..e93930578 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -1378,7 +1378,8 @@ impl GatewayEngine { /// binding. This authenticates neither a live peer nor release authority. /// /// # Errors - /// Refuses absent, corrupt, rejected or unknown source content and invalid keys. + /// Refuses absent, corrupt, rejected, unknown or foreign-recipe source content + /// and invalid keys. pub async fn disclosure_target( &self, source_operation: &str, @@ -1395,6 +1396,9 @@ impl GatewayEngine { .map_err(|_| GatewaySubmitResult::Indeterminate { code: "gateway.attempt.state-unavailable".to_owned(), })?; + if source.source.journal_identity().3 != self.recipe.digest() { + return Err(not_entered("gateway.disclosure.binding")); + } crate::effect::DisclosureTarget::new(source, recipient_key, channel, delivery_instance) .map_err(|_| not_entered("gateway.disclosure.binding")) } diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index 046b1a26c..e01a96609 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -32,6 +32,9 @@ mod retention_tests; #[path = "native_epoch_tests.rs"] mod epoch_tests; +#[path = "native_scope_tests.rs"] +mod scope_tests; + #[derive(Clone, Copy, Debug)] enum Protocol { Acquisition, diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index 167ff2927..3107a41c3 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -107,6 +107,23 @@ pub(super) async fn load_controlled_engine( label: &str, attempts: GatewayAttempts, controls: EngineControls, +) -> (GatewayEngine, ConnectionRecord) { + load_controlled_engine_at_generation( + setup, + label, + attempts, + controls, + std::num::NonZeroU64::MIN, + ) + .await +} + +pub(super) async fn load_controlled_engine_at_generation( + setup: &Setup, + label: &str, + attempts: GatewayAttempts, + controls: EngineControls, + generation: std::num::NonZeroU64, ) -> (GatewayEngine, ConnectionRecord) { let recipe = controls.recipe.unwrap_or_else(recipe); let trust = controls.trust.unwrap_or_else(|| trust(&recipe)); @@ -118,7 +135,7 @@ pub(super) async fn load_controlled_engine( let reference = credentials .install( initial.connection_id(), - initial.credential_generation(), + generation, SecretBytes::new(SECRET.to_vec()).expect("synthetic credential"), ) .await @@ -132,7 +149,7 @@ pub(super) async fn load_controlled_engine( initial.descriptor().to_vec(), *initial.account_commitment(), *reference.as_bytes(), - initial.generation(), + generation, initial.state(), initial.allowed_workloads().to_vec(), initial.allowed_profiles().to_vec(), diff --git a/product/runtime/auths-gateway/src/native_scope_tests.rs b/product/runtime/auths-gateway/src/native_scope_tests.rs new file mode 100644 index 000000000..820eccf0c --- /dev/null +++ b/product/runtime/auths-gateway/src/native_scope_tests.rs @@ -0,0 +1,527 @@ +//! Valid native authority is necessary, but cannot extend a closed managed +//! contract or move retained content between operator partitions. +use super::*; +use crate::effect::EffectPolicy; + +fn scope_substitutions() -> Vec<(&'static str, Value)> { + vec![ + ("task", json!({"commitment": vec![7; 32]})), + ("scope", json!({"kind":"task", "commitment": vec![7; 32]})), + ("participants", json!(["caller-selected-participant"])), + ("ancestors", json!(["caller-selected-parent"])), + ("charges", json!([])), + ("partition", json!("caller-selected-partition")), + ("epoch", json!(2)), + ("operator_namespace", json!("another-operator")), + ("recipe_digest", json!("00".repeat(32))), + ("content_contract", json!("00".repeat(32))), + ("maximum_response_bytes", json!(1)), + ] +} + +fn refused_contract(fixture: &Fixture, field: &str, value: Value) -> Value { + let original = fixture + .runtime + .block_on(Input::content(&fixture.engine, Change::None)); + let call = fixture + .runtime + .block_on( + fixture + .engine + .content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, SOURCE), + ) + .expect("native call"); + let mut arguments = call.arguments().clone(); + arguments.insert(field.to_owned(), value); + let changed = McpToolCall::new(call.service(), call.name(), arguments).expect("changed call"); + let signed = tool_fixture_until(&changed, NOW, NOW + 86_400).expect("genuine native proof"); + assert_native_authorized(fixture, &signed.proof, &signed.action); + let before = fixture.records(); + let witness = fixture.engine.execution_witness(); + let compiled = fixture.runtime.block_on( + fixture + .engine + .compile_content_action(&signed.proof, &signed.action), + ); + assert!( + matches!(compiled, Err(crate::GatewaySubmitResult::NotEntered {code}) + if code == "gateway.acquisition.binding"), + "closed managed contract must reject {field}" + ); + let refused = fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &signed.proof, + &signed.action, + original.approval, + )); + assert!( + matches!(refused, Err(crate::GatewaySubmitResult::NotEntered {code}) + if code == "gateway.acquisition.binding"), + "no entry with substituted {field}" + ); + assert_eq!(fixture.records(), before); + assert_eq!(fixture.engine.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 0); + json!({"field":field, "native_authorized":true, "managed_compile_refused":true, + "entry_refused":true, "journal_unchanged":true, "credential_leases":0, + "provider_reads":0}) +} + +fn assert_native_authorized(fixture: &Fixture, proof: &[u8], action: &[u8]) { + let context_bytes = controls(fixture.clock.clone(), 29) + .trust + .expect("installed trust"); + let context = auths_codec::decode_verifier_context(&context_bytes).expect("context"); + let verified = crate::engine::verify_native(&context, NOW, proof, action) + .expect("ordinary native authority must be valid for this changed call"); + assert!(verified.action().is_some()); +} + +fn partition_engine(fixture: &Fixture) -> GatewayEngine { + let mut candidate_controls = controls(fixture.clock.clone(), 29); + candidate_controls.policy = EffectPolicy::new( + "independent-partition".to_owned(), + 1, + SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + ) + .expect("different operator partition"); + let attempts = GatewayAttempts::new( + fixture.store.reopen().store(), + candidate_controls.policy.clone(), + ) + .expect("separate scoped attempts"); + let (candidate, _) = fixture.runtime.block_on(load_controlled_engine( + &fixture.setup, + "independent-partition", + attempts, + candidate_controls, + )); + candidate + .initialize_effect_configuration() + .expect("independent partition initialization"); + assert_ne!( + fixture + .engine + .shared_configuration() + .expect("original control") + .key(), + candidate + .shared_configuration() + .expect("candidate control") + .key(), + ); + candidate +} + +fn cross_partition(fixture: &Fixture) -> Value { + let input = fixture + .runtime + .block_on(Input::content(&fixture.engine, Change::None)); + let original = fixture + .runtime + .block_on( + fixture + .engine + .compile_content_action(&input.proof, &input.action), + ) + .expect("original valid effect"); + let candidate = partition_engine(fixture); + let candidate_effect = fixture + .runtime + .block_on(candidate.compile_content_action(&input.proof, &input.action)) + .expect("same proof is valid in an independently installed partition"); + assert_ne!(original.binding().id(), candidate_effect.binding().id()); + let before = fixture.records(); + let witness = candidate.execution_witness(); + assert!( + fixture + .runtime + .block_on(candidate.acquire_content_action( + &input.proof, + &input.action, + input.approval.clone(), + )) + .is_err(), + "approval cannot cross partitions even with same actor and operation" + ); + assert_eq!(fixture.records(), before); + assert_eq!(candidate.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 0); + let acquired = fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &input.proof, + &input.action, + input.approval.clone(), + )) + .expect("original exact approval still works"); + let records = fixture.records(); + assert_eq!(records.len(), 1); + foreign_history_refused(fixture, &candidate); + assert_eq!(fixture.records(), records); + assert_eq!(candidate.execution_witness(), witness); + let original_witness = fixture.engine.execution_witness(); + assert_eq!( + fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &input.proof, + &input.action, + input.approval, + )) + .expect("original historical replay"), + acquired + ); + assert_eq!(fixture.engine.execution_witness(), original_witness); + assert_eq!(fixture.records(), records); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + json!({"same_valid_native_proof":true, "different_partition_effect_identity":true, + "foreign_exact_approval_refused":true, "foreign_history_refused":true, + "foreign_disclosure_source_refused":true, "original_replay_retained":true, + "provider_reads":1, "retained_attempts":1}) +} + +fn foreign_history_refused(fixture: &Fixture, candidate: &GatewayEngine) { + assert!( + fixture + .runtime + .block_on(candidate.content_history(SOURCE)) + .is_err() + ); + let uid = std::fs::metadata(&fixture.setup.root).expect("owner").uid(); + let policy = UnixDisclosurePolicy::new(uid, uid, [51; 32]); + assert!( + fixture + .runtime + .block_on(candidate.disclosure_target( + SOURCE, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + policy.commitment().expect("channel"), + [52; 32], + )) + .is_err(), + "foreign content cannot become a disclosure proposal" + ); +} + +fn disclosure_substitutions() -> Vec<(&'static str, Value)> { + let mut cases = scope_substitutions(); + cases.extend([ + ("disclosure_contract", json!("00".repeat(32))), + ("source_effect", json!("00".repeat(32))), + ("source_operation", json!("another-read")), + ("recipient", json!("another-recipient")), + ("channel", json!("00".repeat(32))), + ("delivery_instance", json!("00".repeat(32))), + ("maximum_disclosure_bytes", json!(0)), + ]); + cases +} + +fn refused_disclosure( + fixture: &Fixture, + target: &crate::effect::DisclosureTarget, + field: &str, + value: Value, +) -> Value { + let original = + fixture + .runtime + .block_on(Input::disclosure(&fixture.engine, target, Change::None)); + let call = target + .authorization_call( + &recipe(), + &LogicalOperationId::parse(RELEASE).expect("release operation"), + ) + .expect("native disclosure call"); + let mut arguments = call.arguments().clone(); + arguments.insert(field.to_owned(), value); + let changed = McpToolCall::new(call.service(), call.name(), arguments).expect("changed call"); + let signed = tool_fixture_until(&changed, NOW, NOW + 86_400).expect("genuine release proof"); + assert_native_authorized(fixture, &signed.proof, &signed.action); + let records = fixture.records(); + let witness = fixture.engine.execution_witness(); + let compiled = fixture + .runtime + .block_on( + fixture + .engine + .compile_disclosure_effect(target, &signed.proof, &signed.action), + ); + assert!( + matches!(compiled, Err(crate::GatewaySubmitResult::NotEntered {code}) + if code == "gateway.disclosure.binding"), + "changed {field} must fail managed disclosure compilation" + ); + assert!( + fixture + .runtime + .block_on(fixture.engine.admit_disclosure( + target, + &signed.proof, + &signed.action, + original.approval, + )) + .is_err(), + "changed {field} cannot reserve release" + ); + assert_eq!(fixture.records(), records); + assert_eq!(fixture.engine.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + json!({"field":field, "native_authorized":true, "managed_compile_refused":true, + "reservation_refused":true, "journal_unchanged":true, + "credential_leases":0, "additional_provider_reads":0}) +} + +fn disclosure_cases(fixture: &Fixture) -> Vec { + let uid = std::fs::metadata(&fixture.setup.root).expect("owner").uid(); + let policy = UnixDisclosurePolicy::new(uid, uid, [51; 32]); + let recipient = SigningKey::from_bytes(&[47; 32]); + let target = fixture + .runtime + .block_on(fixture.engine.disclosure_target( + SOURCE, + recipient.verifying_key().to_bytes(), + policy.commitment().expect("channel"), + [52; 32], + )) + .expect("original retained source"); + let cases = disclosure_substitutions() + .into_iter() + .map(|(field, value)| refused_disclosure(fixture, &target, field, value)) + .collect(); + let input = fixture + .runtime + .block_on(Input::disclosure(&fixture.engine, &target, Change::None)); + fixture.runtime.block_on(release( + &fixture.engine, + &input, + &target, + &policy, + &recipient, + true, + )); + assert_eq!( + fixture.records().len(), + 2, + "only original acquisition and exact release admitted" + ); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + cases +} + +fn changed_recipe_engine(fixture: &Fixture) -> GatewayEngine { + let mut source: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/content-only/recipe.json" + )) + .expect("recipe source"); + source["content"]["maximum_content_bytes"] = json!(63); + let changed = crate::CompiledRecipe::compile( + &serde_json::to_vec(&source).expect("changed source"), + include_bytes!("../../../../bindings/fixtures/gateway/content-only/profile.lock.json"), + ) + .expect("different valid recipe with identical resource and transport"); + assert_ne!(changed.digest(), recipe().digest()); + let mut candidate_controls = controls(fixture.clock.clone(), 29); + candidate_controls.recipe = Some(changed); + let attempts = GatewayAttempts::new( + fixture.store.reopen().store(), + candidate_controls.policy.clone(), + ) + .expect("same partition journal"); + let (candidate, record) = fixture.runtime.block_on( + crate::native_process_tests::load_controlled_engine_at_generation( + &fixture.setup, + "different-recipe", + attempts, + candidate_controls, + std::num::NonZeroU64::new(2).expect("new credential generation"), + ), + ); + assert!(candidate.initialize_effect_configuration().is_err()); + let revision = candidate + .effect_configuration_revision() + .expect("operator review"); + candidate + .activate_effect_configuration(revision) + .expect("explicit recipe activation"); + assert!( + fixture + .runtime + .block_on(candidate.content_authorization_call( + br#"{"record_id":"recTEST0000000001"}"#, + "recipe-current", + )) + .is_err(), + "activation cannot bypass the pinned connection descriptor" + ); + let shared = SharedConnection::new( + fixture.store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + let loaded = fixture + .runtime + .block_on(shared.load()) + .expect("load") + .expect("old connection"); + let rotated = loaded + .record() + .rotated( + record.descriptor().to_vec(), + *record.account_commitment(), + *record.credential_reference_commitment(), + record.updated_at_unix_seconds(), + ) + .expect("native generation-incrementing rotation"); + assert_eq!( + rotated, record, + "fixture must use the actual native rotation result" + ); + fixture + .runtime + .block_on(shared.replace(&loaded, &rotated)) + .expect("operator connection CAS"); + candidate +} + +fn signed_input(fixture: &Fixture, engine: &GatewayEngine, operation: &str) -> Input { + let call = fixture + .runtime + .block_on( + engine.content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, operation), + ) + .expect("native call"); + let signed = tool_fixture_until(&call, NOW, NOW + 86_400).expect("valid native proof"); + assert_native_authorized(fixture, &signed.proof, &signed.action); + let effect = fixture + .runtime + .block_on(engine.compile_content_action(&signed.proof, &signed.action)) + .expect("candidate recipe compiles its own valid action"); + Input { + proof: signed.proof, + action: signed.action, + approval: Input::approval(&effect, Change::None), + } +} + +fn cross_recipe(fixture: &Fixture) -> Value { + let original = fixture + .runtime + .block_on(Input::content(&fixture.engine, Change::None)); + let retained = fixture + .runtime + .block_on(fixture.engine.content_history(SOURCE)) + .expect("original content history"); + let candidate = changed_recipe_engine(fixture); + let records = fixture.records(); + let witness = candidate.execution_witness(); + assert!( + fixture + .runtime + .block_on(candidate.compile_content_action(&original.proof, &original.action,)) + .is_err(), + "old recipe's otherwise valid native proof cannot compile here" + ); + assert_native_authorized(fixture, &original.proof, &original.action); + assert!( + fixture + .runtime + .block_on(candidate.acquire_content_action( + &original.proof, + &original.action, + original.approval.clone(), + )) + .is_err() + ); + let changed = signed_input(fixture, &candidate, SOURCE); + assert!( + fixture + .runtime + .block_on(candidate.acquire_content_action( + &changed.proof, + &changed.action, + original.approval, + )) + .is_err(), + "old exact approval cannot approve the new recipe" + ); + assert!( + fixture + .runtime + .block_on(candidate.acquire_content_action( + &changed.proof, + &changed.action, + changed.approval, + )) + .is_err(), + "even fresh authority cannot overwrite the retained logical operation" + ); + foreign_history_refused(fixture, &candidate); + assert_eq!(fixture.records(), records); + assert_eq!(candidate.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!( + fixture + .runtime + .block_on(fixture.engine.content_history(SOURCE)) + .expect("old history remains available to its own recipe"), + retained + ); + let fresh = signed_input(fixture, &candidate, "recipe-current"); + fixture + .runtime + .block_on(candidate.acquire_content_action(&fresh.proof, &fresh.action, fresh.approval)) + .expect("new recipe can perform a separately approved new operation"); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 2); + assert_eq!(fixture.records().len(), records.len() + 1); + json!({"same_namespace_partition_epoch_actor_resource":true, + "explicit_operator_activation":true, "old_native_proof_still_authorized":true, + "activation_without_connection_reapproval_refused":true, + "native_connection_rotation_cas":true, + "old_recipe_compile_refused":true, "old_approval_refused":true, + "fresh_approval_cannot_overwrite_retained_operation":true, + "foreign_history_and_disclosure_source_refused":true, + "original_history_retained":true, "new_exact_operation_succeeds":true, + "provider_reads":2, "retained_attempts":3}) +} + +fn matrix(backend: Backend) { + let fixture = Fixture::new(backend); + let cases: Vec<_> = scope_substitutions() + .into_iter() + .map(|(field, value)| refused_contract(&fixture, field, value)) + .collect(); + let partition = cross_partition(&fixture); + let disclosures = disclosure_cases(&fixture); + let recipe = cross_recipe(&fixture); + let artifact = serde_json::to_vec_pretty(&json!({ + "schema":"auths.native-managed-scope/1", "adapter":backend.label(), + "signed_contract_substitutions":cases, "cross_partition":partition, + "disclosure_substitutions":disclosures, "original_disclosure_acknowledged":true, + "cross_recipe":recipe, + "scope":"native verification, managed compilation and entry over one durable adapter with independent engine configurations and actual local HTTP", + "excluded":["multi-agent task semantics", "hostile OS containment", "installed language framing", "all binding dimensions"] + })).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-managed-scope-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write artifact"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} + +#[test] +fn native_file_managed_scope_fixture_is_current() { + matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_managed_scope_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index afc0a09b7..9b28cee5c 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "3a439c92b1fedcc1e85d39e4955d11240cc9568877f73c7e0d46343b54a21e1b"; + "d23afc5130586f2a92ae31534ef63992394473e82a05d3913f54225a9cf8d1b8"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 9f13c2cfc..d7491a7b7 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 414 +freeze_version = 415 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 414 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 158 +"auths.identity.protocol" = 159 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 414 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 155 +"auths.product.public-sdk-contract" = 156 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 414 +"auths.release.public-surface" = 415 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 13fd85118..4ba2f6b6d 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 414, + "freezeVersion": 415, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 158, + "version": 159, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "bd10dc8d6008550d6ca3a977ffdcc1925dcb9380aa48d6fdfeca84eaae7c65b2" + "sha256": "56ca755ce33dc236720e2574826ec3157901161b7e19051d1f038e1e9e7d6ece" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 155, + "version": 156, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "8c9ba669e13a06c6f1345951b676bdae893534660d932346f701b12cabc5baba" + "sha256": "96b0b52d0626185f57927048509c9f7da076f1218bd6fe3f24f5b11e5e6e5fe2" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 414, + "version": 415, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "0bfcd0f8c0b753184eb77f1462e80c436227f498109b4e862b4df8957857cf67" + "sha256": "33c7c9e1502c089353df69e19e315dc93b8d54a5297fe3515b86c07edb941d56" } ] } From 0609ff259ffe0401676fa2877e9877249d536985 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:45:58 +0000 Subject: [PATCH 103/136] fix(ci): format PostgreSQL test documentation --- .../runtime/auths-gateway/src/native_mutation_budget_tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs index 22ebf49ea..cbb7f2760 100644 --- a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs @@ -1,5 +1,5 @@ //! Native final-unit mutation contention. One prefix and two independent OS -//! workers share actual file/TLS PostgreSQL state and a counting HTTP provider. +//! workers share actual file/TLS `PostgreSQL` state and a counting HTTP provider. use super::*; use crate::GatewayExecutionWitness; use std::{collections::BTreeMap, net::TcpStream, time::Instant}; From dedef2b79db645560853e93af9aa00d21a4fc41e Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:51:15 +0000 Subject: [PATCH 104/136] test(gateway): prove mutation entry ordering and wait-time expiry --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-mutation-entry-order-file.json | 142 ++++++ .../native-mutation-entry-order-postgres.json | 142 ++++++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 18 + docs/plans/0074-implementation-status.md | 52 +- .../0009-bound-effect-and-recovery.md | 9 + .../auths-gateway/semantic-closure.json | 2 +- .../src/native_dependency_tests.rs | 54 +- .../src/native_mutation_entry_tests.rs | 460 ++++++++++++++++++ .../src/native_mutation_replay_tests.rs | 3 + .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 14 files changed, 880 insertions(+), 30 deletions(-) create mode 100644 bindings/fixtures/gateway/native-mutation-entry-order-file.json create mode 100644 bindings/fixtures/gateway/native-mutation-entry-order-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_mutation_entry_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index e9aa6999f..2677e20fb 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -80,6 +80,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::epoch_tests::postgres_native_epoch_fence_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::scope_tests::native_file_managed_scope_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::scope_tests::postgres_native_managed_scope_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::entry_tests::native_file_mutation_entry_order_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::entry_tests::postgres_native_mutation_entry_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-file.json b/bindings/fixtures/gateway/native-mutation-entry-order-file.json new file mode 100644 index 000000000..664b6d914 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-entry-order-file.json @@ -0,0 +1,142 @@ +{ + "schema": "auths.native-mutation-entry-order/1", + "adapter": "file", + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "revoke", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "configuration", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "configuration", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + } + ], + "scope": "actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", + "excluded": [ + "disclosure races", + "selected observer and threshold expiry", + "installed language framing", + "hostile OS containment", + "whole-store rollback and power loss" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json new file mode 100644 index 000000000..cf9d42f9a --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json @@ -0,0 +1,142 @@ +{ + "schema": "auths.native-mutation-entry-order/1", + "adapter": "postgres", + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "revoke", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "configuration", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "configuration", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000004, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + } + ], + "scope": "actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", + "excluded": [ + "disclosure races", + "selected observer and threshold expiry", + "installed language framing", + "hostile OS containment", + "whole-store rollback and power loss" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index c21d5a4aa..adcb7c3b5 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1677,6 +1677,8 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/native_epoch_tests.rs#postgres_native_epoch_fence_fixture_is_current", "product/runtime/auths-gateway/src/native_scope_tests.rs#native_file_managed_scope_fixture_is_current", "product/runtime/auths-gateway/src/native_scope_tests.rs#postgres_native_managed_scope_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_entry_tests.rs#native_file_mutation_entry_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_entry_tests.rs#postgres_native_mutation_entry_order_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/recipe/tests.rs#three_independent_recipes_compile_without_provider_code", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 7b7553c53..a60afa4f1 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1265,3 +1265,21 @@ These tests exercise the present single-agent, unscoped protocol; they introduce no task protocol, alternate admission authority or AP073 dependency. Installed language framing, all binding dimensions and hostile OS containment remain separate acceptance obligations. + +## Mutation dependency order and wait-time validation + +Native Airtable mutation histories now schedule independent worker and operator +processes against each maintained adapter's actual common writer fence. Connection +revocation and configuration activation are ordered before versus after the final +grant. Independent approval and native authority deadlines have eligible and +expired controls while the worker demonstrably waits on a physically different +connection record. Only the existing native callback computes and persists the +grant; the scheduling wrapper supplies neither record bytes nor a decision. + +Refused final entry retains the original reservation with zero HTTP writes. A +grant that linearizes first permits one exact captured write; terminal replay +after reopen creates no new custody or transport calls. The test explicitly +counts the custody lease that preceded the final fence; refusal does not undo it. +This extends the acquisition fence evidence using the same test-only scheduling +helper and adds no production owner. Selected observer/threshold timing, +disclosure races, installed languages and OS containment remain separate work. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 96aaab76f..b29d57c97 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3122,6 +3122,54 @@ Semantic inventory construction advances freeze415 and only the reported changed identity159/public-SDK156/public-surface415 subjects. Formal translation source closure remains a002; these construction results are not fresh formal proofs. +## Native mutation entry-order checkpoint + +Sixteen new histories cover eight schedules on each of file and TLS PostgreSQL: +connection revocation and shared configuration activation before versus after +the final entry grant, plus independent approval/native-authority eligible and +expired controls during an actual writer-fence wait. Separate native worker and +operator OS processes share the maintained adapter. The operator holds or changes +a physically distinct connection/configuration row; the worker's final native +callback receives snapshots only under the same real adapter fence. Worker and +operator PIDs differ, and the worker must reach that final fence explicitly. + +When operator withdrawal wins, the native result remains Reserved with original +attempt facts and zero HTTP writes. When the grant wins, the counting provider +receives exactly one original closed Airtable mutation body. Terminal reopen and +replay retain byte-identical journal data and perform no new custody or transport +calls. Eligible lock-wait controls record their advanced grant time; expired proof +or approval produces no write. Each worker already acquired one credential lease +before the pause, and that observed lease is counted explicitly even when final +entry refuses. Signed proof/action/approval bytes and original admission time +remain unchanged; no test refreshes authorization or fabricates a grant. + +The acquisition scheduling helper now accepts an explicit operation key and +recognizes the existing typed mutation and acquisition grant shapes. No shipping +runtime/store behavior, new fault switch, callback authority or lifecycle owner +was added. The initial constructor exposed two fixture setup errors: the helper +had assumed acquisition's nested phase shape, and an operator using a new +approver needed its own matching `GatewayAttempts` policy. Both fixture errors +were corrected without changing native authorization or reducing assertions. + +Required artifact construction passed each exact selector with one matched, +nonignored test: mutation file1.92s and TLS PostgreSQL3.01s. The original acquisition +constructors also passed without update mode after the shared helper change: +file3.63s and TLS PostgreSQL4.90s, preserving their committed artifacts. The workflow +preserves all 32 preceding native selectors and adds two for 34 explicit selectors. +This is local constructor evidence, not new-head hosted acceptance. Selected +observer/threshold timing for mutation, full disclosure races and installed +language/adverse/containment obligations remain; A12/A13 stay partial. + +Integrated the CI subagent's exact documentation correction as `0609ff25`: +backticks around PostgreSQL in the mutation-budget module comment. Its isolated +reproduction of the actual failed strict Clippy check passed; the main agent did +not inspect CI or duplicate that check. AP070/AP073 remain untouched. + +Native source-closure construction and rebuilt non-update verification passed. +Semantic inventory construction advances freeze416 and only its reported changed +identity160/public-SDK157/public-surface416 subjects. Formal translation closure +remains a002; neither metadata construction nor translation reuse is fresh proof. + ## Phase gates | Phase | State | Outstanding gate | @@ -3151,8 +3199,8 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | -| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate plus full native acquisition worker/operator histories / sixteen file/TLS PostgreSQL histories executed | Complete mutation/disclosure races remain required | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native independent-process approval/authority/observer lock-wait cases / file/TLS PostgreSQL positive/stale observer controls executed at the exact freshness boundary and one second beyond | Full mutation/disclosure and installed/adverse evidence remain required | +| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition and sixteen native mutation worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Full disclosure races and remaining mutation dependency scopes remain required | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, native acquisition evidence timing and native mutation independent proof/approval lock waits / eligible and expired controls executed on file/TLS PostgreSQL | Remaining mutation selected-observer/threshold, disclosure and installed/adverse evidence required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | | A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | | A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 142dbdaf8..e46870862 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -893,3 +893,12 @@ existing compilation/entry checks remain. The positive replacement uses native generation-incrementing connection rotation and the existing CAS, checks that activation alone is insufficient, and requires a new operation rather than overwriting retained facts. No new semantic owner is extracted. + +Mutation entry-order histories reuse only the test scheduling helper from the +native acquisition matrix. The helper now accepts an exact operation key and +recognizes the existing typed mutation/acquisition entry-granted wire shapes. +Native compilation, approval, admission, time checks, dependency snapshots and +grant persistence remain the existing production owners. Separate OS workers and +operators order actual file/TLS PostgreSQL locks around revocation, configuration +activation and independently expiring proof/approval intervals. This is additional +vertical evidence, not a shared shipping abstraction or new lifecycle framework. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 0a4c8d5e3..93341d352 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"0fe040b7c23554074b8d147d5b66541912377df132619d6efc549fd7f7e0205c"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"b976fd7cd38015ee92541a36cf65a536e85b983b91b1308ec9defa548109ad17"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"13a7294191d2f627f3a9c623805c23f30a5498b7acf7dd9a084a44127e2f7ea1"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"424f34e9b73b5c513f3b098f336847050e6143fbd5e48a3823d80cb7eb1047f7"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"b976fd7cd38015ee92541a36cf65a536e85b983b91b1308ec9defa548109ad17"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"0ff952978fb0676b69d1133baf2e554b25af363a49aa897084e18981d3984e3e"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"2b88eb67decc7d480126192b6e004931687fe89caf9c1571db7da7b49709dc7d"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_dependency_tests.rs b/product/runtime/auths-gateway/src/native_dependency_tests.rs index 07d7cb76b..339da4184 100644 --- a/product/runtime/auths-gateway/src/native_dependency_tests.rs +++ b/product/runtime/auths-gateway/src/native_dependency_tests.rs @@ -32,7 +32,7 @@ const OPERATION: &str = "dependency-read"; #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] -enum Scenario { +pub(super) enum Scenario { Revoke, Configuration, ApprovalValid, @@ -45,7 +45,7 @@ enum Scenario { ThresholdChanged, } impl Scenario { - const fn time_shift(self) -> u64 { + pub(super) const fn time_shift(self) -> u64 { match self { Self::ApprovalValid | Self::AuthorityValid => 4, Self::ObserverValid | Self::ThresholdValid => 5, @@ -69,7 +69,7 @@ impl Scenario { } #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] -enum Order { +pub(super) enum Order { ChangeFirst, GrantFirst, LockWait, @@ -103,7 +103,7 @@ impl Race { } } -fn connect(port: u16) -> TcpStream { +pub(super) fn connect(port: u16) -> TcpStream { let channel = TcpStream::connect(("127.0.0.1", port)).expect("test control"); channel .set_read_timeout(Some(Duration::from_secs(15))) @@ -113,15 +113,15 @@ fn connect(port: u16) -> TcpStream { .expect("deadline"); channel } -fn send(channel: &mut TcpStream, marker: u8) { +pub(super) fn send(channel: &mut TcpStream, marker: u8) { channel.write_all(&[marker]).expect("marker"); } -fn expect(channel: &mut TcpStream, marker: u8) { +pub(super) fn expect(channel: &mut TcpStream, marker: u8) { let mut value = [0]; channel.read_exact(&mut value).expect("control marker"); assert_eq!(value, [marker]); } -fn pending(channel: &mut TcpStream) { +pub(super) fn pending(channel: &mut TcpStream) { channel .set_read_timeout(Some(Duration::from_millis(50))) .expect("short observation"); @@ -138,14 +138,34 @@ fn pending(channel: &mut TcpStream) { .expect("deadline"); } -struct EntryGate { +pub(super) struct EntryGate { inner: Arc, order: Order, port: u16, clock: Arc, fired: AtomicBool, + key: GatewayAttemptKey, } impl EntryGate { + pub(super) fn reached(&self) -> bool { + self.fired.load(Ordering::SeqCst) + } + pub(super) fn new( + inner: Arc, + order: Order, + port: u16, + clock: Arc, + key: GatewayAttemptKey, + ) -> Self { + Self { + inner, + order, + port, + clock, + key, + fired: AtomicBool::new(false), + } + } fn before_lock( &self, keys: &[(GatewayRecordKind, GatewayAttemptKey)], @@ -184,7 +204,7 @@ impl GatewayAttemptStore for EntryGate { keys: &[(GatewayRecordKind, GatewayAttemptKey)], decide: &mut GatewayFenceDecision<'_>, ) -> Result<(), GatewayAttemptError> { - let target = keys.first() == Some(&(GatewayRecordKind::Attempt, Race::key())); + let target = keys.first() == Some(&(GatewayRecordKind::Attempt, self.key)); if !target || self.fired.swap(true, Ordering::SeqCst) { return self.inner.fenced_replace(keys, decide); } @@ -194,7 +214,7 @@ impl GatewayAttemptStore for EntryGate { ] { let dependencies: Vec<_> = keys.iter().filter(|(found, _)| *found == kind).collect(); assert_eq!(dependencies.len(), 1, "entry fences its actual dependency"); - assert_ne!(dependencies[0].1, Race::key(), "physically distinct record"); + assert_ne!(dependencies[0].1, self.key, "physically distinct record"); } if !matches!(self.order, Order::GrantFirst) { return self.before_lock(keys, decide); @@ -202,7 +222,10 @@ impl GatewayAttemptStore for EntryGate { self.inner.fenced_replace(keys, &mut |snapshots| { let bytes = decide(snapshots)?; let value: Value = serde_json::from_slice(&bytes).expect("native decision"); - assert_eq!(value["state"]["facts"]["phase"]["stage"], "entry-granted"); + assert!( + value["state"]["facts"]["phase"]["stage"] == "entry-granted" + || value["state"]["facts"]["stage"] == "entry-granted" + ); let mut channel = connect(self.port); send(&mut channel, b'P'); expect(&mut channel, b'G'); @@ -255,6 +278,7 @@ fn run_worker(race: &Race, store: &TestAttempts) { port: race.installation.barrier_port, clock: clock.clone(), fired: AtomicBool::new(false), + key: Race::key(), }); let attempts = GatewayAttempts::new(gate, crate::effect::fixture_policy().expect("policy")) .expect("attempts"); @@ -392,7 +416,7 @@ fn native_dependency_peer() { _ => panic!("unknown private test role"), } } -struct Peer(Child); +pub(super) struct Peer(pub(super) Child); impl Peer { fn start(input: &Path, role: &str) -> Self { Self( @@ -425,7 +449,7 @@ impl Peer { } result } - fn accept(&mut self, listener: &TcpListener) -> TcpStream { + pub(super) fn accept(&mut self, listener: &TcpListener) -> TcpStream { let deadline = Instant::now() + Duration::from_secs(15); loop { assert!( @@ -451,7 +475,7 @@ impl Peer { } } } - fn finish(&mut self) { + pub(super) fn finish(&mut self) { let deadline = Instant::now() + Duration::from_secs(20); while self.check_exit().is_none() { assert!(Instant::now() < deadline, "peer completion timeout"); @@ -472,7 +496,7 @@ impl Drop for Peer { } } } -fn listener() -> TcpListener { +pub(super) fn listener() -> TcpListener { let value = TcpListener::bind("127.0.0.1:0").expect("listener"); value.set_nonblocking(true).expect("nonblocking"); value diff --git a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs new file mode 100644 index 000000000..21b5a892b --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs @@ -0,0 +1,460 @@ +//! Native mutation entry linearizes with actual adapter locks, independent +//! operator processes and the maintained test clock. No decision is fabricated. +use super::*; +use crate::GatewayAttemptKey; +use crate::native_dependency_tests::{ + EntryGate, Order, Peer, Scenario, connect, expect, listener, pending, send, +}; +use serde::{Deserialize, Serialize}; +use std::{ + net::TcpStream, + process::{Command, Stdio}, +}; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Race { + setup: Setup, + scenario: Scenario, + order: Order, + operator_port: u16, +} +impl Race { + fn key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(OPERATION).expect("operation"), + ) + .expect("key") + } + const fn enters(&self) -> bool { + matches!(self.order, Order::GrantFirst) + || matches!( + self.scenario, + Scenario::ApprovalValid | Scenario::AuthorityValid + ) + } + const fn change(&self) -> Change { + match self.scenario { + Scenario::ApprovalValid | Scenario::ApprovalExpired => Change::ApprovalExpiry, + Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, + Scenario::Revoke | Scenario::Configuration => Change::None, + _ => unreachable!(), + } + } + fn inputs(&self) -> Vec> { + ["proof", "action", "approval"] + .map(|suffix| { + std::fs::read(self.setup.root.join(suffix)).expect("original signed input") + }) + .to_vec() + } + fn peer(&self, role: &str) -> Peer { + Peer( + Command::new(std::env::current_exe().expect("test executable")) + .args([ + "--exact", + "native_mutation_replay_tests::entry_tests::native_mutation_entry_peer", + "--nocapture", + ]) + .env( + "AUTHS_AP074_MUTATION_ENTRY_PEER", + self.setup.root.join("race.json"), + ) + .env("AUTHS_AP074_MUTATION_ENTRY_ROLE", role) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("independent peer"), + ) + } +} + +fn worker(race: &Race, store: &TestAttempts) { + let clock = Arc::new(FixedClock::at(NOW)); + let gate = Arc::new(EntryGate::new( + store.raw(), + race.order, + race.setup.barrier_port, + clock.clone(), + Race::key(), + )); + let attempts = GatewayAttempts::new( + gate.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &race.setup, + "entry-worker", + attempts, + controls(clock, 29), + )); + let inputs = race.inputs(); + let approval = serde_json::from_slice(&inputs[2]).expect("exact approval"); + let result = runtime.block_on(engine.submit(&inputs[0], &inputs[1], approval)); + assert!( + gate.reached(), + "native worker must reach final fence: {result:?}" + ); + crate::native_process_tests::private( + &race.setup.root.join("worker-result"), + &serde_json::to_vec(&result).expect("result"), + ); + crate::native_process_tests::private( + &race.setup.root.join("worker-witness"), + &serde_json::to_vec(&engine.execution_witness()).expect("witness"), + ); +} + +fn operator(race: &Race, store: &TestAttempts) { + let runtime = runtime(); + let candidate_controls = controls( + Arc::new(FixedClock::at(NOW)), + if matches!(race.scenario, Scenario::Configuration) { + 30 + } else { + 29 + }, + ); + let attempts = GatewayAttempts::new(store.raw(), candidate_controls.policy.clone()) + .expect("operator candidate policy"); + let (engine, record) = runtime.block_on(load_controlled_engine( + &race.setup, + "entry-operator", + attempts, + candidate_controls, + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + let current = runtime + .block_on(shared.load()) + .expect("load") + .expect("connection"); + let reviewed = engine + .effect_configuration_revision() + .expect("operator review"); + let mut channel = connect(race.operator_port); + send(&mut channel, b'S'); + expect(&mut channel, b'G'); + match race.order { + Order::LockWait => { + let key = crate::connection::connection_key(record.provider_kind(), record.alias()); + store + .raw() + .fenced_replace(&[(GatewayRecordKind::Connection, key)], &mut |rows| { + send(&mut channel, b'H'); + expect(&mut channel, b'G'); + Ok(rows[0].clone().expect("actual connection bytes")) + }) + .expect("actual held writer fence"); + } + _ => match race.scenario { + Scenario::Revoke => { + let revoked = current + .record() + .transition_state(auths_connections::ConnectionState::Revoked, NOW) + .expect("native revocation"); + runtime + .block_on(shared.replace(¤t, &revoked)) + .expect("operator CAS"); + } + Scenario::Configuration => { + engine + .activate_effect_configuration(reviewed) + .expect("operator activation"); + } + _ => unreachable!(), + }, + } + crate::native_process_tests::private(&race.setup.root.join("operator-result"), b"committed"); + send(&mut channel, b'D'); +} + +#[test] +fn native_mutation_entry_peer() { + let Some(path) = std::env::var_os("AUTHS_AP074_MUTATION_ENTRY_PEER") else { + return; + }; + let race: Race = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach(Backend::parse(&race.setup.backend), &race.setup.location); + match std::env::var("AUTHS_AP074_MUTATION_ENTRY_ROLE") + .expect("role") + .as_str() + { + "worker" => worker(&race, &store), + "operator" => operator(&race, &store), + _ => panic!("unsupported test role"), + } +} + +struct Case { + _directory: tempfile::TempDir, + store: TestAttempts, + race: Race, + worker_listener: TcpListener, + operator_listener: TcpListener, + provider: Provider, + input: Input, + signed_inputs: Vec>, +} +impl Case { + fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("root"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let worker_listener = listener(); + let operator_listener = listener(); + let provider = Provider::start(); + let store = TestAttempts::open(backend); + let race = Race { + scenario, + order, + operator_port: operator_listener.local_addr().expect("port").port(), + setup: Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: worker_listener.local_addr().expect("port").port(), + }, + }; + let runtime = runtime(); + let (engine, record) = runtime.block_on(load_controlled_engine( + &race.setup, + "entry-parent", + store.attempts().clone(), + controls(Arc::new(FixedClock::at(NOW)), 29), + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + runtime + .block_on(shared.insert(&record)) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let input = runtime.block_on(Input::author(&engine, race.change())); + let signed_inputs = vec![ + input.proof.clone(), + input.action.clone(), + serde_json::to_vec(&input.approval).expect("approval"), + ]; + for (name, bytes) in ["proof", "action", "approval"].iter().zip(&signed_inputs) { + crate::native_process_tests::private(&race.setup.root.join(name), bytes); + } + crate::native_process_tests::private( + &race.setup.root.join("race.json"), + &serde_json::to_vec(&race).expect("setup"), + ); + Self { + _directory: directory, + store, + race, + worker_listener, + operator_listener, + provider, + input, + signed_inputs, + } + } + fn schedule( + &self, + operator: &mut Peer, + worker: &mut Peer, + op: &mut TcpStream, + run: &mut TcpStream, + ) { + assert!(self.provider.bodies.lock().expect("requests").is_empty()); + match self.race.order { + Order::ChangeFirst => { + send(op, b'G'); + expect(op, b'D'); + operator.finish(); + send(run, b'G'); + } + Order::GrantFirst => { + send(op, b'G'); + pending(op); + assert!(!self.race.setup.root.join("operator-result").exists()); + send(run, b'G'); + expect(op, b'D'); + operator.finish(); + } + Order::LockWait => { + send(op, b'G'); + expect(op, b'H'); + send(run, b'G'); + expect(run, b'W'); + run.write_all(&(NOW + self.race.scenario.time_shift()).to_be_bytes()) + .expect("clock advance"); + expect(run, b'A'); + pending(run); + assert!(self.provider.bodies.lock().expect("requests").is_empty()); + send(op, b'G'); + expect(op, b'D'); + operator.finish(); + expect(run, b'D'); + } + } + worker.finish(); + } + fn execute(&self) -> GatewaySubmitResult { + let mut operator = self.race.peer("operator"); + let mut op = operator.accept(&self.operator_listener); + expect(&mut op, b'S'); + let mut worker = self.race.peer("worker"); + assert_ne!(operator.0.id(), worker.0.id()); + assert_ne!(worker.0.id(), std::process::id()); + let mut run = worker.accept(&self.worker_listener); + expect(&mut run, b'P'); + self.schedule(&mut operator, &mut worker, &mut op, &mut run); + serde_json::from_slice( + &std::fs::read(self.race.setup.root.join("worker-result")).expect("result"), + ) + .expect("native result") + } + fn verify(&self, result: &GatewaySubmitResult) -> Value { + assert_eq!(self.race.inputs(), self.signed_inputs); + if self.race.enters() { + assert_eq!( + *result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!( + *self.provider.bodies.lock().expect("requests"), + vec![self.input.body.clone()] + ); + } else { + assert!(matches!(result, GatewaySubmitResult::Reserved { .. })); + assert!(self.provider.bodies.lock().expect("requests").is_empty()); + } + let witness: crate::GatewayExecutionWitness = serde_json::from_slice( + &std::fs::read(self.race.setup.root.join("worker-witness")).expect("witness"), + ) + .expect("native witness"); + assert_eq!( + witness.credential_lease_calls, 1, + "the pause is after admission/custody" + ); + assert_eq!( + witness.write_transport_entries, + u64::from(self.race.enters()) + ); + assert_eq!(witness.read_transport_entries, 0); + let raw = self.store.raw(); + let bytes = raw + .load(GatewayRecordKind::Attempt, &Race::key()) + .expect("load") + .expect("attempt"); + let record: Value = serde_json::from_slice(&bytes).expect("record"); + assert_eq!(record["evaluated_at"], NOW); + assert_eq!(!record["entry"].is_null(), self.race.enters()); + if matches!(self.race.order, Order::LockWait) && self.race.enters() { + assert_eq!( + record["entry"]["granted_at"], + NOW + self.race.scenario.time_shift() + ); + } + self.reopen(result, &bytes); + json!({"scenario":self.race.scenario, "order":self.race.order, + "separate_worker_and_operator_processes":true, "signed_inputs_unchanged":true, + "native_result":result, "admission_time":NOW, + "clock_after_wait":matches!(self.race.order, Order::LockWait).then(|| NOW+self.race.scenario.time_shift()), + "actual_credential_leases":1, "actual_provider_writes":u64::from(self.race.enters()), + "reopened_history_unchanged":true, "historical_replay_performs_no_io":self.race.enters()}) + } + fn reopen(&self, result: &GatewaySubmitResult, bytes: &[u8]) { + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &self.race.setup, + "entry-reopened", + self.store.reopen(), + controls( + Arc::new(FixedClock::at(NOW + self.race.scenario.time_shift())), + 29, + ), + )); + let operation = LogicalOperationId::parse(OPERATION).expect("operation"); + let history = runtime + .block_on(self.store.attempts().read(recipe().namespace(), &operation)) + .expect("history") + .expect("retained"); + assert_eq!( + history.stage(), + if self.race.enters() { + crate::GatewayAttemptStage::ResponseRecorded + } else { + crate::GatewayAttemptStage::Reserved + } + ); + if self.race.enters() { + let before = engine.execution_witness(); + assert_eq!(runtime.block_on(self.input.submit(&engine)), *result); + assert_eq!(engine.execution_witness(), before); + } + assert_eq!( + self.store + .raw() + .load(GatewayRecordKind::Attempt, &Race::key()) + .expect("load") + .expect("attempt"), + bytes + ); + } +} + +fn matrix(backend: Backend) { + let schedules = [ + (Scenario::Revoke, Order::ChangeFirst), + (Scenario::Revoke, Order::GrantFirst), + (Scenario::Configuration, Order::ChangeFirst), + (Scenario::Configuration, Order::GrantFirst), + (Scenario::ApprovalValid, Order::LockWait), + (Scenario::ApprovalExpired, Order::LockWait), + (Scenario::AuthorityValid, Order::LockWait), + (Scenario::AuthorityExpired, Order::LockWait), + ]; + let cases: Vec<_> = schedules + .into_iter() + .map(|(scenario, order)| { + let case = Case::new(backend, scenario, order); + let result = case.execute(); + case.verify(&result) + }) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-entry-order/1", + "adapter":backend.label(), "cases":cases, + "scope":"actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", + "excluded":["disclosure races", "selected observer and threshold expiry", "installed language framing", "hostile OS containment", "whole-store rollback and power loss"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-mutation-entry-order-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} + +#[test] +fn native_file_mutation_entry_order_fixture_is_current() { + matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_entry_order_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs index ffb7219bd..33893f232 100644 --- a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs @@ -28,6 +28,9 @@ use std::{ const OPERATION: &str = "retained-mutation"; const SECRET: &[u8] = b"public-native-process-fixture"; +#[path = "native_mutation_entry_tests.rs"] +mod entry_tests; + struct Provider { port: u16, bodies: Arc>>>, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 9b28cee5c..6de89c3af 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d23afc5130586f2a92ae31534ef63992394473e82a05d3913f54225a9cf8d1b8"; + "9583463d07c03447cc6123cadcd5b9e97c085c2c60a107178a5fb71a014680f5"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index d7491a7b7..1e08eb4ab 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 415 +freeze_version = 416 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 415 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 159 +"auths.identity.protocol" = 160 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 415 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 156 +"auths.product.public-sdk-contract" = 157 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 415 +"auths.release.public-surface" = 416 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 4ba2f6b6d..709e42726 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 415, + "freezeVersion": 416, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 159, + "version": 160, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "56ca755ce33dc236720e2574826ec3157901161b7e19051d1f038e1e9e7d6ece" + "sha256": "cccaec257b1db0e4bc97b6483be5a54dd619b0e302b6c1b98c80474d50bb711c" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 156, + "version": 157, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "96b0b52d0626185f57927048509c9f7da076f1218bd6fe3f24f5b11e5e6e5fe2" + "sha256": "ebeee92d79d13ea07b17887082798e1dcad62cf67a06a9d241109712ff28cae8" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 415, + "version": 416, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "33c7c9e1502c089353df69e19e315dc93b8d54a5297fe3515b86c07edb941d56" + "sha256": "1aedf803fddc5ecb4b301ae1ad98b652068c3f9228614135386ded22fe36cebf" } ] } From 70bd0ecd9f353539d1622fece7d4557ad40c7a59 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 29 Oct 2026 23:56:56 +0000 Subject: [PATCH 105/136] test(gateway): prove disclosure entry ordering and zero-byte refusal --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-disclosure-entry-order-file.json | 206 ++++++ ...ative-disclosure-entry-order-postgres.json | 206 ++++++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 23 + docs/plans/0074-implementation-status.md | 50 +- .../0009-bound-effect-and-recovery.md | 8 + .../auths-gateway/semantic-closure.json | 2 +- .../src/native_disclosure_entry_tests.rs | 615 ++++++++++++++++++ .../src/native_information_replay_tests.rs | 3 + .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 13 files changed, 1125 insertions(+), 16 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-entry-order-file.json create mode 100644 bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 2677e20fb..82fb46308 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -82,6 +82,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::scope_tests::postgres_native_managed_scope_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::entry_tests::native_file_mutation_entry_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::entry_tests::postgres_native_mutation_entry_order_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::entry_tests::native_file_disclosure_entry_order_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::entry_tests::postgres_native_disclosure_entry_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-file.json b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json new file mode 100644 index 000000000..4d73446ff --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json @@ -0,0 +1,206 @@ +{ + "schema": "auths.native-disclosure-entry-order/1", + "adapter": "file", + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "revoke", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "configuration", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "configuration", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000004, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000004, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + } + ], + "scope": "native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", + "excluded": [ + "separate gateway/recipient OS processes in each worker", + "hostile OS containment", + "selected observer and threshold timing", + "installed language framing", + "whole-store rollback and power loss" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json new file mode 100644 index 000000000..12f826837 --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json @@ -0,0 +1,206 @@ +{ + "schema": "auths.native-disclosure-entry-order/1", + "adapter": "postgres", + "cases": [ + { + "scenario": "revoke", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "revoke", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "configuration", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "configuration", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "approval-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000004, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "approval-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "authority-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000004, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, + { + "scenario": "authority-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + } + ], + "scope": "native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", + "excluded": [ + "separate gateway/recipient OS processes in each worker", + "hostile OS containment", + "selected observer and threshold timing", + "installed language framing", + "whole-store rollback and power loss" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index adcb7c3b5..6f62a1ab7 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1679,6 +1679,8 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/native_scope_tests.rs#postgres_native_managed_scope_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_entry_tests.rs#native_file_mutation_entry_order_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_entry_tests.rs#postgres_native_mutation_entry_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs#native_file_disclosure_entry_order_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs#postgres_native_disclosure_entry_order_fixture_is_current", "product/runtime/auths-gateway/src/configuration.rs#file_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/configuration.rs#postgres_configuration_changes_fence_stale_hosts_and_retain_revocations", "product/runtime/auths-gateway/src/recipe/tests.rs#three_independent_recipes_compile_without_provider_code", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index a60afa4f1..2724057c5 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1283,3 +1283,26 @@ counts the custody lease that preceded the final fence; refusal does not undo it This extends the acquisition fence evidence using the same test-only scheduling helper and adds no production owner. Selected observer/threshold timing, disclosure races, installed languages and OS containment remain separate work. + +## Disclosure dependency order and wait-time validation + +The same eight order/time schedules now exercise separately approved native +disclosure from an actual HTTP acquisition. Independent worker/operator processes +order the actual adapter fence; gateway and recipient tasks inside the worker +use real same-UID Unix sockets. Recipient authentication completes before the +native final-grant pause. Withdrawal or expiry that wins retains a reservation +and produces no recipient content or ACK. A grant that wins yields exactly the +retained projection and an exact native recipient ACK. Historical replay after +reopen emits no authentication/content frames or new custody/provider calls. +Attempts and lifetime delivery/byte allocations remain retained on refusal. +An opaque same-process socket relay independently captures all gateway bytes. +After the native authentication challenge, refusal must produce zero wire bytes, +including partial frame prefixes; success must carry exactly one length-prefixed +content frame with the original bytes. The relay forwards bytes without changing +native decisions or authentication and provides no hostile-channel qualification. + +These file/TLS PostgreSQL histories establish native entry ordering, not hostile +recipient process containment, separate recipient OS processes within each worker, +selected observer/threshold timing or installed binding/UI coverage. Existing +native authority, approval, recipient authentication and journal owners remain +unchanged; the test scheduler constructs no grant or decision. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index b29d57c97..4fdce2179 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3170,6 +3170,50 @@ Semantic inventory construction advances freeze416 and only its reported changed identity160/public-SDK157/public-surface416 subjects. Formal translation closure remains a002; neither metadata construction nor translation reuse is fresh proof. +## Native disclosure entry-order checkpoint + +Sixteen additional histories cover eight schedules per file/TLS PostgreSQL: +connection revocation and shared configuration activation before versus after +the final native disclosure grant, plus eligible/expired independent approval and +native authority during actual writer-lock waits. An original native HTTP +acquisition records the exact private source. Separate worker and operator OS +processes race the maintained adapter fence; gateway/recipient tasks within the +worker use real same-UID Unix sockets and exact native recipient authentication. +The scheduling helper never constructs a grant, decision or journal bytes. + +If withdrawal or expiry wins, the original charged disclosure remains Reserved, +with no recipient content result or ACK. If the native grant wins, the recipient +receives exactly the retained projection and sends its native signed ACK. An +opaque same-process socket relay independently captures every gateway byte: after +the authentication challenge, refusal must produce zero bytes, including partial +frame prefixes, and success must contain exactly one length-prefixed original +content frame. The relay forwards bytes without changing native authentication or +decisions. This strengthens the zero-content assertion beyond the receiver's +complete-message result; it establishes no hostile-channel qualification. + +All schedules retain one lifetime delivery/byte allocation, original admission +time and exact signed input bytes. Eligible wait cases record the advanced grant +time. Release/replay performs zero credential leases or provider reads/writes; +the sole HTTP read is the original acquisition. After reopen, native history and +raw attempt bytes remain unchanged. Terminal replay emits no authentication or +content frames, sends no recipient ACK and recreates no permit/charge. Reserved +history inspection does not attempt continuation or create delivery authority. + +Required exact artifact constructors passed with one matched, nonignored test +each. The initial file/TLS PostgreSQL cases passed3.04s/4.24s; the strengthened +wire-capture constructors passed3.10s/4.28s. The workflow retains all prior34native +selectors and adds two for36explicit selectors. No production runtime/store +behavior changed in this batch. These are local constructor results, not +new-head hosted acceptance. Gateway and recipient are tasks in one worker, not +separate hostile OS processes. Complete selected observer/threshold/revocation +scopes, installed binding/UI, adverse durability, containment and formal/performance +obligations remain; A07/A12/A13 stay partial. AP070/AP073 are untouched. + +Native closure construction and rebuilt non-update verification passed. Semantic +metadata construction advances freeze417 and only reported changed identity161/ +public-SDK158/public-surface417 subjects. Formal translation closure remains a002; +this is not new hosted or formal qualification. + ## Phase gates | Phase | State | Outstanding gate | @@ -3194,13 +3238,13 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | | A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | -| A07 | Revoke between acquisition and disclosure | Partial / socket-file and real daemon process corpus / separate operator disable prevents recipient CLI delivery | Full revocation scopes and adapter races | +| A07 | Revoke between acquisition and disclosure | Partial / daemon corpus plus native file/TLS PostgreSQL worker/operator release races / withdrawal before final grant produces no post-authentication wire bytes or ACK, while grant-first records exact delivery/ACK | Complete revocation scopes and installed boundary races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient and full native file/TLS PostgreSQL crash corpora / fifty-six release histories include partial sends, both peers killed before ACK, caller loss after ACK commit, current-authority gates, late and repeated ACKs with conserved allocations/slots | Remaining I/O-error/ambiguous-commit races and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | -| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition and sixteen native mutation worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Full disclosure races and remaining mutation dependency scopes remain required | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, native acquisition evidence timing and native mutation independent proof/approval lock waits / eligible and expired controls executed on file/TLS PostgreSQL | Remaining mutation selected-observer/threshold, disclosure and installed/adverse evidence required | +| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus sixteen mutation and sixteen disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, native acquisition evidence timing and mutation/disclosure independent proof/approval lock waits / eligible and expired controls executed on file/TLS PostgreSQL | Remaining selected-observer/threshold, dependency scopes and installed/adverse evidence required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | | A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | | A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index e46870862..5cf06226d 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -902,3 +902,11 @@ grant persistence remain the existing production owners. Separate OS workers and operators order actual file/TLS PostgreSQL locks around revocation, configuration activation and independently expiring proof/approval intervals. This is additional vertical evidence, not a shared shipping abstraction or new lifecycle framework. + +Disclosure extends those eight order/time schedules through its own typed source, +recipient authentication and native ACK. The source is an actual bounded HTTP +acquisition. Zero content/ACK on final-grant refusal and exact authenticated +delivery on success are measured independently of provider responses. Same-UID +gateway/recipient tasks run within a worker process distinct from the operator. +This adds test-only evidence for the existing disclosure owner, while retaining +the distinct installed-language, selected-dependency and hostile-process gates. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 93341d352..3f414bf92 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"b976fd7cd38015ee92541a36cf65a536e85b983b91b1308ec9defa548109ad17"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"0ff952978fb0676b69d1133baf2e554b25af363a49aa897084e18981d3984e3e"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"2b88eb67decc7d480126192b6e004931687fe89caf9c1571db7da7b49709dc7d"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"ec9b0fcf071390938def3fc8130e9d516855b476a6e0da5e531436faed60d18d"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"0ff952978fb0676b69d1133baf2e554b25af363a49aa897084e18981d3984e3e"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"2b88eb67decc7d480126192b6e004931687fe89caf9c1571db7da7b49709dc7d"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs new file mode 100644 index 000000000..b8b253004 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs @@ -0,0 +1,615 @@ +//! Recipient authentication is not delivery permission. Actual adapter locks +//! order native disclosure grants against independent operator withdrawal/time. +use super::*; +use crate::native_dependency_tests::{ + EntryGate, Order, Peer, Scenario, connect, expect, listener, pending, send, +}; +use serde::{Deserialize, Serialize}; +use std::{ + io::Write as _, + net::{TcpListener, TcpStream}, + process::{Command, Stdio}, +}; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Race { + setup: Setup, + scenario: Scenario, + order: Order, + operator_port: u16, +} +impl Race { + fn key() -> crate::GatewayAttemptKey { + crate::GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &LogicalOperationId::parse(RELEASE).expect("operation"), + ) + .expect("key") + } + const fn enters(&self) -> bool { + matches!(self.order, Order::GrantFirst) + || matches!( + self.scenario, + Scenario::ApprovalValid | Scenario::AuthorityValid + ) + } + const fn change(&self) -> Change { + match self.scenario { + Scenario::ApprovalValid | Scenario::ApprovalExpired => Change::ApprovalExpiry, + Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, + Scenario::Revoke | Scenario::Configuration => Change::None, + _ => unreachable!(), + } + } + fn peer(&self, role: &str) -> Peer { + Peer( + Command::new(std::env::current_exe().expect("test executable")) + .args([ + "--exact", + "native_information_replay_tests::entry_tests::native_disclosure_entry_peer", + "--nocapture", + ]) + .env( + "AUTHS_AP074_DISCLOSURE_ENTRY_PEER", + self.setup.root.join("race.json"), + ) + .env("AUTHS_AP074_DISCLOSURE_ENTRY_ROLE", role) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + .expect("independent peer"), + ) + } + fn inputs(&self) -> Vec> { + ["release-proof", "release-action", "release-approval"] + .map(|name| std::fs::read(self.setup.root.join(name)).expect("original signed input")) + .to_vec() + } + fn policy(&self) -> UnixDisclosurePolicy { + let uid = std::fs::metadata(&self.setup.root).expect("owner").uid(); + UnixDisclosurePolicy::new(uid, uid, [51; 32]) + } + async fn target(&self, engine: &GatewayEngine) -> crate::effect::DisclosureTarget { + engine + .disclosure_target( + SOURCE, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + self.policy().commitment().expect("channel"), + [52; 32], + ) + .await + .expect("retained source") + } +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + snapshot: crate::DisclosureSnapshot, + recipient_bytes: u64, + recipient_ack_sent: bool, + content_wire_bytes: u64, + witness: crate::GatewayExecutionWitness, +} + +async fn proxy(gateway: UnixStream, recipient: UnixStream) -> u64 { + use tokio::io::AsyncWriteExt as _; + let (mut from_gateway, mut to_gateway) = gateway.into_split(); + let (mut from_recipient, mut to_recipient) = recipient.into_split(); + let outbound = async { + let mut captured = Vec::new(); + let mut buffer = [0; 1024]; + loop { + let count = from_gateway.read(&mut buffer).await.expect("proxy read"); + if count == 0 { + break; + } + assert!( + captured.len() + count <= 16_384, + "bounded local wire capture" + ); + captured.extend_from_slice(&buffer[..count]); + to_recipient + .write_all(&buffer[..count]) + .await + .expect("opaque forwarding"); + } + to_recipient.shutdown().await.expect("forward EOF"); + // The first native frame is the authenticated challenge. Independently + // inspect every following wire byte, including partial length prefixes. + let length = u32::from_be_bytes( + captured + .get(..4) + .expect("native challenge prefix") + .try_into() + .expect("four bytes"), + ) as usize; + let following = captured + .get(4 + length..) + .expect("complete native challenge"); + if !following.is_empty() { + assert_eq!(following.len(), 4 + CONTENT.len()); + assert_eq!( + &following[..4], + &u32::try_from(CONTENT.len()) + .expect("bounded content") + .to_be_bytes() + ); + assert_eq!(&following[4..], CONTENT); + } + following.len() as u64 + }; + let inbound = async { + tokio::io::copy(&mut from_recipient, &mut to_gateway) + .await + .expect("opaque recipient forwarding"); + to_gateway.shutdown().await.expect("forward recipient EOF"); + }; + let (bytes, ()) = tokio::join!(outbound, inbound); + bytes +} + +async fn receive( + client: UnixStream, + policy: UnixDisclosurePolicy, + binding: &crate::effect::EffectBinding, + recipient: &SigningKey, +) -> (u64, bool) { + let received = crate::disclosure_transport::receive_disclosure( + crate::disclosure_transport::DisclosureConnection::new(client, policy), + binding, + CONTENT.len() as u64, + recipient, + ) + .await; + match received { + Ok(received) => { + assert_eq!(received.content(), CONTENT); + let count = received.content().len() as u64; + received + .acknowledge(recipient) + .await + .expect("native exact ACK"); + (count, true) + } + Err(code) => { + assert_eq!( + code, "gateway.disclosure.read", + "only pre-content EOF is expected" + ); + (0, false) + } + } +} + +fn worker(race: &Race, store: &TestAttempts) { + let clock = Arc::new(FixedClock::at(NOW)); + let gate = Arc::new(EntryGate::new( + store.raw(), + race.order, + race.setup.barrier_port, + clock.clone(), + Race::key(), + )); + let attempts = GatewayAttempts::new( + gate.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &race.setup, + "release-worker", + attempts, + controls(clock, 29), + )); + let inputs = race.inputs(); + let result = runtime.block_on(async { + let target = race.target(&engine).await; + let effect = engine + .compile_disclosure_effect(&target, &inputs[0], &inputs[1]) + .await + .expect("current release effect"); + let recipient = SigningKey::from_bytes(&[47; 32]); + let (server, gateway_proxy) = UnixStream::pair().expect("gateway channel"); + let (recipient_proxy, client) = UnixStream::pair().expect("recipient channel"); + let (snapshot, (recipient_bytes, recipient_ack_sent), content_wire_bytes) = tokio::join!( + engine.disclose( + &target, + &inputs[0], + &inputs[1], + serde_json::from_slice(&inputs[2]).expect("approval"), + crate::disclosure_transport::DisclosureConnection::new(server, race.policy()) + ), + receive(client, race.policy(), effect.binding(), &recipient), + proxy(gateway_proxy, recipient_proxy), + ); + WorkerResult { + snapshot: snapshot.expect("retained native disclosure facts"), + recipient_bytes, + recipient_ack_sent, + content_wire_bytes, + witness: engine.execution_witness(), + } + }); + assert!( + gate.reached(), + "worker must reach final native disclosure fence" + ); + crate::native_process_tests::private( + &race.setup.root.join("worker-result"), + &serde_json::to_vec(&result).expect("result"), + ); +} + +fn operator(race: &Race, store: &TestAttempts) { + let runtime = runtime(); + let candidate_controls = controls( + Arc::new(FixedClock::at(NOW)), + if matches!(race.scenario, Scenario::Configuration) { + 30 + } else { + 29 + }, + ); + let attempts = GatewayAttempts::new(store.raw(), candidate_controls.policy.clone()) + .expect("candidate policy"); + let (engine, record) = runtime.block_on(load_controlled_engine( + &race.setup, + "release-operator", + attempts, + candidate_controls, + )); + let shared = SharedConnection::new( + store.raw(), + record.provider_kind().clone(), + record.alias().clone(), + ); + let current = runtime + .block_on(shared.load()) + .expect("load") + .expect("connection"); + let reviewed = engine + .effect_configuration_revision() + .expect("operator review"); + let mut channel = connect(race.operator_port); + send(&mut channel, b'S'); + expect(&mut channel, b'G'); + match race.order { + Order::LockWait => { + let key = crate::connection::connection_key(record.provider_kind(), record.alias()); + store + .raw() + .fenced_replace(&[(GatewayRecordKind::Connection, key)], &mut |rows| { + send(&mut channel, b'H'); + expect(&mut channel, b'G'); + Ok(rows[0].clone().expect("actual connection bytes")) + }) + .expect("actual held writer fence"); + } + _ => match race.scenario { + Scenario::Revoke => { + let revoked = current + .record() + .transition_state(auths_connections::ConnectionState::Revoked, NOW) + .expect("native revocation"); + runtime + .block_on(shared.replace(¤t, &revoked)) + .expect("operator CAS"); + } + Scenario::Configuration => { + engine + .activate_effect_configuration(reviewed) + .expect("operator activation"); + } + _ => unreachable!(), + }, + } + crate::native_process_tests::private(&race.setup.root.join("operator-result"), b"committed"); + send(&mut channel, b'D'); +} + +#[test] +fn native_disclosure_entry_peer() { + let Some(path) = std::env::var_os("AUTHS_AP074_DISCLOSURE_ENTRY_PEER") else { + return; + }; + let race: Race = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach(Backend::parse(&race.setup.backend), &race.setup.location); + match std::env::var("AUTHS_AP074_DISCLOSURE_ENTRY_ROLE") + .expect("role") + .as_str() + { + "worker" => worker(&race, &store), + "operator" => operator(&race, &store), + _ => panic!("unsupported test role"), + } +} + +struct Case { + fixture: Fixture, + race: Race, + worker_listener: TcpListener, + operator_listener: TcpListener, + input: Input, + target: crate::effect::DisclosureTarget, + signed_inputs: Vec>, +} +impl Case { + fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { + let fixture = Fixture::new(backend); + let worker_listener = listener(); + let operator_listener = listener(); + let setup = Setup { + backend: backend.label().to_owned(), + location: fixture.store.location(), + root: fixture.setup.root.clone(), + provider_port: fixture.provider.port, + barrier_port: worker_listener.local_addr().expect("port").port(), + }; + let race = Race { + setup, + scenario, + order, + operator_port: operator_listener.local_addr().expect("port").port(), + }; + let source = fixture + .runtime + .block_on(Input::content(&fixture.engine, Change::None)); + fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &source.proof, + &source.action, + source.approval, + )) + .expect("actual original HTTP acquisition"); + let target = fixture.runtime.block_on(race.target(&fixture.engine)); + let input = + fixture + .runtime + .block_on(Input::disclosure(&fixture.engine, &target, race.change())); + let signed_inputs = vec![ + input.proof.clone(), + input.action.clone(), + serde_json::to_vec(&input.approval).expect("approval"), + ]; + for (name, bytes) in ["release-proof", "release-action", "release-approval"] + .iter() + .zip(&signed_inputs) + { + crate::native_process_tests::private(&race.setup.root.join(name), bytes); + } + crate::native_process_tests::private( + &race.setup.root.join("race.json"), + &serde_json::to_vec(&race).expect("setup"), + ); + Self { + fixture, + race, + worker_listener, + operator_listener, + input, + target, + signed_inputs, + } + } + fn schedule( + &self, + operator: &mut Peer, + worker: &mut Peer, + op: &mut TcpStream, + run: &mut TcpStream, + ) { + assert_eq!(self.fixture.provider.calls.load(Ordering::SeqCst), 1); + match self.race.order { + Order::ChangeFirst => { + send(op, b'G'); + expect(op, b'D'); + operator.finish(); + send(run, b'G'); + } + Order::GrantFirst => { + send(op, b'G'); + pending(op); + assert!(!self.race.setup.root.join("operator-result").exists()); + send(run, b'G'); + expect(op, b'D'); + operator.finish(); + } + Order::LockWait => { + send(op, b'G'); + expect(op, b'H'); + send(run, b'G'); + expect(run, b'W'); + run.write_all(&(NOW + self.race.scenario.time_shift()).to_be_bytes()) + .expect("clock advance"); + expect(run, b'A'); + pending(run); + assert_eq!(self.fixture.provider.calls.load(Ordering::SeqCst), 1); + send(op, b'G'); + expect(op, b'D'); + operator.finish(); + expect(run, b'D'); + } + } + worker.finish(); + } + fn execute(&self) -> WorkerResult { + let mut operator = self.race.peer("operator"); + let mut op = operator.accept(&self.operator_listener); + expect(&mut op, b'S'); + let mut worker = self.race.peer("worker"); + assert_ne!(worker.0.id(), operator.0.id()); + assert_ne!(worker.0.id(), std::process::id()); + let mut run = worker.accept(&self.worker_listener); + expect(&mut run, b'P'); + self.schedule(&mut operator, &mut worker, &mut op, &mut run); + serde_json::from_slice( + &std::fs::read(self.race.setup.root.join("worker-result")).expect("result"), + ) + .expect("native result") + } + fn verify(&self, result: &WorkerResult) -> Value { + assert_eq!(self.race.inputs(), self.signed_inputs); + assert_eq!( + result.snapshot.stage, + if self.race.enters() { + crate::DisclosureStage::Acknowledged + } else { + crate::DisclosureStage::Reserved + } + ); + assert_eq!( + result.recipient_bytes, + if self.race.enters() { + CONTENT.len() as u64 + } else { + 0 + } + ); + assert_eq!(result.recipient_ack_sent, self.race.enters()); + assert_eq!( + result.content_wire_bytes, + if self.race.enters() { + (CONTENT.len() + 4) as u64 + } else { + 0 + } + ); + assert_eq!( + ( + result.snapshot.reserved_deliveries, + result.snapshot.reserved_bytes + ), + (1, CONTENT.len() as u64) + ); + assert_eq!(result.witness.credential_lease_calls, 0); + assert_eq!(result.witness.write_transport_entries, 0); + assert_eq!(result.witness.read_transport_entries, 0); + assert_eq!(self.fixture.provider.calls.load(Ordering::SeqCst), 1); + let rows = self.fixture.records(); + assert_eq!(rows.len(), 2); + let record: Value = serde_json::from_slice( + &self + .fixture + .store + .raw() + .load(GatewayRecordKind::Attempt, &Race::key()) + .expect("load") + .expect("release"), + ) + .expect("record"); + assert_eq!(record["evaluated_at"], NOW); + assert_eq!(record["state"]["facts"]["allocation"], 0); + assert_eq!(!record["entry"].is_null(), self.race.enters()); + if self.race.enters() && matches!(self.race.order, Order::LockWait) { + assert_eq!( + record["entry"]["granted_at"], + NOW + self.race.scenario.time_shift() + ); + } + self.reopen(&result.snapshot); + assert_eq!(self.fixture.records(), rows); + json!({"scenario":self.race.scenario,"order":self.race.order,"native_snapshot":result.snapshot, + "separate_worker_operator_processes":true,"signed_inputs_unchanged":true,"original_admission_time":NOW, + "clock_after_wait":matches!(self.race.order,Order::LockWait).then(||NOW+self.race.scenario.time_shift()), + "recipient_bytes":result.recipient_bytes,"native_recipient_ack_sent":result.recipient_ack_sent, + "captured_wire_bytes_after_authentication_challenge":result.content_wire_bytes, + "provider_reads":1,"additional_provider_reads":0,"credential_leases_at_release":0, + "reopened_journal_unchanged":true,"historical_replay_sends_nothing":self.race.enters()}) + } + fn reopen(&self, snapshot: &crate::DisclosureSnapshot) { + let (engine, _) = self.fixture.runtime.block_on(load_controlled_engine( + &self.race.setup, + "release-reopened", + self.fixture.store.reopen(), + controls( + Arc::new(FixedClock::at(NOW + self.race.scenario.time_shift())), + 29, + ), + )); + match self + .fixture + .runtime + .block_on(engine.content_history(RELEASE)) + .expect("native history") + { + crate::ContentHistory::Disclosure(actual) => assert_eq!(&actual, snapshot), + crate::ContentHistory::Acquisition(_) => panic!("wrong protocol"), + } + if !self.race.enters() { + return; + } + let before = engine.execution_witness(); + self.fixture.runtime.block_on(async { + let (server, mut client) = UnixStream::pair().expect("replay channel"); + let reader = async { + let mut bytes = Vec::new(); + client.read_to_end(&mut bytes).await.expect("EOF"); + assert!(bytes.is_empty()); + }; + let (actual, ()) = tokio::join!( + engine.disclose( + &self.target, + &self.input.proof, + &self.input.action, + self.input.approval.clone(), + crate::disclosure_transport::DisclosureConnection::new( + server, + self.race.policy() + ) + ), + reader + ); + assert_eq!(&actual.expect("historical native replay"), snapshot); + }); + assert_eq!(engine.execution_witness(), before); + } +} + +fn matrix(backend: Backend) { + let schedules = [ + (Scenario::Revoke, Order::ChangeFirst), + (Scenario::Revoke, Order::GrantFirst), + (Scenario::Configuration, Order::ChangeFirst), + (Scenario::Configuration, Order::GrantFirst), + (Scenario::ApprovalValid, Order::LockWait), + (Scenario::ApprovalExpired, Order::LockWait), + (Scenario::AuthorityValid, Order::LockWait), + (Scenario::AuthorityExpired, Order::LockWait), + ]; + let cases: Vec<_> = schedules + .into_iter() + .map(|(scenario, order)| { + let case = Case::new(backend, scenario, order); + let result = case.execute(); + case.verify(&result) + }) + .collect(); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-entry-order/1","adapter":backend.label(),"cases":cases, + "scope":"native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", + "excluded":["separate gateway/recipient OS processes in each worker","hostile OS containment","selected observer and threshold timing","installed language framing","whole-store rollback and power loss"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-disclosure-entry-order-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} +#[test] +fn native_file_disclosure_entry_order_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_disclosure_entry_order_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index e01a96609..5543f576b 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -35,6 +35,9 @@ mod epoch_tests; #[path = "native_scope_tests.rs"] mod scope_tests; +#[path = "native_disclosure_entry_tests.rs"] +mod entry_tests; + #[derive(Clone, Copy, Debug)] enum Protocol { Acquisition, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 6de89c3af..c48cbb98a 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9583463d07c03447cc6123cadcd5b9e97c085c2c60a107178a5fb71a014680f5"; + "0834d52072a641984396e31ef1cad613980a254c3604d5fe29914354b0cefe5d"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 1e08eb4ab..18d4a08df 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 416 +freeze_version = 417 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 416 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 160 +"auths.identity.protocol" = 161 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 416 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 157 +"auths.product.public-sdk-contract" = 158 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 416 +"auths.release.public-surface" = 417 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 709e42726..b70acf27e 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 416, + "freezeVersion": 417, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 160, + "version": 161, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "cccaec257b1db0e4bc97b6483be5a54dd619b0e302b6c1b98c80474d50bb711c" + "sha256": "3285212cd5ca9f46bf4622984915e6376b1f38d68b45b2d1d7d65b3cebc0dd2c" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 157, + "version": 158, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "ebeee92d79d13ea07b17887082798e1dcad62cf67a06a9d241109712ff28cae8" + "sha256": "0d296e8d1302b1350b495a9393db7d54b822d7f9c85cca481bdd634d7f4fc1b8" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 416, + "version": 417, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "1aedf803fddc5ecb4b301ae1ad98b652068c3f9228614135386ded22fe36cebf" + "sha256": "e8ffded4f694a346175605f38c2ce40d3febcf2a69137d6311dc521f50b31231" } ] } From 0957021a3db0b20c5359762990d1cc74a8509a6a Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 00:06:30 +0000 Subject: [PATCH 106/136] test(gateway): cover selected evidence changes at mutation and release entry --- .../native-disclosure-entry-order-file.json | 162 +++++++++++++++++- ...ative-disclosure-entry-order-postgres.json | 162 +++++++++++++++++- .../native-mutation-entry-order-file.json | 130 +++++++++++++- .../native-mutation-entry-order-postgres.json | 130 +++++++++++++- ...017-bound-effect-and-recovery-ownership.md | 22 +++ docs/plans/0074-implementation-status.md | 52 +++++- .../0009-bound-effect-and-recovery.md | 9 + ...ound-effects-and-recovery-state-machine.md | 20 ++- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_disclosure_entry_tests.rs | 91 +++++++++- .../src/native_mutation_entry_tests.rs | 87 +++++++++- .../src/native_mutation_replay_tests.rs | 10 +- .../src/native_threshold_testkit.rs | 6 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 4 +- release/semantic-freeze.json | 6 +- 16 files changed, 857 insertions(+), 38 deletions(-) diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-file.json b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json index 4d73446ff..3c8f95714 100644 --- a/bindings/fixtures/gateway/native-disclosure-entry-order-file.json +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json @@ -193,13 +193,173 @@ "credential_leases_at_release": 0, "reopened_journal_unchanged": true, "historical_replay_sends_nothing": false + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000005, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true, + "old_approval_accepts_current_effect": false + } + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000005, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + } } ], "scope": "native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", "excluded": [ "separate gateway/recipient OS processes in each worker", "hostile OS containment", - "selected observer and threshold timing", + "all selected-authority and revocation scopes", "installed language framing", "whole-store rollback and power loss" ] diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json index 12f826837..f6b3d6d51 100644 --- a/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json @@ -193,13 +193,173 @@ "credential_leases_at_release": 0, "reopened_journal_unchanged": true, "historical_replay_sends_nothing": false + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000005, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true, + "old_approval_accepts_current_effect": false + } + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000005, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": 1790000006, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + } } ], "scope": "native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", "excluded": [ "separate gateway/recipient OS processes in each worker", "hostile OS containment", - "selected observer and threshold timing", + "all selected-authority and revocation scopes", "installed language framing", "whole-store rollback and power loss" ] diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-file.json b/bindings/fixtures/gateway/native-mutation-entry-order-file.json index 664b6d914..208ef7e7b 100644 --- a/bindings/fixtures/gateway/native-mutation-entry-order-file.json +++ b/bindings/fixtures/gateway/native-mutation-entry-order-file.json @@ -129,12 +129,140 @@ "actual_provider_writes": 0, "reopened_history_unchanged": true, "historical_replay_performs_no_io": false + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true, + "old_approval_accepts_current_effect": false + } + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + } } ], "scope": "actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", "excluded": [ "disclosure races", - "selected observer and threshold expiry", + "all selected-authority and revocation scopes", "installed language framing", "hostile OS containment", "whole-store rollback and power loss" diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json index cf9d42f9a..e3b3ffd49 100644 --- a/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json +++ b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json @@ -129,12 +129,140 @@ "actual_provider_writes": 0, "reopened_history_unchanged": true, "historical_replay_performs_no_io": false + }, + { + "scenario": "observer-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "observer-expired", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false, + "selected_native_evidence": { + "threshold": false, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": false, + "signed_inputs_reused": true, + "old_approval_accepts_current_effect": false + } + }, + { + "scenario": "threshold-valid", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000005, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000005, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": false, + "old_approval_accepts_current_effect": true + } + }, + { + "scenario": "threshold-changed", + "order": "lock-wait", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": 1790000006, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false, + "selected_native_evidence": { + "threshold": true, + "observed_at": 1790000000, + "short_maximum_age_seconds": 5, + "evaluation_after_wait": 1790000006, + "authorized_before_wait": true, + "authorized_after_wait": true, + "signed_inputs_reused": true, + "selected_branches_before": [ + "4040404040404040404040404040404040404040404040404040404040404040", + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "selected_branches_after": [ + "4141414141414141414141414141414141414141414141414141414141414141" + ], + "authority_commitment_changed": true, + "old_approval_accepts_current_effect": false + } } ], "scope": "actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", "excluded": [ "disclosure races", - "selected observer and threshold expiry", + "all selected-authority and revocation scopes", "installed language framing", "hostile OS containment", "whole-store rollback and power loss" diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 2724057c5..e61b6a796 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1306,3 +1306,25 @@ recipient process containment, separate recipient OS processes within each worke selected observer/threshold timing or installed binding/UI coverage. Existing native authority, approval, recipient authentication and journal owners remain unchanged; the test scheduler constructs no grant or decision. + +## Selected observation and threshold parity at native entry + +Mutation and disclosure each extend their entry-order matrix with the existing +native acquisition observation/threshold controls. At the inclusive five-second +freshness boundary, a single signed observation and a genuine 1-of-2 proof retain +the approved native selection. At six seconds the observation-only proof is stale; +the threshold proof remains Authorized through its long-lived branch, while the +native selected-authority commitment changes. Fresh native compilation establishes +that only the bound authority changes, and the old approval's own signature/time +remains valid for the original effect. It cannot authorize the new effect. + +Actual worker/operator lock waits re-run that native check at the final grant. +Refusal retains original reservations and sends no mutation request or disclosure +content/ACK. Positive controls perform the exact separately reviewed request or +recipient delivery. Changing a mutation's signed proof also changes its declared +provider echo, so the expected captured body comes from that proof's own native +bound request. No approval, request body, input timestamp or grant is synthesized +by the scheduling helper. The fixtures use explicitly public test observer keys +and signed observation attachments; they do not qualify live-provider evidence. +Installed language/UI parity, other authority/revocation scopes and hostile OS +containment remain separate obligations. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 4fdce2179..91de5d467 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3214,6 +3214,52 @@ metadata construction advances freeze417 and only reported changed identity161/ public-SDK158/public-surface417 subjects. Formal translation closure remains a002; this is not new hosted or formal qualification. +## Native selected-evidence parity checkpoint + +The mutation and disclosure entry matrices each add four schedules per adapter: +single-observer and genuine 1-of-2 threshold controls at the inclusive five-second +freshness boundary and one second beyond. Each typed matrix now contains twelve +histories per adapter, preserving the eight earlier order/expiry schedules. This +adds sixteen histories and brings the mutation/disclosure entry corpus to 48. +The existing acquisition authoring/selection/binding test helpers are reused +through test-module visibility; no shipping semantic owner or decoder changes. + +The full ordinary native verifier establishes each proof's authority before and +after the future wait. At five seconds, the signed observation and both threshold +branches remain eligible, the exact effect stays unchanged, and actual native +entry succeeds. At six seconds, single-observer authority is stale. The threshold +proof remains Authorized through the longer-lived branch, but its selected +authority commitment changes. Fresh gateway compilation is still successful; +the canonical binding differs only in native authority. The original approval's +signature and time remain valid for its original binding, yet cannot approve that +changed effect. Original proof/action/observation/approval bytes are never renewed. + +Actual independent worker/operator OS-process lock waits reproduce that final +grant check on file and TLS PostgreSQL. Refused mutation retains its reservation +and sends zero HTTP requests; positive mutation sends its own exact native bound +request. A newly signed proof changes the recipe's declared provider echo, so its +expected captured body is taken from that proof's native request rather than +reusing another proof's body. Refused disclosure retains its lifetime allocation +and sends zero bytes after the authentication challenge, independently checked by +the opaque relay, with no recipient ACK. Positive disclosure gets the exact +retained bytes and native ACK. Native history/replay conserves the existing facts +and creates no new transport, credential lease or allocation. + +Required constructors passed with one matched, nonignored test each: mutation +file2.90s/TLS PostgreSQL4.79s and disclosure file4.75s/TLS PostgreSQL6.54s. The same +36 explicit workflow selectors remain; four of them now cover the expanded +matrices. These are local constructor results, not new-head hosted qualification. +The observation attachments use public fixture observer keys, not live-provider +attestation. All selected-authority/revocation scopes, installed language/UI and +hostile-process/adverse durability obligations remain distinct. A13/A14 stay +partial. AP070 and paused AP073 remain untouched; CI belongs to the subagent. + +Native closure construction and rebuilt non-update verification passed. Semantic +inventory construction advances freeze418 and only its reported public-surface418 +subject; identity161/public-SDK158 and the other counters remain unchanged. Formal +translation closure remains a002. These construction results are not new hosted +or formal qualification. + ## Phase gates | Phase | State | Outstanding gate | @@ -3243,9 +3289,9 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | -| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus sixteen mutation and sixteen disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age, native acquisition evidence timing and mutation/disclosure independent proof/approval lock waits / eligible and expired controls executed on file/TLS PostgreSQL | Remaining selected-observer/threshold, dependency scopes and installed/adverse evidence required | -| A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls / four file/TLS PostgreSQL histories execute unchanged/changed selection; proof remains Authorized but changed authority invalidates the old still-current exact approval before grant | Complete installed language/UI and mutation/disclosure parity remain required | +| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus 24 mutation and 24 disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | +| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native acquisition/mutation/disclosure proof/approval/observer/threshold lock waits / eligible and expired controls executed on file/TLS PostgreSQL, with zero post-authentication disclosure wire bytes on refusal | Remaining dependency/revocation scopes and installed/adverse evidence required | +| A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls across all three protocols / 12 file/TLS PostgreSQL threshold histories preserve Authorized proof while changed selected authority invalidates the old still-current exact approval | Complete installed language/UI and remaining selected-authority/adverse boundaries required | | A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | | A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index 5cf06226d..ba3ea7148 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -910,3 +910,12 @@ delivery on success are measured independently of provider responses. Same-UID gateway/recipient tasks run within a worker process distinct from the operator. This adds test-only evidence for the existing disclosure owner, while retaining the distinct installed-language, selected-dependency and hostile-process gates. + +Selected observation and threshold controls now reuse the acquisition testkit's +native signed authoring and before/after binding assertions for mutation and +disclosure. Only test-module visibility changes; no shipping abstraction or +semantics are extracted. Full native verification, exact-effect comparison and +the existing final entry fence establish parity when a 1-of-2 proof remains +Authorized but its selected evidence changes. Native mutation request echoes +remain bound to the newly signed proof. All earlier order/expiry schedules are +preserved, including independent wire-byte capture for refused disclosure. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 92effc020..58eea006b 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -741,9 +741,23 @@ action, observation and approval bytes and admission time remain unchanged; valid entry records the time after waiting. The schedule occurs after initially authorized admission and a custody lease; the final refusal prevents any HTTP entry and does not claim to undo that prior lease. These cases establish native -acquisition ordering under the stated test deployment. Complete mutation/ -disclosure dependency races and installed language/human UI evidence remain -separate requirements. +acquisition ordering under the stated test deployment. + +`native-mutation-entry-order-{file,postgres}.json` and +`native-disclosure-entry-order-{file,postgres}.json` extend the same schedules to +the typed native mutation and disclosure owners, with twelve histories per +protocol/adapter. Both preserve original admission and signed input bytes across +real independent worker/operator lock waits. Changed selected authority cannot +reuse the old exact approval even while the threshold proof remains Authorized. +Mutation captures the exact request compiled for its own signed proof, including +its declared echo. Disclosure separately authenticates a native recipient and +records an exact ACK only after a grant. An opaque socket relay inspects every +gateway byte after the authentication challenge: final-grant refusal produces +zero subsequent wire bytes, including incomplete frame prefixes. Gateway and +recipient are same-UID tasks within the worker, not hostile OS peers. The signed +observation fixtures use public test observer keys and do not qualify live-provider +evidence. Complete dependency/revocation scopes and installed language/human UI, +adverse durability and containment evidence remain separate requirements. `native-independent-recovery-{file,postgres}.json` exercises four outcomes per adapter using separate native writer and recovery-reader OS processes. A real diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 3f414bf92..779fdecf2 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"ec9b0fcf071390938def3fc8130e9d516855b476a6e0da5e531436faed60d18d"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"0ff952978fb0676b69d1133baf2e554b25af363a49aa897084e18981d3984e3e"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"2b88eb67decc7d480126192b6e004931687fe89caf9c1571db7da7b49709dc7d"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"8f35ecd245f3147090f0f8011b06415671be29560a4c1c2fc779a05366dfef99"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs index b8b253004..e54fb1fdb 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs @@ -32,15 +32,22 @@ impl Race { matches!(self.order, Order::GrantFirst) || matches!( self.scenario, - Scenario::ApprovalValid | Scenario::AuthorityValid + Scenario::ApprovalValid + | Scenario::AuthorityValid + | Scenario::ObserverValid + | Scenario::ThresholdValid ) } const fn change(&self) -> Change { match self.scenario { Scenario::ApprovalValid | Scenario::ApprovalExpired => Change::ApprovalExpiry, Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, - Scenario::Revoke | Scenario::Configuration => Change::None, - _ => unreachable!(), + Scenario::Revoke + | Scenario::Configuration + | Scenario::ObserverValid + | Scenario::ObserverExpired + | Scenario::ThresholdValid + | Scenario::ThresholdChanged => Change::None, } } fn peer(&self, role: &str) -> Peer { @@ -338,6 +345,7 @@ struct Case { input: Input, target: crate::effect::DisclosureTarget, signed_inputs: Vec>, + evidence: Option, } impl Case { fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { @@ -369,10 +377,13 @@ impl Case { )) .expect("actual original HTTP acquisition"); let target = fixture.runtime.block_on(race.target(&fixture.engine)); - let input = + let mut input = fixture .runtime .block_on(Input::disclosure(&fixture.engine, &target, race.change())); + let evidence = fixture + .runtime + .block_on(selected_evidence(&fixture, &race, &target, &mut input)); let signed_inputs = vec![ input.proof.clone(), input.action.clone(), @@ -396,6 +407,7 @@ impl Case { input, target, signed_inputs, + evidence, } } fn schedule( @@ -515,13 +527,17 @@ impl Case { } self.reopen(&result.snapshot); assert_eq!(self.fixture.records(), rows); - json!({"scenario":self.race.scenario,"order":self.race.order,"native_snapshot":result.snapshot, + let mut summary = json!({"scenario":self.race.scenario,"order":self.race.order,"native_snapshot":result.snapshot, "separate_worker_operator_processes":true,"signed_inputs_unchanged":true,"original_admission_time":NOW, "clock_after_wait":matches!(self.race.order,Order::LockWait).then(||NOW+self.race.scenario.time_shift()), "recipient_bytes":result.recipient_bytes,"native_recipient_ack_sent":result.recipient_ack_sent, "captured_wire_bytes_after_authentication_challenge":result.content_wire_bytes, "provider_reads":1,"additional_provider_reads":0,"credential_leases_at_release":0, - "reopened_journal_unchanged":true,"historical_replay_sends_nothing":self.race.enters()}) + "reopened_journal_unchanged":true,"historical_replay_sends_nothing":self.race.enters()}); + if let Some(evidence) = &self.evidence { + summary["selected_native_evidence"] = evidence.clone(); + } + summary } fn reopen(&self, snapshot: &crate::DisclosureSnapshot) { let (engine, _) = self.fixture.runtime.block_on(load_controlled_engine( @@ -572,6 +588,63 @@ impl Case { } } +async fn selected_evidence( + fixture: &Fixture, + race: &Race, + target: &crate::effect::DisclosureTarget, + input: &mut Input, +) -> Option { + if !matches!( + race.scenario, + Scenario::ObserverValid + | Scenario::ObserverExpired + | Scenario::ThresholdValid + | Scenario::ThresholdChanged + ) { + return None; + } + use crate::observed_tests::threshold_testkit as kit; + let threshold = matches!( + race.scenario, + Scenario::ThresholdValid | Scenario::ThresholdChanged + ); + let after = NOW + race.scenario.time_shift(); + let call = target + .authorization_call( + &recipe(), + &LogicalOperationId::parse(RELEASE).expect("operation"), + ) + .expect("native release call"); + let signed = kit::signed(&call, threshold); + let mut witness = kit::selection_witness(&signed, threshold, after); + let first = fixture + .engine + .compile_disclosure_effect(target, &signed.proof, &signed.action) + .await + .expect("initial native disclosure"); + let exact = Input::approval(&first, Change::None); + let before = first.binding().clone(); + first + .approve( + exact.clone(), + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + after, + ) + .expect("original approval interval remains current after wait"); + fixture.clock.set(after); + let fresh = fixture + .engine + .compile_disclosure_effect(target, &signed.proof, &signed.action) + .await; + fixture.clock.set(NOW); + kit::verify_binding(&before, fresh, exact.clone(), threshold, after); + witness["old_approval_accepts_current_effect"] = json!(after <= NOW + 5); + input.proof = signed.proof; + input.action = signed.action; + input.approval = exact; + Some(witness) +} + fn matrix(backend: Backend) { let schedules = [ (Scenario::Revoke, Order::ChangeFirst), @@ -582,6 +655,10 @@ fn matrix(backend: Backend) { (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), (Scenario::AuthorityExpired, Order::LockWait), + (Scenario::ObserverValid, Order::LockWait), + (Scenario::ObserverExpired, Order::LockWait), + (Scenario::ThresholdValid, Order::LockWait), + (Scenario::ThresholdChanged, Order::LockWait), ]; let cases: Vec<_> = schedules .into_iter() @@ -593,7 +670,7 @@ fn matrix(backend: Backend) { .collect(); let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-entry-order/1","adapter":backend.label(),"cases":cases, "scope":"native separate release authority and exact approval, real local HTTP source acquisition, independent worker/operator OS processes, maintained adapter writer fence; gateway/recipient tasks in the worker over same-UID Unix sockets; fixed public keys and controlled maintained clock", - "excluded":["separate gateway/recipient OS processes in each worker","hostile OS containment","selected observer and threshold timing","installed language framing","whole-store rollback and power loss"]})).expect("artifact"); + "excluded":["separate gateway/recipient OS processes in each worker","hostile OS containment","all selected-authority and revocation scopes","installed language framing","whole-store rollback and power loss"]})).expect("artifact"); let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( "../../../bindings/fixtures/gateway/native-disclosure-entry-order-{}.json", backend.label() diff --git a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs index 21b5a892b..ccfdf2264 100644 --- a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs @@ -32,15 +32,22 @@ impl Race { matches!(self.order, Order::GrantFirst) || matches!( self.scenario, - Scenario::ApprovalValid | Scenario::AuthorityValid + Scenario::ApprovalValid + | Scenario::AuthorityValid + | Scenario::ObserverValid + | Scenario::ThresholdValid ) } const fn change(&self) -> Change { match self.scenario { Scenario::ApprovalValid | Scenario::ApprovalExpired => Change::ApprovalExpiry, Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, - Scenario::Revoke | Scenario::Configuration => Change::None, - _ => unreachable!(), + Scenario::Revoke + | Scenario::Configuration + | Scenario::ObserverValid + | Scenario::ObserverExpired + | Scenario::ThresholdValid + | Scenario::ThresholdChanged => Change::None, } } fn inputs(&self) -> Vec> { @@ -204,6 +211,7 @@ struct Case { provider: Provider, input: Input, signed_inputs: Vec>, + evidence: Option, } impl Case { fn new(backend: Backend, scenario: Scenario, order: Order) -> Self { @@ -227,11 +235,12 @@ impl Case { }, }; let runtime = runtime(); + let clock = Arc::new(FixedClock::at(NOW)); let (engine, record) = runtime.block_on(load_controlled_engine( &race.setup, "entry-parent", store.attempts().clone(), - controls(Arc::new(FixedClock::at(NOW)), 29), + controls(clock.clone(), 29), )); let shared = SharedConnection::new( store.raw(), @@ -244,7 +253,8 @@ impl Case { engine .initialize_effect_configuration() .expect("configuration"); - let input = runtime.block_on(Input::author(&engine, race.change())); + let mut input = runtime.block_on(Input::author(&engine, race.change())); + let evidence = runtime.block_on(selected_evidence(&engine, &clock, &race, &mut input)); let signed_inputs = vec![ input.proof.clone(), input.action.clone(), @@ -266,6 +276,7 @@ impl Case { provider, input, signed_inputs, + evidence, } } fn schedule( @@ -367,12 +378,16 @@ impl Case { ); } self.reopen(result, &bytes); - json!({"scenario":self.race.scenario, "order":self.race.order, + let mut result = json!({"scenario":self.race.scenario, "order":self.race.order, "separate_worker_and_operator_processes":true, "signed_inputs_unchanged":true, "native_result":result, "admission_time":NOW, "clock_after_wait":matches!(self.race.order, Order::LockWait).then(|| NOW+self.race.scenario.time_shift()), "actual_credential_leases":1, "actual_provider_writes":u64::from(self.race.enters()), - "reopened_history_unchanged":true, "historical_replay_performs_no_io":self.race.enters()}) + "reopened_history_unchanged":true, "historical_replay_performs_no_io":self.race.enters()}); + if let Some(evidence) = &self.evidence { + result["selected_native_evidence"] = evidence.clone(); + } + result } fn reopen(&self, result: &GatewaySubmitResult, bytes: &[u8]) { let runtime = runtime(); @@ -414,6 +429,58 @@ impl Case { } } +async fn selected_evidence( + engine: &GatewayEngine, + clock: &FixedClock, + race: &Race, + input: &mut Input, +) -> Option { + if !matches!( + race.scenario, + Scenario::ObserverValid + | Scenario::ObserverExpired + | Scenario::ThresholdValid + | Scenario::ThresholdChanged + ) { + return None; + } + use crate::observed_tests::threshold_testkit as kit; + let threshold = matches!( + race.scenario, + Scenario::ThresholdValid | Scenario::ThresholdChanged + ); + let after = NOW + race.scenario.time_shift(); + let signed = kit::signed(&Input::call(), threshold); + let mut witness = kit::selection_witness(&signed, threshold, after); + let first = engine + .compile_effect(&signed.proof, &signed.action) + .await + .expect("initial native effect"); + let exact = approval(&first, NOW + 300); + let before = first.binding().clone(); + input.body = first + .private_request() + .expect("new proof's exact request") + .body() + .to_vec(); + first + .approve( + exact.clone(), + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + after, + ) + .expect("original approval interval remains current after wait"); + clock.set(after); + let fresh = engine.compile_effect(&signed.proof, &signed.action).await; + clock.set(NOW); + kit::verify_binding(&before, fresh, exact.clone(), threshold, after); + witness["old_approval_accepts_current_effect"] = json!(after <= NOW + 5); + input.proof = signed.proof; + input.action = signed.action; + input.approval = exact; + Some(witness) +} + fn matrix(backend: Backend) { let schedules = [ (Scenario::Revoke, Order::ChangeFirst), @@ -424,6 +491,10 @@ fn matrix(backend: Backend) { (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), (Scenario::AuthorityExpired, Order::LockWait), + (Scenario::ObserverValid, Order::LockWait), + (Scenario::ObserverExpired, Order::LockWait), + (Scenario::ThresholdValid, Order::LockWait), + (Scenario::ThresholdChanged, Order::LockWait), ]; let cases: Vec<_> = schedules .into_iter() @@ -436,7 +507,7 @@ fn matrix(backend: Backend) { let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-entry-order/1", "adapter":backend.label(), "cases":cases, "scope":"actual native mutation, separate worker/operator OS processes, maintained durable writer fence, public fixture keys and controlled maintained test clock, counting local HTTP provider without deduplication", - "excluded":["disclosure races", "selected observer and threshold expiry", "installed language framing", "hostile OS containment", "whole-store rollback and power loss"]})).expect("artifact"); + "excluded":["disclosure races", "all selected-authority and revocation scopes", "installed language framing", "hostile OS containment", "whole-store rollback and power loss"]})).expect("artifact"); let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( "../../../bindings/fixtures/gateway/native-mutation-entry-order-{}.json", backend.label() diff --git a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs index 33893f232..48cb0956d 100644 --- a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs @@ -189,15 +189,19 @@ fn approval( request.with_signature(signature) } impl Input { - async fn author(engine: &GatewayEngine, change: Change) -> Self { + fn call() -> McpToolCall { let recipe = recipe(); let arguments = json!({"operator_namespace":recipe.namespace().as_str(),"recipe_digest":recipe.digest_hex(),"operation_id":OPERATION,"record_id":"recTEST0000000001","replacement":"Approved"}); - let call = McpToolCall::new( + McpToolCall::new( recipe.review().service(), recipe.review().tool(), arguments.as_object().expect("arguments").clone(), ) - .expect("call"); + .expect("call") + } + async fn author(engine: &GatewayEngine, change: Change) -> Self { + let recipe = recipe(); + let call = Self::call(); let signed = tool_fixture_until( &call, NOW, diff --git a/product/runtime/auths-gateway/src/native_threshold_testkit.rs b/product/runtime/auths-gateway/src/native_threshold_testkit.rs index b4ae03c00..be2232722 100644 --- a/product/runtime/auths-gateway/src/native_threshold_testkit.rs +++ b/product/runtime/auths-gateway/src/native_threshold_testkit.rs @@ -20,7 +20,7 @@ fn requirement(maximum_age: u32) -> ObservationRequirement { .expect("observation requirement") } -fn signed(call: &McpToolCall, threshold: bool) -> ToolFixture { +pub(crate) fn signed(call: &McpToolCall, threshold: bool) -> ToolFixture { let root = signer(h::ROOT_SEED); let actor = signer(0x22); let observer = signer(h::OBSERVER_SEED); @@ -111,7 +111,7 @@ fn signed(call: &McpToolCall, threshold: bool) -> ToolFixture { } } -fn selection_witness(signed: &ToolFixture, threshold: bool, after: u64) -> Value { +pub(crate) fn selection_witness(signed: &ToolFixture, threshold: bool, after: u64) -> Value { let context = auths_codec::decode_verifier_context(&signed.context).expect("context"); let before = crate::engine::verify_native(&context, NOW, &signed.proof, &signed.action) .expect("native authority before wait"); @@ -175,7 +175,7 @@ fn selection_witness(signed: &ToolFixture, threshold: bool, after: u64) -> Value witness } -fn verify_binding( +pub(crate) fn verify_binding( before: &crate::effect::EffectBinding, fresh: Result, approval: crate::effect::ExactEffectApproval, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index c48cbb98a..990d39bfe 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0834d52072a641984396e31ef1cad613980a254c3604d5fe29914354b0cefe5d"; + "d4f058591674f1c5f660647b596045347a964cd33b4b209fafaf6ccac03f5c75"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 18d4a08df..9d7ab109f 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 417 +freeze_version = 418 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -67,4 +67,4 @@ freeze_version = 417 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 417 +"auths.release.public-surface" = 418 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index b70acf27e..a6c3175e7 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 417, + "freezeVersion": 418, "publicSurface": { "rustRoots": [ "auths", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 417, + "version": 418, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "e8ffded4f694a346175605f38c2ce40d3febcf2a69137d6311dc521f50b31231" + "sha256": "4bbd2934e4373656a5d57d8b3ebf7d5d846560a6a6d7d0f17c8b69861ecd1201" } ] } From 7bf36befa80951584af5b6565d88c47abae26989 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 00:25:13 +0000 Subject: [PATCH 107/136] test(gateway): prove atomic mutation and disclosure admission batches --- .github/workflows/postgres-lifecycle.yml | 2 + ...ive-disclosure-postgres-partial-batch.json | 100 ++++++ ...ative-mutation-postgres-partial-batch.json | 60 ++++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 26 ++ docs/plans/0074-implementation-status.md | 53 ++- .../0009-bound-effect-and-recovery.md | 9 + ...ound-effects-and-recovery-state-machine.md | 17 +- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_disclosure_crash_tests.rs | 3 + .../src/native_disclosure_pg_batch_tests.rs | 319 ++++++++++++++++++ .../src/native_mutation_budget_tests.rs | 3 + .../src/native_mutation_pg_batch_tests.rs | 204 +++++++++++ .../src/native_postgres_fault_tests.rs | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- .../auths-gateway/src/store_testkit.rs | 9 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 18 files changed, 818 insertions(+), 17 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-postgres-partial-batch.json create mode 100644 bindings/fixtures/gateway/native-mutation-postgres-partial-batch.json create mode 100644 product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 82fb46308..70416655c 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -69,6 +69,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::window_capacity_tests::postgres_native_disclosure_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_batch_tests::postgres_native_mutation_partial_batch_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_batch_tests::postgres_native_disclosure_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::native_file_mutation_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current diff --git a/bindings/fixtures/gateway/native-disclosure-postgres-partial-batch.json b/bindings/fixtures/gateway/native-disclosure-postgres-partial-batch.json new file mode 100644 index 000000000..56bf70ac9 --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-postgres-partial-batch.json @@ -0,0 +1,100 @@ +{ + "schema": "auths.native-disclosure-postgres-partial-batch/1", + "scope": "actual native source HTTP acquisition, independent initialized failure worker, server-side insert exceptions and sequence witnesses over maintained TLS adapter; reopened gateway authenticates a separate native recipient OS process over same-UID Unix sockets and records its exact ACK; public fixture keys and maintained clock", + "excluded": [ + "ambiguous commit delivery", + "server/power failure", + "file I/O faults", + "hostile OS or live-provider qualification" + ], + "cases": [ + { + "server_rejected_insert": 1, + "prior_insert_prefix": 0, + "server_sequence": 1, + "all_release_attempt_allocation_count_and_byte_rows_rolled_back": true, + "source_attempt_and_allocations_unchanged": true, + "failed_worker_has_zero_custody_provider_or_wire_bytes": true, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "independent_native_recipient_received_exact_content_and_sent_ack": true, + "provider_source_reads": 1, + "additional_provider_reads": 0, + "one_release_allocation_count_and_sum_slot": true, + "terminal_replay_changes_no_rows_or_witness_and_sends_zero_bytes": true + }, + { + "server_rejected_insert": 2, + "prior_insert_prefix": 1, + "server_sequence": 2, + "all_release_attempt_allocation_count_and_byte_rows_rolled_back": true, + "source_attempt_and_allocations_unchanged": true, + "failed_worker_has_zero_custody_provider_or_wire_bytes": true, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "independent_native_recipient_received_exact_content_and_sent_ack": true, + "provider_source_reads": 1, + "additional_provider_reads": 0, + "one_release_allocation_count_and_sum_slot": true, + "terminal_replay_changes_no_rows_or_witness_and_sends_zero_bytes": true + }, + { + "server_rejected_insert": 3, + "prior_insert_prefix": 2, + "server_sequence": 3, + "all_release_attempt_allocation_count_and_byte_rows_rolled_back": true, + "source_attempt_and_allocations_unchanged": true, + "failed_worker_has_zero_custody_provider_or_wire_bytes": true, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "independent_native_recipient_received_exact_content_and_sent_ack": true, + "provider_source_reads": 1, + "additional_provider_reads": 0, + "one_release_allocation_count_and_sum_slot": true, + "terminal_replay_changes_no_rows_or_witness_and_sends_zero_bytes": true + }, + { + "server_rejected_insert": 4, + "prior_insert_prefix": 3, + "server_sequence": 4, + "all_release_attempt_allocation_count_and_byte_rows_rolled_back": true, + "source_attempt_and_allocations_unchanged": true, + "failed_worker_has_zero_custody_provider_or_wire_bytes": true, + "same_signed_inputs_reauthorized_after_reopen": true, + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "independent_native_recipient_received_exact_content_and_sent_ack": true, + "provider_source_reads": 1, + "additional_provider_reads": 0, + "one_release_allocation_count_and_sum_slot": true, + "terminal_replay_changes_no_rows_or_witness_and_sends_zero_bytes": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-postgres-partial-batch.json b/bindings/fixtures/gateway/native-mutation-postgres-partial-batch.json new file mode 100644 index 000000000..fd3548ea1 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-postgres-partial-batch.json @@ -0,0 +1,60 @@ +{ + "schema": "auths.native-mutation-postgres-partial-batch/1", + "scope": "full native plain Stripe mutation with real TLS adapter transactions, separate initialized worker processes, server-side row-prefix exceptions and nontransactional sequence witnesses; maintained clock/public fixture keys, actual counting HTTP provider without deduplication", + "excluded": [ + "ambiguous commit delivery", + "server or power failure", + "file I/O faults", + "hostile OS and live-provider qualification" + ], + "cases": [ + { + "server_rejected_insert": 1, + "prior_insert_prefix": 0, + "server_sequence": 1, + "failed_native_worker_has_no_custody_or_transport": true, + "all_attempt_count_and_amount_sum_rows_rolled_back": true, + "unchanged_signed_inputs_reauthorized_after_reopen": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "exact_native_body_captured": true, + "one_count_and_one_amount_sum_slot": true, + "replay_changes_no_rows_or_execution_witness": true + }, + { + "server_rejected_insert": 2, + "prior_insert_prefix": 1, + "server_sequence": 2, + "failed_native_worker_has_no_custody_or_transport": true, + "all_attempt_count_and_amount_sum_rows_rolled_back": true, + "unchanged_signed_inputs_reauthorized_after_reopen": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "exact_native_body_captured": true, + "one_count_and_one_amount_sum_slot": true, + "replay_changes_no_rows_or_execution_witness": true + }, + { + "server_rejected_insert": 3, + "prior_insert_prefix": 2, + "server_sequence": 3, + "failed_native_worker_has_no_custody_or_transport": true, + "all_attempt_count_and_amount_sum_rows_rolled_back": true, + "unchanged_signed_inputs_reauthorized_after_reopen": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "actual_provider_writes": 1, + "exact_native_body_captured": true, + "one_count_and_one_amount_sum_slot": true, + "replay_changes_no_rows_or_execution_witness": true + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 6f62a1ab7..fadeb54f8 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1833,6 +1833,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs#postgres_native_disclosure_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs#postgres_native_mutation_partial_batch_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs#postgres_native_disclosure_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_commit_tests.rs#postgres_native_commit_reply_loss_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#native_file_mutation_retained_replay_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#postgres_native_mutation_retained_replay_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index e61b6a796..334f25e16 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1328,3 +1328,29 @@ by the scheduling helper. The fixtures use explicitly public test observer keys and signed observation attachments; they do not qualify live-provider evidence. Installed language/UI parity, other authority/revocation scopes and hostile OS containment remain separate obligations. + +## Typed native admission rows roll back together + +Server-side insert exceptions now exercise every row position of the native +mutation and disclosure admission batches. A nontransactional sequence in each +owned fixture schema witnesses the actual rejected prefix; complete gateway-table +counts and raw slot lookups verify rollback before any credential or transport +entry. Mutation keeps its distinct attempt/count/amount-sum transaction. Disclosure +adds its separate source-lifetime allocation and byte units, while its original +acquisition and source charges remain byte-identical. No generic lifecycle or +alternative admission authority is introduced. + +The sequence witness checks `is_called` as well as `last_value`. A fresh sequence +can report its initial value before any insert; that state must never count as +evidence that the first native admission row reached the trigger. This stronger +oracle applies to the existing acquisition fixtures and both new typed matrices. + +Removing the owned test trigger permits explicit native reauthorization with +unchanged proof/action/approval. Mutation sends one exact compiled request; +disclosure authenticates a separately spawned native recipient over a real Unix +endpoint and records its exact ACK. Terminal replay changes no inspected rows or +execution witness and sends zero bytes. Failed release admission sends no native +authentication challenge either. These tests use the maintained TLS transaction +adapter and existing testkit setup/authoring, with no shipping fault branch. +Commit acknowledgement ambiguity, actual durability/power faults, full file I/O +matrices and hostile OS/provider qualification remain separate obligations. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 91de5d467..ea77c91d5 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3260,6 +3260,57 @@ subject; identity161/public-SDK158 and the other counters remain unchanged. Form translation closure remains a002. These construction results are not new hosted or formal qualification. +## Native mutation/disclosure PostgreSQL batch-abort checkpoint + +Seven new histories reject every actual admission insert prefix: three mutation +rows (attempt/count/amount sum) and four disclosure rows (attempt/lifetime +allocation/delivery count/byte sum). Existing owned-schema trigger/sequence controls +run inside the maintained TLS PostgreSQL adapter transaction. An independent +initialized worker OS process reaches each exact failure; a nontransactional +server sequence survives rollback and equals the rejected ordinal. Complete +gateway-table counts plus known slot/allocation keys prove that every attempted +prefix row rolled back, with no hidden or duplicate charge. + +The shared witness now also requires PostgreSQL's `is_called` flag to be true. +Without that assertion, an unused fresh sequence's initial `last_value = 1` could +be mistaken for a first-row exception. The strengthened oracle applies to all +eleven acquisition/mutation/disclosure prefixes; native gateway decisions and +transaction behavior are unchanged. + +Failed workers perform zero custody or provider calls. Failed disclosure admission +also sends zero wire bytes, including no native authentication challenge. Its +original acquisition journal and source allocation rows remain byte-identical. +After removing only the owned fixture trigger, a reopened native engine confirms +the operation is absent and explicitly reauthorizes the unchanged signed inputs. +Mutation sends one exact native compiled Stripe request to the counting provider, +which performs no idempotent deduplication. Disclosure authenticates a separately +spawned native recipient OS process over a real same-UID Unix endpoint, delivers +the exact content and records its exact signed ACK. The original source is never +refetched; one lifetime release allocation, one count slot and one byte-sum slot +remain. Terminal replay performs no custody/provider work, emits no wire bytes and +preserves all inspected attempt/charge rows. + +Required constructors passed with one matched, nonignored test each. After the +sequence-witness strengthening: acquisition 1.70s, mutation 1.32s and disclosure +2.83s. The workflow preserves all 36 +previous native selectors and adds the two exact ignored-PostgreSQL selectors for +38. Alongside the existing four acquisition prefixes, the corpus now covers 11 +actual native admission aborts across all three protocols. New compliance anchors +name both constructors. The testkit exposes the existing ready-marker reader and +strengthens the sequence witness; shipping runtime/store behavior is unchanged. + +These are local artifact construction results, not new-head hosted acceptance. +They cover actual server transaction aborts and fresh handles, not ambiguous +COMMIT delivery, sync/power loss, hostile process containment or the full A06 +fault matrix. The recipient retry crosses an actual process boundary under the +explicit same-UID fixture policy; it establishes no hostile OS qualification. +A06 remains partial. AP070 and the paused AP073 worktree remain untouched. + +Native source-closure construction and rebuilt non-update verification passed. +Semantic inventory construction advances freeze419 and only its reported changed +identity162/public-SDK159/public-surface419 subjects. Formal translation closure +remains a002; metadata construction is not fresh formal or hosted qualification. + ## Phase gates | Phase | State | Outstanding gate | @@ -3283,7 +3334,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, four rejected-prefix transactions and six committed/aborted reply-loss histories executed | Complete mutation/disclosure fault schedules and remaining durability cases required | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, eleven rejected native admission prefixes across all protocols and six committed/aborted acquisition reply-loss histories executed | Mutation/disclosure ambiguous-commit and file I/O schedules plus remaining durability cases required | | A07 | Revoke between acquisition and disclosure | Partial / daemon corpus plus native file/TLS PostgreSQL worker/operator release races / withdrawal before final grant produces no post-authentication wire bytes or ACK, while grant-first records exact delivery/ACK | Complete revocation scopes and installed boundary races | | A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient and full native file/TLS PostgreSQL crash corpora / fifty-six release histories include partial sends, both peers killed before ACK, caller loss after ACK commit, current-authority gates, late and repeated ACKs with conserved allocations/slots | Remaining I/O-error/ambiguous-commit races and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index ba3ea7148..cf91f7d2b 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -919,3 +919,12 @@ the existing final entry fence establish parity when a 1-of-2 proof remains Authorized but its selected evidence changes. Native mutation request echoes remain bound to the newly signed proof. All earlier order/expiry schedules are preserved, including independent wire-byte capture for refused disclosure. + +The native mutation/disclosure transaction-prefix fixtures reuse the existing +owned-schema PostgreSQL trigger/sequence controls and protocol-specific authoring. +All attempt and unit-specific charge rows roll back together. Disclosure preserves +its pre-existing source and charges and requires independent recipient authority +after a fresh native retry; mutation has no disclosure lifetime allocation. These +are test-only vertical histories using the existing transaction and journal +owners. No provider branch enters runtime, no new abstraction is extracted and no +reference implementation becomes a managed decision system. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 58eea006b..fc0a36cfb 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -807,13 +807,28 @@ complete mutation/disclosure fault matrix remain separate requirements. `native-postgres-partial-batch.json` separately rejects each insert of a four-record native admission transaction using a server trigger confined to an -owned test schema. A nontransactional sequence witnesses the reached row prefix; +owned test schema. A nontransactional sequence witnesses the reached row prefix, +including an explicit `is_called` check so an unused sequence's initial value +cannot masquerade as a rejected first insert; actual gateway-table counts must show complete rollback before any credential lease or HTTP entry. Removing the test fault permits explicit native reauthorization of the unchanged operation, followed by no-I/O terminal replay. This is real PostgreSQL transaction-abort evidence, not commit-acknowledgement ambiguity, power loss or the complete mutation/disclosure fault matrix. +`native-mutation-postgres-partial-batch.json` extends row-prefix rejection to all +three rows of a real native Stripe mutation admission: attempt, count and amount +sum. `native-disclosure-postgres-partial-batch.json` covers all four release rows: +attempt, lifetime allocation, delivery count and byte sum, while preserving the +already acquired source and its charges byte-for-byte. The failure workers make +no custody or provider calls; failed release admission sends no authentication or +content bytes. After the trigger is removed, explicit full native reauthorization +of the unchanged signed inputs sends exactly one mutation or authenticates a +separate native recipient OS process and records its exact ACK. Replay preserves +all inspected rows and sends nothing. These are transaction-abort and ordinary +reopen histories over the maintained TLS adapter, not ambiguous commit delivery, +power loss, hostile OS containment or the complete A06 durability matrix. + `native-postgres-commit-reply-loss.json` separately exercises real lost COMMIT replies for admission, entry and response persistence. A deferred fixture trigger pauses the actual COMMIT; a direct TLS observer verifies the selected backend's diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 779fdecf2..66537287c 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"ffe0eef546c98832959690517ffb4aca4d9903c166220fb39e8442838c1f7bb7"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"ab4bd0f13ca2ad24e97cec316f1a9370ac9af7c21eb191ab8377270c0a7bb6d9"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"3aed4ec132bf6e7199e6cf3a8143292bb3ee97245b994a91ab5e6255ac97bc76"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"368d9939cf30362bb84b3c290c3d36a545d048d509ffe42c52baab28be287081"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"3977a19697b479ff29aff513455a8dcedab33e36148bf511c27fd16b50c96108"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"e9212a65d8c2fe336a52b6cfc6c3bde6280df8739be1f3088642597aa8e8c62f"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs index 18c33a8b1..6bf7db71e 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs @@ -37,6 +37,9 @@ use kit::{CrashSetup, Input, Recipient, Role, controls, key}; #[path = "native_disclosure_budget_tests.rs"] mod window_capacity_tests; +#[path = "native_disclosure_pg_batch_tests.rs"] +mod postgres_batch_tests; + const SOURCE: &str = "crash-release-source"; const RELEASE: &str = "crash-release"; diff --git a/product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs new file mode 100644 index 000000000..b46e79530 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs @@ -0,0 +1,319 @@ +//! Actual server exceptions must roll back every release admission row while +//! preserving its independently acquired source and lifetime charges. +use super::*; +use crate::native_postgres_fault_tests::ready; +use crate::{GatewayExecutionWitness, GatewaySubmitResult}; +use std::io::{Read as _, Write as _}; + +const WORKER: &str = "AUTHS_AP074_DISCLOSURE_BATCH_PEER"; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct WorkerResult { + process: u32, + result: Result, + wire_bytes: u64, + witness: GatewayExecutionWitness, +} + +async fn wire_bytes(client: UnixStream) -> u64 { + let mut bytes = Vec::new(); + client + .take(16_385) + .read_to_end(&mut bytes) + .await + .expect("gateway EOF"); + assert!(bytes.len() <= 16_384, "bounded local wire capture"); + bytes.len() as u64 +} + +#[test] +fn native_disclosure_postgres_batch_peer() { + let Some(path) = std::env::var_os(WORKER) else { + return; + }; + let setup: CrashSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach( + Backend::parse(&setup.installation.backend), + &setup.installation.location, + ); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + "partial-release-worker", + store.attempts().clone(), + controls(Gate::Current), + )); + let input = Input::read(&setup.installation.root); + let target = runtime.block_on(kit::target(&engine, &setup)); + runtime + .block_on(engine.compile_disclosure_effect(&target, &input.proof, &input.action)) + .expect("genuine native release before failure"); + let mut signal = crate::native_dependency_tests::connect(setup.installation.barrier_port); + signal.write_all(b"R").expect("ready"); + let mut marker = [0]; + signal.read_exact(&mut marker).expect("release"); + assert_eq!(marker, *b"G"); + let (result, wire_bytes) = runtime.block_on(async { + let (server, client) = UnixStream::pair().expect("real local channel"); + tokio::join!( + engine.disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(server, setup.channel.clone()) + ), + wire_bytes(client) + ) + }); + private( + &setup.installation.root.join("partial-release-result.json"), + &serde_json::to_vec(&WorkerResult { + process: std::process::id(), + result, + wire_bytes, + witness: engine.execution_witness(), + }) + .expect("result"), + ); +} + +fn counts(admitted: bool) -> BTreeMap { + let mut counts = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ("attempt".to_owned(), 1), + ("effect-allocation".to_owned(), 1), + ]); + if admitted { + counts.insert("attempt".to_owned(), 2); + counts.insert("effect-allocation".to_owned(), 2); + counts.insert("count-slot".to_owned(), 1); + counts.insert("sum-slot".to_owned(), 1); + } + counts +} + +fn assert_source(case: &Case) { + assert_eq!( + case.store + .raw() + .load(GatewayRecordKind::Attempt, &key(SOURCE)) + .expect("load") + .expect("source"), + case.source + ); + assert_eq!(case.provider.calls.load(Ordering::SeqCst), 1); + for (name, expected) in ["release.proof", "release.action", "release.approval"] + .iter() + .zip(&case.signed_inputs) + { + assert_eq!( + &std::fs::read(case.setup.installation.root.join(name)).expect("original signed input"), + expected + ); + } +} + +fn fail(case: &Case, fail_at: u64) { + let before = case.source_charges.records(&case.store, true); + assert_eq!(case.store.postgres_gateway_record_counts(), counts(false)); + let input = case.setup.installation.root.join("partial-release.setup"); + private( + &input, + &serde_json::to_vec(&case.setup).expect("closed setup"), + ); + let mut peer = Peer::start( + &input, + "native_disclosure_crash_tests::postgres_batch_tests::native_disclosure_postgres_batch_peer", + WORKER, + ); + let mut signal = ready(&case.listener); + case.store.reject_postgres_batch_insert(fail_at); + signal.write_all(b"G").expect("release initialized worker"); + peer.finish(); + let worker: WorkerResult = serde_json::from_slice( + &std::fs::read( + case.setup + .installation + .root + .join("partial-release-result.json"), + ) + .expect("result"), + ) + .expect("native result"); + assert_ne!(worker.process, std::process::id()); + assert_eq!( + worker.result, + Err(GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned() + }) + ); + assert_eq!( + worker.wire_bytes, 0, + "admission failure cannot send even an authentication challenge" + ); + assert_eq!( + ( + worker.witness.credential_lease_calls, + worker.witness.read_transport_entries, + worker.witness.write_transport_entries + ), + (0, 0, 0) + ); + assert_eq!( + case.store.clear_postgres_batch_failure(), + fail_at, + "server sequence witnesses the rejected prefix" + ); + assert_eq!(case.store.postgres_gateway_record_counts(), counts(false)); + assert!( + case.store + .raw() + .load(GatewayRecordKind::Attempt, &key(RELEASE)) + .expect("load") + .is_none() + ); + assert!(case.release_charges.records(&case.store, false).is_empty()); + assert_eq!(case.source_charges.records(&case.store, true), before); + assert_source(case); +} + +fn reopen(case: &Case) -> DisclosureSnapshot { + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup.installation, + "partial-release-reopened", + case.store.reopen(), + controls(Gate::Current), + )); + assert!( + case.runtime + .block_on(engine.content_history(RELEASE)) + .is_err() + ); + let input = Input::read(&case.setup.installation.root); + let target = case.runtime.block_on(kit::target(&engine, &case.setup)); + let (snapshot, mut recipient) = case.runtime.block_on(async { + let listener = UnixListener::bind(case.setup.installation.root.join("release.sock")) + .expect("owned native endpoint"); + let recipient = Recipient::start(&case.setup, false); + let (stream, _) = listener + .accept() + .await + .expect("independent native recipient"); + let snapshot = engine + .disclose( + &target, + &input.proof, + &input.action, + input.approval.clone(), + DisclosureConnection::new(stream, case.setup.channel.clone()), + ) + .await + .expect("fresh native reauthorization"); + (snapshot, recipient) + }); + recipient.finish(false); + assert_eq!(snapshot.stage, DisclosureStage::Acknowledged); + assert_eq!( + (snapshot.reserved_deliveries, snapshot.reserved_bytes), + (1, CONTENT.len() as u64) + ); + assert_eq!( + ( + snapshot.policy_count_counters, + snapshot.policy_byte_counters + ), + (1, 1) + ); + let received: Value = serde_json::from_slice( + &std::fs::read(case.setup.installation.root.join("recipient-result.json")) + .expect("actual recipient outcome"), + ) + .expect("recipient"); + assert_eq!(received["received_full"], true); + assert_eq!(received["bytes"], CONTENT.len()); + assert_replay(case, &engine, &input, &target, &snapshot); + snapshot +} + +fn assert_replay( + case: &Case, + engine: &GatewayEngine, + input: &Input, + target: &DisclosureTarget, + snapshot: &DisclosureSnapshot, +) { + let charges = case.release_charges.records(&case.store, true); + assert_eq!(charges.len(), 3); + let raw = case + .store + .raw() + .load(GatewayRecordKind::Attempt, &key(RELEASE)) + .expect("load") + .expect("release"); + let witness = engine.execution_witness(); + case.runtime.block_on(async { + let (server, client) = UnixStream::pair().expect("replay channel"); + let (replayed, wire) = tokio::join!( + engine.disclose( + target, + &input.proof, + &input.action, + input.approval.clone(), + DisclosureConnection::new(server, case.setup.channel.clone()) + ), + wire_bytes(client) + ); + assert_eq!(&replayed.expect("historical facts"), snapshot); + assert_eq!(wire, 0); + }); + assert_eq!(engine.execution_witness(), witness); + assert_eq!( + ( + witness.credential_lease_calls, + witness.read_transport_entries, + witness.write_transport_entries + ), + (0, 0, 0) + ); + assert_eq!(case.release_charges.records(&case.store, true), charges); + assert_eq!( + case.store + .raw() + .load(GatewayRecordKind::Attempt, &key(RELEASE)) + .expect("replay") + .expect("record"), + raw + ); + assert_eq!(case.store.postgres_gateway_record_counts(), counts(true)); + assert_source(case); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_disclosure_partial_batch_fixture_is_current() { + assert!(postgres_configured()); + let cases:Vec<_>=(1..=4).map(|fail_at| { + let case=Case::new(Backend::Postgres,Point::BeforeReservationCommit,Gate::Current); + fail(&case,fail_at);let snapshot=reopen(&case); + json!({"server_rejected_insert":fail_at,"prior_insert_prefix":fail_at-1,"server_sequence":fail_at, + "all_release_attempt_allocation_count_and_byte_rows_rolled_back":true, + "source_attempt_and_allocations_unchanged":true,"failed_worker_has_zero_custody_provider_or_wire_bytes":true, + "same_signed_inputs_reauthorized_after_reopen":true,"native_snapshot":snapshot, + "independent_native_recipient_received_exact_content_and_sent_ack":true,"provider_source_reads":1, + "additional_provider_reads":0,"one_release_allocation_count_and_sum_slot":true, + "terminal_replay_changes_no_rows_or_witness_and_sends_zero_bytes":true}) + }).collect(); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-postgres-partial-batch/1", + "scope":"actual native source HTTP acquisition, independent initialized failure worker, server-side insert exceptions and sequence witnesses over maintained TLS adapter; reopened gateway authenticates a separate native recipient OS process over same-UID Unix sockets and records its exact ACK; public fixture keys and maintained clock", + "excluded":["ambiguous commit delivery","server/power failure","file I/O faults","hostile OS or live-provider qualification"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-disclosure-postgres-partial-batch.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs index cbb7f2760..eb64bba40 100644 --- a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs @@ -9,6 +9,9 @@ const WORKER: &str = "AUTHS_AP074_MUTATION_WINDOW_PEER"; const WINDOW: u64 = 60; const AMOUNT: u64 = 500; +#[path = "native_mutation_pg_batch_tests.rs"] +mod postgres_batch_tests; + #[derive(Clone, Copy)] enum Limit { Count, diff --git a/product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs b/product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs new file mode 100644 index 000000000..2c5322cf8 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs @@ -0,0 +1,204 @@ +//! Actual server-rejected native mutation admission prefixes. The maintained +//! transaction must roll back its attempt, count and amount-sum rows together. +use super::*; +use crate::native_postgres_fault_tests::ready; + +fn counts(admitted: bool) -> BTreeMap { + let mut result = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ]); + if admitted { + for kind in ["attempt", "count-slot", "sum-slot"] { + result.insert(kind.to_owned(), 1); + } + } + result +} + +fn signed_inputs(case: &MutationRace) -> Vec> { + ["proof", "action", "approval", "binding"] + .map(|suffix| { + std::fs::read(case.setup.root.join(format!("{}.{suffix}", OPERATIONS[0]))) + .expect("original native input") + }) + .to_vec() +} + +fn fail(case: &MutationRace, fail_at: u64, counters: &[Counter]) { + let input = case.setup.root.join("partial-mutation.setup"); + private( + &input, + &serde_json::to_vec(&json!({"installation":case.setup, + "operation":OPERATIONS[0],"mode":WorkerMode::Contend})) + .expect("closed worker setup"), + ); + let mut peer = Peer::start( + &input, + "native_mutation_crash_tests::window_capacity_tests::native_mutation_window_peer", + WORKER, + ); + let mut signal = ready(&case.barrier); + case.store.reject_postgres_batch_insert(fail_at); + signal.write_all(b"G").expect("release initialized worker"); + peer.finish(); + let worker: WorkerResult = serde_json::from_slice( + &std::fs::read(case.setup.root.join(format!("{}.result", OPERATIONS[0]))) + .expect("native result"), + ) + .expect("result"); + assert_ne!(worker.process, std::process::id()); + assert_eq!( + worker.result, + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned() + } + ); + assert_eq!( + ( + worker.witness.credential_lease_calls, + worker.witness.write_transport_entries, + worker.witness.read_transport_entries + ), + (0, 0, 0) + ); + assert_eq!(case.provider.calls(), 0); + assert_eq!( + case.store.clear_postgres_batch_failure(), + fail_at, + "nontransactional server sequence records the rejected row prefix" + ); + assert_eq!(case.store.postgres_gateway_record_counts(), counts(false)); + assert!(case.store.raw().attempt_keys(4).expect("keys").is_empty()); + for counter in counters { + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(0)) + .expect("rolled back first slot") + .is_none() + ); + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(1)) + .expect("no hidden charge") + .is_none() + ); + } +} + +fn reopen(case: &MutationRace, counters: &[Counter]) -> GatewaySubmitResult { + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup, + "partial-mutation-reopened", + case.store.reopen(), + Flavor::StripePlain.controls(), + )); + let operation = LogicalOperationId::parse(OPERATIONS[0]).expect("operation"); + assert!( + case.runtime + .block_on( + case.store + .attempts() + .read(Flavor::StripePlain.recipe().namespace(), &operation) + ) + .expect("history") + .is_none() + ); + let result = case + .runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])); + assert_eq!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + assert_eq!(case.provider.calls(), 1); + assert_eq!( + case.provider.requests.lock().expect("requests")[0].body, + std::fs::read(case.setup.root.join(format!("{}.body", OPERATIONS[0]))) + .expect("exact native body") + ); + let raw = case.store.raw(); + let key = GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + Flavor::StripePlain.recipe().namespace(), + &operation, + ) + .expect("key"); + let mut records = vec![( + GatewayRecordKind::Attempt, + key, + raw.load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("attempt"), + )]; + for counter in counters { + let bytes = raw + .load(counter.kind, &counter.key(0)) + .expect("load") + .expect("first slot"); + let value: Value = serde_json::from_slice(&bytes).expect("native slot"); + assert_eq!(value["slot"], 0); + assert_eq!(value["operation_id"], OPERATIONS[0]); + assert_eq!(value["window_seconds"], WINDOW); + assert_eq!(value["window_index"], NOW / WINDOW); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], AMOUNT); + assert_eq!(value["cumulative"], AMOUNT); + } + assert!( + raw.load(counter.kind, &counter.key(1)) + .expect("no duplicate") + .is_none() + ); + records.push((counter.kind, counter.key(0), bytes)); + } + let witness = engine.execution_witness(); + assert_eq!( + case.runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])), + result + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(case.provider.calls(), 1); + for (kind, key, bytes) in records { + assert_eq!( + raw.load(kind, &key).expect("replay").expect("record"), + bytes + ); + } + assert_eq!(case.store.postgres_gateway_record_counts(), counts(true)); + result +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_partial_batch_fixture_is_current() { + assert!(postgres_configured()); + let cases:Vec<_> = (1..=3).map(|fail_at| { + let case = MutationRace::new(Backend::Postgres); + let counters = case.runtime.block_on(inputs(&case.engine,&case.setup.root,OPERATIONS[0],Limit::Both)); + assert_eq!(counters.len(),2);assert_eq!(case.store.postgres_gateway_record_counts(),counts(false)); + let signed = signed_inputs(&case); + fail(&case,fail_at,&counters); + assert_eq!(signed_inputs(&case),signed); + let result = reopen(&case,&counters); + assert_eq!(signed_inputs(&case),signed); + json!({"server_rejected_insert":fail_at,"prior_insert_prefix":fail_at-1, + "server_sequence":fail_at,"failed_native_worker_has_no_custody_or_transport":true, + "all_attempt_count_and_amount_sum_rows_rolled_back":true, + "unchanged_signed_inputs_reauthorized_after_reopen":true,"native_result":result, + "actual_provider_writes":1,"exact_native_body_captured":true, + "one_count_and_one_amount_sum_slot":true,"replay_changes_no_rows_or_execution_witness":true}) + }).collect(); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-postgres-partial-batch/1", + "scope":"full native plain Stripe mutation with real TLS adapter transactions, separate initialized worker processes, server-side row-prefix exceptions and nontransactional sequence witnesses; maintained clock/public fixture keys, actual counting HTTP provider without deduplication", + "excluded":["ambiguous commit delivery","server or power failure","file I/O faults","hostile OS and live-provider qualification"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-mutation-postgres-partial-batch.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs b/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs index 09817a622..af880d4be 100644 --- a/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs +++ b/product/runtime/auths-gateway/src/native_postgres_fault_tests.rs @@ -24,7 +24,7 @@ use std::{ const OPERATION: &str = "postgres-partial-batch"; -fn ready(listener: &TcpListener) -> TcpStream { +pub(crate) fn ready(listener: &TcpListener) -> TcpStream { let deadline = Instant::now() + Duration::from_secs(15); loop { match listener.accept() { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 990d39bfe..f9282ee71 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d4f058591674f1c5f660647b596045347a964cd33b4b209fafaf6ccac03f5c75"; + "ed250726fc4863fa0ead03cc3cf30857958af791d74be23386afbb1bd9004894"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store_testkit.rs b/product/runtime/auths-gateway/src/store_testkit.rs index fbf0faffa..d53eca84b 100644 --- a/product/runtime/auths-gateway/src/store_testkit.rs +++ b/product/runtime/auths-gateway/src/store_testkit.rs @@ -189,11 +189,18 @@ impl TestAttempts { let mut client = admin_client(); let row = client .query_one( - &format!("SELECT last_value FROM {schema}.fixture_batch_insert_sequence"), + &format!( + "SELECT last_value, is_called FROM {schema}.fixture_batch_insert_sequence" + ), &[], ) .expect("sequence witness"); let reached: i64 = row.get(0); + let called: bool = row.get(1); + assert!( + called, + "the native worker must actually reach the server insert trigger" + ); client .batch_execute(&format!( "DROP TRIGGER fixture_reject_batch_insert ON {schema}.auths_gateway_records" diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 9d7ab109f..31cc0f699 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 418 +freeze_version = 419 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 418 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 161 +"auths.identity.protocol" = 162 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 418 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 158 +"auths.product.public-sdk-contract" = 159 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 418 +"auths.release.public-surface" = 419 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index a6c3175e7..29d61dbe9 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 418, + "freezeVersion": 419, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 161, + "version": 162, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "3285212cd5ca9f46bf4622984915e6376b1f38d68b45b2d1d7d65b3cebc0dd2c" + "sha256": "9be14d24405f47726c04d54a595986bdd251cbc94085231cb67233a35e1fe4f3" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 158, + "version": 159, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "0d296e8d1302b1350b495a9393db7d54b822d7f9c85cca481bdd634d7f4fc1b8" + "sha256": "aa26eb8e034162f11f0f222700f052b041444aa564ee9ac129876eb691592987" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 418, + "version": 419, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "4bbd2934e4373656a5d57d8b3ebf7d5d846560a6a6d7d0f17c8b69861ecd1201" + "sha256": "cbb067b6614cf19f17ed21e026b1a112ae0324637a6967ccb0ad0befc4017702" } ] } From 2ab072a5fda7dfc2c2c5659e39db60d2ff08659d Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 00:46:22 +0000 Subject: [PATCH 108/136] test(gateway): cover lost mutation and disclosure commit replies --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-disclosure-commit-reply-loss.json | 203 ++++++ .../native-mutation-commit-reply-loss.json | 111 +++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 29 + docs/plans/0074-implementation-status.md | 64 +- .../0009-bound-effect-and-recovery.md | 10 + ...ound-effects-and-recovery-state-machine.md | 17 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/native_crash_tests.rs | 9 + .../src/native_disclosure_crash_tests.rs | 3 + .../src/native_disclosure_pg_commit_tests.rs | 669 ++++++++++++++++++ .../src/native_mutation_budget_tests.rs | 3 + .../src/native_mutation_pg_commit_tests.rs | 366 ++++++++++ .../src/native_postgres_commit_proxy.rs | 12 +- .../src/native_postgres_commit_tests.rs | 109 ++- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 19 files changed, 1586 insertions(+), 49 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-commit-reply-loss.json create mode 100644 bindings/fixtures/gateway/native-mutation-commit-reply-loss.json create mode 100644 product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 70416655c..94df5ce58 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -72,6 +72,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_batch_tests::postgres_native_mutation_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_batch_tests::postgres_native_disclosure_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_commit_tests::postgres_native_mutation_commit_reply_loss_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_commit_tests::postgres_native_disclosure_commit_reply_loss_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::native_file_mutation_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current diff --git a/bindings/fixtures/gateway/native-disclosure-commit-reply-loss.json b/bindings/fixtures/gateway/native-disclosure-commit-reply-loss.json new file mode 100644 index 000000000..c09d2b9aa --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-commit-reply-loss.json @@ -0,0 +1,203 @@ +{ + "schema": "auths.native-disclosure-commit-reply-loss/1", + "cases": [ + { + "phase": "admission", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "reserved", + "post_error_native_phase": "reserved", + "new_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "admission", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": null, + "post_error_native_phase": null, + "new_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "entry", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "entry-granted", + "post_error_native_phase": "entry-granted", + "new_delivery_allowed": false, + "recipient_deliveries": 0, + "native_snapshot_before_historical_ack": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": false, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "entry", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "reserved", + "post_error_native_phase": "reserved", + "new_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "acknowledgement", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "acknowledged", + "post_error_native_phase": "acknowledged", + "new_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "acknowledgement", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "entry-granted", + "post_error_native_phase": "unknown", + "new_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "unknown", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "unknown", + "post_error_native_phase": "unknown", + "new_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + }, + { + "phase": "unknown", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independent_commit_phase": "entry-granted", + "post_error_native_phase": "entry-granted", + "new_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_provider_or_custody_calls": 0, + "one_allocation_count_and_byte_sum_slot": true, + "existing_source_and_charges_conserved": true, + "terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change": true + } + ], + "scope": "actual native HTTP source acquisition, native release gateway and recipient in independent OS processes, real TLS COMMIT replies withheld by opaque proxy, independently observed committed/aborted outcomes; native Unix authentication, exact received ACKs and opaque gateway wire capture; fixed public fixture keys/clock, same-UID local processes", + "excluded": [ + "file faults", + "server or power failure", + "hostile OS or live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-commit-reply-loss.json b/bindings/fixtures/gateway/native-mutation-commit-reply-loss.json new file mode 100644 index 000000000..a362c5648 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-commit-reply-loss.json @@ -0,0 +1,111 @@ +{ + "schema": "auths.native-mutation-commit-reply-loss/1", + "cases": [ + { + "phase": "admission", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": "reserved", + "provider_writes_before_reopen": 0, + "new_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + }, + { + "phase": "admission", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": null, + "provider_writes_before_reopen": 0, + "new_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + }, + { + "phase": "entry", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": "entry-granted", + "provider_writes_before_reopen": 0, + "new_execution_allowed": false, + "provider_writes_after_reopen": 0, + "native_result": { + "outcome": "unknown" + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + }, + { + "phase": "entry", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": "reserved", + "provider_writes_before_reopen": 0, + "new_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + }, + { + "phase": "response", + "outcome": "committed", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": "response-recorded", + "provider_writes_before_reopen": 1, + "new_execution_allowed": false, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + }, + { + "phase": "response", + "outcome": "aborted", + "selected_commit_uses_tls": true, + "actual_native_adapter_commit_errors": 1, + "independently_observed_commit_phase": "entry-granted", + "provider_writes_before_reopen": 1, + "new_execution_allowed": false, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "unknown" + }, + "exact_native_body_captured_when_sent": true, + "one_count_and_one_amount_sum_slot": true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay": true + } + ], + "scope": "full native Stripe mutation with native signed bounded proof/exact approval, separate worker OS processes, actual end-to-end TLS COMMIT replies withheld by an opaque proxy, server-deferred barrier and independent TLS transaction-outcome observer, counting local provider without deduplication; fixed public test keys/clock", + "excluded": [ + "file faults", + "server or power failure", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index fadeb54f8..52f2b30c4 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1836,6 +1836,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs#postgres_native_mutation_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs#postgres_native_disclosure_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_commit_tests.rs#postgres_native_commit_reply_loss_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs#postgres_native_mutation_commit_reply_loss_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs#postgres_native_disclosure_commit_reply_loss_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#native_file_mutation_retained_replay_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_replay_tests.rs#postgres_native_mutation_retained_replay_fixture_is_current", "product/runtime/auths-gateway/src/native_information_replay_tests.rs#native_file_information_retained_replay_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 334f25e16..5a184d7e1 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1354,3 +1354,32 @@ authentication challenge either. These tests use the maintained TLS transaction adapter and existing testkit setup/authoring, with no shipping fault branch. Commit acknowledgement ambiguity, actual durability/power faults, full file I/O matrices and hostile OS/provider qualification remain separate obligations. + +## Real lost COMMIT replies preserve typed uncertainty + +The existing acquisition COMMIT harness now observes typed mutation and +disclosure record paths and exact operation keys. Its native store wrapper +forwards unchanged native decisions and counts actual adapter errors. An opaque +proxy never terminates TLS; a separate direct TLS observer waits on the selected +backend's deferred transaction trigger, verifies its SSL session and independently +observes commit versus backend termination/rollback. Snapshot keys include record +kind as well as storage key so distinct record families cannot collapse together. +No production error, clock, grant, record byte or authorization decision is faked. + +Six mutation histories cover admission, final grant and response persistence. +Eight disclosure histories cover admission, final grant, exact ACK and Unknown +persistence, with separate native gateway/recipient processes and opaque Unix +wire capture. A committed grant with a lost reply never recreates a permit, even +if actual send count is zero. Absent/reserved work requires native reauthorization +to continue. Existing count/sum/lifetime rows remain byte-identical and terminal +replay makes no new custody/provider calls or authentication/content frames. + +An aborted ACK transaction is followed by the existing native Unknown transition; +an ACK that committed despite reply loss stays acknowledged. A recipient that +received content can supply its genuine historical signed ACK later, including +when its original ACK was deliberately withheld to exercise Unknown persistence. +That action refines history and preserves charges without delivery. No saved ACK +is invented when a lost grant sent no content. This is native transaction/transport +evidence under fixture keys, clocks and same-UID local process policy; file faults, +server/power loss, hostile OS containment and live-provider qualification remain +separate work. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index ea77c91d5..eb7da028e 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3311,6 +3311,66 @@ Semantic inventory construction advances freeze419 and only its reported changed identity162/public-SDK159/public-surface419 subjects. Formal translation closure remains a002; metadata construction is not fresh formal or hosted qualification. +## Native mutation/disclosure lost-COMMIT-reply checkpoint + +Fourteen new histories extend the actual TLS commit-reply-loss harness: mutation +admission/final grant/response persistence, and disclosure admission/final grant/ +ACK/Unknown persistence, each with separately observed committed and aborted +outcomes. The native worker reaches a deferred trigger in its actual COMMIT; a +separate direct TLS client checks that backend's SSL session and observes its +advisory-lock wait. An opaque TCP proxy withholds replies while the observer either +releases the transaction to commit or terminates that exact fixture backend and +verifies rollback. TLS is never terminated by the proxy and no adapter error, +decision, permit or record bytes are fabricated. A transparent store wrapper counts +one actual selected adapter error in each history. + +The shared observer now takes a typed native record path and exact operation key. +Its query filters the attempt record kind, and all-row snapshots retain kind plus +key, preventing distinct record families from collapsing into one comparison. +The original acquisition artifact constructor passed without update mode in2.45s +after this helper change and its committed artifact stayed byte-identical. These +are test-only observation/transport changes, not a new runtime or lifecycle owner. + +Mutation uses maintained plain Stripe recipe/proof/approval and a counting HTTP +provider that performs no idempotent deduplication. A committed final grant whose +reply was lost stays charged Unknown even when no HTTP write occurred. Absent or +reserved work continues only through full native reauthorization on a reopened +handle. Native response evidence remains distinct from uncertainty, and actual +captured bodies equal the original native compiled request. Count and amount-sum +rows retain their exact bytes, first slot and original admission time; no replay +leases credentials, sends again, refunds or creates another charge. + +Disclosure runs native gateway and recipient in separate OS processes, with an +opaque same-UID Unix relay independently measuring every gateway frame. A lost +grant reply sends no content; terminal replay emits no authentication or content +bytes. ACK commit success despite reply loss remains Acknowledged. An aborted ACK +write follows the existing native Unknown transition; an aborted Unknown write +leaves the physical grant and a conservative Unknown projection. The recipient +stores a genuine native signed ACK only after receiving the exact retained bytes. +That historical ACK may later refine uncertainty or replay an existing ACK without +delivery, provider/custody work, changed source facts or changed charges. No ACK is +invented for the committed/lost grant that delivered nothing. The original HTTP +source remains fetched exactly once across all release and recovery actions. + +Required exact artifact constructors passed with one matched, nonignored test: +mutation 3.40s and disclosure 5.88s (initial 2.72s/5.77s before explicit pre-existing +charge-byte comparisons). The workflow preserves its prior 38 native selectors and +adds two for 40. The combined acquisition/mutation/disclosure corpus now has 20 +actual committed/aborted reply-loss histories. Compliance anchors name both new +constructors; native source closure and release identities are refreshed. + +These are local artifact-construction results, not new-head hosted qualification. +They do not establish file fault parity, server/power-loss protection, hostile OS +containment or live-provider qualification. Existing native authority, approval, +grant, transaction and historical ACK owners are unchanged. A06/A08 remain partial +pending the remaining adverse/installed/durability evidence. AP070 and paused +AP073 remain untouched; the subagent alone handles CI inspection and publication. + +Native source-closure construction and rebuilt non-update verification passed. +Semantic inventory construction advances freeze420 and only its reported changed +identity163/public-SDK160/public-surface420 subjects. Formal translation closure +remains a002; these construction results are not fresh hosted or formal evidence. + ## Phase gates | Phase | State | Outstanding gate | @@ -3334,9 +3394,9 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen file faults, eleven rejected native admission prefixes across all protocols and six committed/aborted acquisition reply-loss histories executed | Mutation/disclosure ambiguous-commit and file I/O schedules plus remaining durability cases required | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen acquisition file faults, eleven admission-prefix aborts and twenty committed/aborted reply-loss histories across all protocols | Mutation/disclosure file I/O schedules and remaining durability/adverse cases required | | A07 | Revoke between acquisition and disclosure | Partial / daemon corpus plus native file/TLS PostgreSQL worker/operator release races / withdrawal before final grant produces no post-authentication wire bytes or ACK, while grant-first records exact delivery/ACK | Complete revocation scopes and installed boundary races | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient and full native file/TLS PostgreSQL crash corpora / fifty-six release histories include partial sends, both peers killed before ACK, caller loss after ACK commit, current-authority gates, late and repeated ACKs with conserved allocations/slots | Remaining I/O-error/ambiguous-commit races and full installed boundary evidence pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash and actual COMMIT-reply-loss corpora / fifty-six release crash histories plus eight committed/aborted release transactions cover lost grant replies, ACK/Unknown persistence, late genuine ACKs and no redelivery with conserved charges | Remaining file I/O-error, adverse races and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index cf91f7d2b..e873d5689 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -928,3 +928,13 @@ after a fresh native retry; mutation has no disclosure lifetime allocation. Thes are test-only vertical histories using the existing transaction and journal owners. No provider branch enters runtime, no new abstraction is extracted and no reference implementation becomes a managed decision system. + +Real COMMIT-reply loss now uses the acquisition harness's opaque TLS proxy and +server observer for mutation and disclosure too. The shared test observer selects +only typed record paths/operation keys and preserves kind-plus-key snapshots; +it has no decision or permit authority. Mutation response, disclosure ACK and +native Unknown persistence keep their distinct facts. Existing production journal, +grant and historical ACK owners are unchanged. Late recipient evidence may +refine Unknown, while lost grants and terminal replay cannot authorize I/O or new +charges. The additional six mutation/eight disclosure histories introduce no +shipping abstraction, provider branch or application-owned decision system. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index fc0a36cfb..bf0a2d9a7 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -840,6 +840,23 @@ checks and never recreate a lost grant. Charges and exact terminal rows remain unchanged through replay. These acquisition histories do not replace the full mutation/disclosure commit-fault matrix or establish power-loss/rollback safety. +`native-mutation-commit-reply-loss.json` extends those committed/aborted COMMIT +histories to native mutation admission, final entry and response persistence. +`native-disclosure-commit-reply-loss.json` covers release admission, entry, ACK +and Unknown persistence with gateway and recipient in separate OS processes. +Both use the same opaque end-to-end TLS proxy and independent server observer; +only typed native record paths/operation keys select the fixture barrier. The +observer addresses records by kind and key and snapshots every record family. +A grant whose transaction committed but whose reply was lost remains charged +Unknown even if no provider request or content frame was sent. Absent/pre-grant work continues only +through explicit native reauthorization. Recorded responses and recipient ACKs +remain distinct retained facts, and terminal replay emits no new frames or I/O. +An aborted ACK write can be followed by native Unknown persistence; an exact +historical ACK from the recipient may refine it later without any new delivery +or charge. These cases add fourteen transaction-outcome histories. Remaining +file/adverse schedules, server/power-loss and supported rollback assumptions and +hostile OS/provider qualification remain separate requirements. + A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. ### 4.4 Stage types and serialization diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 66537287c..cdd312d29 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"c8322e20a510d9b13a33398eb80dceed278a773a83d944adbd069ca649777979"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"3977a19697b479ff29aff513455a8dcedab33e36148bf511c27fd16b50c96108"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"e9212a65d8c2fe336a52b6cfc6c3bde6280df8739be1f3088642597aa8e8c62f"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"9f4f74b7117f7c579a91ef11d17dd2a67973d19c5b418df77fbc2a0b6019ff77"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"2d6d1184a7ca8af446204cb106aeeb18f640818121d379fefb45386a480bb81c"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"69f387fce82f44d6de7aca93fa30a185302fa45e98546b43c4d05f44d2b47a40"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"affe9ded085abfb3954b24f235dd545b44127603e21b5c0c5d11e0a108bb355a"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"3ed93201c69b94104e00516bde614761c562e2a679c738603f398283ead58a44"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"cdc1e051cb0a51521195281d1e78fff07067ccf21c3335064b0de9a06086e454"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs index e97367263..856eb0034 100644 --- a/product/runtime/auths-gateway/src/native_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -130,6 +130,15 @@ pub(super) enum CrashProtocol { Disclosure, } +impl CrashProtocol { + pub(super) const fn stage_pointer(self) -> &'static str { + match self { + Self::Mutation => "/state/facts/stage", + Self::Acquisition | Self::Disclosure => "/state/facts/phase/stage", + } + } +} + pub(super) struct PausedStore { operation: &'static str, protocol: CrashProtocol, diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs index 6bf7db71e..a8bafefbf 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs @@ -40,6 +40,9 @@ mod window_capacity_tests; #[path = "native_disclosure_pg_batch_tests.rs"] mod postgres_batch_tests; +#[path = "native_disclosure_pg_commit_tests.rs"] +mod postgres_commit_tests; + const SOURCE: &str = "crash-release-source"; const RELEASE: &str = "crash-release"; diff --git a/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs new file mode 100644 index 000000000..41d422c44 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs @@ -0,0 +1,669 @@ +//! Real TLS COMMIT-reply loss at native release admission, grant, ACK and Unknown +//! persistence. Independent recipients and server observers retain distinct facts. +use super::*; +use crate::native_dependency_tests::Peer as Process; +use crate::native_postgres_commit_tests::{Barrier, CommitWitness, Outcome, Proxy, fixture_url}; +use crate::native_postgres_fault_tests::ready; +use crate::{GatewayExecutionWitness, GatewaySubmitResult}; +use std::{ + io::{Read as _, Write as _}, + process::{Command, Stdio}, + sync::Arc, +}; +use tokio::io::AsyncWriteExt as _; + +const ENVIRONMENT: &str = "AUTHS_AP074_DISCLOSURE_COMMIT_PEER"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Phase { + Admission, + Entry, + Acknowledgement, + Unknown, +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + outcome: Outcome, +} +impl Schedule { + const fn stage(self) -> &'static str { + match self.phase { + Phase::Admission => "reserved", + Phase::Entry => "entry-granted", + Phase::Acknowledgement => "acknowledged", + Phase::Unknown => "unknown", + } + } + const fn retained(self) -> Option<&'static str> { + match self.outcome { + Outcome::Committed => Some(self.stage()), + Outcome::Aborted => match self.phase { + Phase::Admission => None, + Phase::Entry => Some("reserved"), + Phase::Acknowledgement | Phase::Unknown => Some("entry-granted"), + }, + } + } + fn resumable(self) -> bool { + matches!(self.retained(), None | Some("reserved")) + } + fn delivered(self) -> bool { + matches!(self.phase, Phase::Acknowledgement | Phase::Unknown) + } + fn ack_sent(self) -> bool { + matches!(self.phase, Phase::Acknowledgement) + } + fn final_phase(self) -> Option<&'static str> { + if matches!( + (self.phase, self.outcome), + (Phase::Acknowledgement, Outcome::Aborted) + ) { + Some("unknown") + } else { + self.retained() + } + } + fn projection(self) -> DisclosureStage { + match self.retained() { + Some("reserved") => DisclosureStage::Reserved, + Some("acknowledged") => DisclosureStage::Acknowledged, + _ => DisclosureStage::Unknown, + } + } +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Role { + Gateway, + Recipient, +} +impl Role { + const fn label(self) -> &'static str { + match self { + Self::Gateway => "gateway", + Self::Recipient => "recipient", + } + } +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Run { + Worker, + Reopened, + ReplayBeforeAck, + ReplayAfterAck, +} +impl Run { + const fn label(self) -> &'static str { + match self { + Self::Worker => "commit-worker", + Self::Reopened => "commit-reopened", + Self::ReplayBeforeAck => "commit-replay-before", + Self::ReplayAfterAck => "commit-replay-after", + } + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct CommitSetup { + installation: Setup, + channel: UnixDisclosurePolicy, + schedule: Schedule, + role: Role, + run: Run, +} +impl CommitSetup { + fn path(&self, suffix: &str) -> std::path::PathBuf { + self.installation + .root + .join(format!("{}.{suffix}", self.run.label())) + } + async fn target(&self, engine: &GatewayEngine) -> DisclosureTarget { + engine + .disclosure_target( + SOURCE, + SigningKey::from_bytes(&[47; 32]).verifying_key().to_bytes(), + self.channel.commitment().expect("channel"), + [52; 32], + ) + .await + .expect("retained native source") + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct RecipientResult { + process: u32, + bytes: u64, + ack_sent: bool, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct ResultData { + process: u32, + result: Result, + errors: u64, + witness: GatewayExecutionWitness, + recipient: RecipientResult, + challenge_sent: bool, + content_wire_bytes: u64, +} + +fn spawn(setup: &CommitSetup, role: Role, url: Option<&str>) -> Process { + let path = setup.path(&format!("{}.setup", role.label())); + private( + &path, + &serde_json::to_vec( + &json!({"installation":setup.installation,"channel":setup.channel, + "schedule":setup.schedule,"role":role,"run":setup.run}), + ) + .expect("setup"), + ); + let mut command = Command::new(std::env::current_exe().expect("test executable")); + command.args(["--exact","native_disclosure_crash_tests::postgres_commit_tests::native_disclosure_postgres_commit_peer","--nocapture"]) + .env(ENVIRONMENT,path).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::piped()); + if let Some(url) = url { + command.env("AUTHS_POSTGRES_URL", url); + } + Process(command.spawn().expect("independent native peer")) +} + +async fn recipient(setup: &CommitSetup) { + let stream = UnixStream::connect(setup.path("sock")) + .await + .expect("native gateway endpoint"); + let binding = EffectBinding::from_private_bytes( + &std::fs::read(setup.installation.root.join("release.binding")).expect("reviewed binding"), + ) + .expect("binding"); + let signer = SigningKey::from_bytes(&[47; 32]); + let received = crate::disclosure_transport::receive_disclosure( + DisclosureConnection::new(stream, setup.channel.clone()), + &binding, + CONTENT.len() as u64, + &signer, + ) + .await; + let (bytes, ack_sent) = match received { + Ok(received) => { + assert_eq!(received.content(), CONTENT); + let ack = received + .acknowledgement(&signer) + .expect("native received ACK"); + private( + &setup.path("ack"), + &ack.to_private_bytes().expect("private ACK"), + ); + if !matches!(setup.schedule.phase, Phase::Unknown) || !matches!(setup.run, Run::Worker) + { + received + .acknowledge(&signer) + .await + .expect("native ACK send"); + (CONTENT.len() as u64, true) + } else { + drop(received); + (CONTENT.len() as u64, false) + } + } + Err(code) => { + assert_eq!(code, "gateway.disclosure.read"); + (0, false) + } + }; + private( + &setup.path("recipient-result"), + &serde_json::to_vec(&RecipientResult { + process: std::process::id(), + bytes, + ack_sent, + }) + .expect("result"), + ); +} + +async fn relay(gateway: UnixStream, recipient: UnixStream) -> (bool, u64) { + let (mut from_gateway, mut to_gateway) = gateway.into_split(); + let (mut from_recipient, mut to_recipient) = recipient.into_split(); + let outbound = async { + let mut captured = Vec::new(); + let mut buffer = [0; 1024]; + loop { + let count = from_gateway.read(&mut buffer).await.expect("capture read"); + if count == 0 { + break; + } + assert!(captured.len() + count <= 16_384); + captured.extend_from_slice(&buffer[..count]); + to_recipient + .write_all(&buffer[..count]) + .await + .expect("opaque forwarding"); + } + to_recipient.shutdown().await.expect("forward EOF"); + if captured.is_empty() { + return (false, 0); + } + let length = u32::from_be_bytes( + captured + .get(..4) + .expect("complete challenge prefix") + .try_into() + .expect("four bytes"), + ) as usize; + let content = captured + .get(4 + length..) + .expect("complete challenge frame"); + if !content.is_empty() { + assert_eq!(content.len(), 4 + CONTENT.len()); + assert_eq!( + &content[..4], + &u32::try_from(CONTENT.len()) + .expect("bounded content") + .to_be_bytes() + ); + assert_eq!(&content[4..], CONTENT); + } + (true, content.len() as u64) + }; + let inbound = async { + tokio::io::copy(&mut from_recipient, &mut to_gateway) + .await + .expect("opaque ACK forwarding"); + to_gateway.shutdown().await.expect("recipient EOF"); + }; + let (result, ()) = tokio::join!(outbound, inbound); + result +} + +async fn delivery(engine: &GatewayEngine, setup: &CommitSetup, signal: bool) -> ResultData { + let input = Input::read(&setup.installation.root); + let target = setup.target(engine).await; + let listener = UnixListener::bind(setup.path("sock")).expect("owned gateway socket"); + let mut receiver = spawn(setup, Role::Recipient, None); + let receiver_pid = receiver.0.id(); + let (recipient, _) = listener.accept().await.expect("independent recipient"); + if signal { + let mut channel = crate::native_dependency_tests::connect(setup.installation.barrier_port); + channel.write_all(b"R").expect("ready"); + let mut marker = [0]; + channel.read_exact(&mut marker).expect("release"); + assert_eq!(marker, *b"G"); + } + let (server, recorder) = UnixStream::pair().expect("opaque recorder channel"); + let (result, (challenge_sent, content_wire_bytes)) = tokio::join!( + engine.disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(server, setup.channel.clone()) + ), + relay(recorder, recipient) + ); + receiver.finish(); + let recipient: RecipientResult = serde_json::from_slice( + &std::fs::read(setup.path("recipient-result")).expect("recipient outcome"), + ) + .expect("result"); + assert_eq!(recipient.process, receiver_pid); + assert_ne!(recipient.process, std::process::id()); + ResultData { + process: std::process::id(), + result, + errors: 0, + witness: engine.execution_witness(), + recipient, + challenge_sent, + content_wire_bytes, + } +} + +#[test] +fn native_disclosure_postgres_commit_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: CommitSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let runtime = runtime(); + match setup.role { + Role::Recipient => runtime.block_on(recipient(&setup)), + Role::Gateway => { + let store = TestAttempts::attach(Backend::Postgres, &setup.installation.location); + let witness = Arc::new(CommitWitness::new( + store.raw(), + key(RELEASE), + CrashProtocol::Disclosure, + setup.schedule.stage(), + )); + let attempts = GatewayAttempts::new( + witness.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + "commit-release-worker", + attempts, + controls(Gate::Current), + )); + let mut result = runtime.block_on(delivery(&engine, &setup, true)); + result.errors = witness.errors(); + private( + &setup.path("result"), + &serde_json::to_vec(&result).expect("native result"), + ); + } + } +} + +fn counts(charged: bool) -> BTreeMap { + let mut result = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ("attempt".to_owned(), 1), + ("effect-allocation".to_owned(), 1), + ]); + if charged { + result.insert("attempt".to_owned(), 2); + result.insert("effect-allocation".to_owned(), 2); + result.insert("count-slot".to_owned(), 1); + result.insert("sum-slot".to_owned(), 1); + } + result +} +fn assert_source(case: &Case) { + assert_eq!(case.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!( + case.store + .raw() + .load(GatewayRecordKind::Attempt, &key(SOURCE)) + .expect("load") + .expect("source"), + case.source + ); + for (name, bytes) in ["release.proof", "release.action", "release.approval"] + .iter() + .zip(&case.signed_inputs) + { + assert_eq!( + &std::fs::read(case.setup.installation.root.join(name)).expect("original signed input"), + bytes + ); + } +} +fn setup(case: &Case, schedule: Schedule, run: Run) -> CommitSetup { + serde_json::from_value( + json!({"installation":case.setup.installation,"channel":case.setup.channel, + "schedule":schedule,"role":Role::Gateway,"run":run}), + ) + .expect("closed fixture setup") +} + +fn interrupt(case: &Case, setup: &CommitSetup, proxy: &Proxy, url: &str) -> Barrier { + let mut worker = spawn(setup, Role::Gateway, Some(&proxy.url(url))); + let mut signal = ready(&case.listener); + let mut barrier = Barrier::install_target( + &case.store, + key(RELEASE), + CrashProtocol::Disclosure, + setup.schedule.stage(), + ); + signal.write_all(b"G").expect("release worker"); + let pid = barrier.waiter(); + proxy.hold_replies(); + match setup.schedule.outcome { + Outcome::Committed => { + barrier.release(); + barrier.committed(setup.schedule.retained()); + proxy.wait_for_withheld_reply(); + } + Outcome::Aborted => { + barrier.abort(pid); + barrier.committed(setup.schedule.retained()); + } + } + proxy.disconnect_and_resume(); + worker.finish(); + barrier.retire(); + let result: ResultData = + serde_json::from_slice(&std::fs::read(setup.path("result")).expect("result")) + .expect("native result"); + assert_ne!(result.process, std::process::id()); + assert_ne!(result.process, result.recipient.process); + assert_eq!(result.errors, 1); + assert_eq!( + ( + result.witness.credential_lease_calls, + result.witness.read_transport_entries, + result.witness.write_transport_entries + ), + (0, 0, 0) + ); + match result.result { + Ok(snapshot) => { + assert!(setup.schedule.retained().is_some()); + assert_eq!(snapshot.stage, setup.schedule.projection()); + } + Err(GatewaySubmitResult::Indeterminate { code }) => { + assert_eq!(code, "gateway.attempt.state-unavailable") + } + Err(other) => panic!("unexpected projection: {other:?}"), + } + assert_eq!( + result.recipient.bytes, + if setup.schedule.delivered() { + CONTENT.len() as u64 + } else { + 0 + } + ); + assert_eq!(result.recipient.ack_sent, setup.schedule.ack_sent()); + assert_eq!( + result.content_wire_bytes, + if setup.schedule.delivered() { + (CONTENT.len() + 4) as u64 + } else { + 0 + } + ); + assert_eq!( + result.challenge_sent, + !matches!(setup.schedule.phase, Phase::Admission) + ); + barrier.committed(setup.schedule.final_phase()); + assert_eq!( + case.store.postgres_gateway_record_counts(), + counts(setup.schedule.retained().is_some()) + ); + assert_source(case); + barrier +} + +fn assert_replay( + case: &Case, + engine: &GatewayEngine, + control: &CommitSetup, + expected: &DisclosureSnapshot, + barrier: &mut Barrier, + run: Run, +) { + let rows = barrier.records(); + let witness = engine.execution_witness(); + let replay = setup(case, control.schedule, run); + let result = case.runtime.block_on(delivery(engine, &replay, false)); + assert_eq!(&result.result.expect("retained facts"), expected); + assert_eq!(result.recipient.bytes, 0); + assert!(!result.recipient.ack_sent); + assert!(!result.challenge_sent); + assert_eq!(result.content_wire_bytes, 0); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(barrier.records(), rows); + assert_source(case); +} + +fn late_ack( + case: &Case, + engine: &GatewayEngine, + control: &CommitSetup, + snapshot: &DisclosureSnapshot, + barrier: &mut Barrier, +) -> bool { + let run = if control.schedule.resumable() { + Run::Reopened + } else { + Run::Worker + }; + let acknowledged = setup(case, control.schedule, run); + let path = acknowledged.path("ack"); + if !path.exists() { + assert!(matches!( + (control.schedule.phase, control.schedule.outcome), + (Phase::Entry, Outcome::Committed) + )); + assert_eq!(snapshot.stage, DisclosureStage::Unknown); + return false; + } + let ack = DisclosureAcknowledgement::from_private_bytes( + &std::fs::read(path).expect("actual native ACK"), + ) + .expect("ACK"); + let mut before = barrier.records(); + let charges = case.release_charges.records(&case.store, true); + let witness = engine.execution_witness(); + let after = case + .runtime + .block_on(engine.acknowledge_disclosure(RELEASE, &ack)) + .expect("genuine historical ACK"); + assert_eq!(after.stage, DisclosureStage::Acknowledged); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(case.release_charges.records(&case.store, true), charges); + let mut retained = barrier.records(); + let release = format!("attempt:{}", hex::encode(key(RELEASE).as_bytes())); + before.remove(&release); + retained.remove(&release); + assert_eq!(retained, before); + assert_replay(case, engine, control, &after, barrier, Run::ReplayAfterAck); + true +} + +fn reopen(case: &Case, control: &CommitSetup, barrier: &mut Barrier) -> Value { + let before = barrier.records(); + let source_charges = case.source_charges.records(&case.store, true); + let prior_release_charges = control + .schedule + .retained() + .map(|_| case.release_charges.records(&case.store, true)); + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup.installation, + "commit-release-reopened", + case.store.reopen(), + controls(Gate::Current), + )); + let history = case.runtime.block_on(engine.content_history(RELEASE)); + if control.schedule.retained().is_none() { + assert!(history.is_err()); + } else { + let ContentHistory::Disclosure(actual) = history.expect("history") else { + panic!("wrong protocol"); + }; + assert_eq!(actual.stage, control.schedule.projection()); + } + let snapshot = if control.schedule.resumable() { + let fresh = setup(case, control.schedule, Run::Reopened); + let result = case.runtime.block_on(delivery(&engine, &fresh, false)); + assert_eq!(result.recipient.bytes, CONTENT.len() as u64); + assert!(result.recipient.ack_sent); + assert!(result.challenge_sent); + assert_eq!(result.content_wire_bytes, (CONTENT.len() + 4) as u64); + let result = result.result.expect("native reauthorization"); + assert_eq!(result.stage, DisclosureStage::Acknowledged); + result + } else { + let ContentHistory::Disclosure(snapshot) = case + .runtime + .block_on(engine.content_history(RELEASE)) + .expect("history") + else { + panic!("protocol"); + }; + assert_eq!(barrier.records(), before); + snapshot + }; + assert_eq!( + ( + snapshot.reserved_deliveries, + snapshot.reserved_bytes, + snapshot.policy_count_counters, + snapshot.policy_byte_counters + ), + (1, CONTENT.len() as u64, 1, 1) + ); + let release_charges = case.release_charges.records(&case.store, true); + assert_eq!(release_charges.len(), 3); + if let Some(prior) = prior_release_charges { + assert_eq!(release_charges, prior); + } + assert_eq!( + case.source_charges.records(&case.store, true), + source_charges + ); + assert_replay( + case, + &engine, + control, + &snapshot, + barrier, + Run::ReplayBeforeAck, + ); + let historical_ack = late_ack(case, &engine, control, &snapshot, barrier); + assert_eq!(case.store.postgres_gateway_record_counts(), counts(true)); + assert_source(case); + json!({"phase":control.schedule.phase,"outcome":control.schedule.outcome,"selected_commit_uses_tls":true, + "actual_native_adapter_commit_errors":1,"independent_commit_phase":control.schedule.retained(), + "post_error_native_phase":control.schedule.final_phase(),"new_delivery_allowed":control.schedule.resumable(), + "recipient_deliveries":usize::from(control.schedule.delivered()||control.schedule.resumable()), + "native_snapshot_before_historical_ack":snapshot,"native_historical_ack_refined_or_replayed":historical_ack, + "provider_source_reads":1,"additional_provider_or_custody_calls":0,"one_allocation_count_and_byte_sum_slot":true, + "existing_source_and_charges_conserved":true,"terminal_replay_has_zero_wire_bytes_and_no_journal_or_witness_change":true}) +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_disclosure_commit_reply_loss_fixture_is_current() { + assert!(postgres_configured()); + let (url, port) = fixture_url(); + let mut cases = Vec::new(); + for phase in [ + Phase::Admission, + Phase::Entry, + Phase::Acknowledgement, + Phase::Unknown, + ] { + for outcome in [Outcome::Committed, Outcome::Aborted] { + let schedule = Schedule { phase, outcome }; + let case = Case::new( + Backend::Postgres, + Point::BeforeReservationCommit, + Gate::Current, + ); + let control = setup(&case, schedule, Run::Worker); + let proxy = Proxy::start(port); + let mut barrier = interrupt(&case, &control, &proxy, &url); + cases.push(reopen(&case, &control, &mut barrier)); + } + } + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-commit-reply-loss/1","cases":cases, + "scope":"actual native HTTP source acquisition, native release gateway and recipient in independent OS processes, real TLS COMMIT replies withheld by opaque proxy, independently observed committed/aborted outcomes; native Unix authentication, exact received ACKs and opaque gateway wire capture; fixed public fixture keys/clock, same-UID local processes", + "excluded":["file faults","server or power failure","hostile OS or live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-disclosure-commit-reply-loss.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs index eb64bba40..1d059ebe2 100644 --- a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs @@ -12,6 +12,9 @@ const AMOUNT: u64 = 500; #[path = "native_mutation_pg_batch_tests.rs"] mod postgres_batch_tests; +#[path = "native_mutation_pg_commit_tests.rs"] +mod postgres_commit_tests; + #[derive(Clone, Copy)] enum Limit { Count, diff --git a/product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs b/product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs new file mode 100644 index 000000000..bb3242d40 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs @@ -0,0 +1,366 @@ +//! Real lost mutation COMMIT replies, with an independent TLS observer of the +//! server outcome and an opaque transport that cannot fabricate store decisions. +use super::*; +use crate::native_dependency_tests::Peer as Process; +use crate::native_postgres_commit_tests::{ + Barrier, CommitWitness, Outcome, Phase, Proxy, fixture_url, +}; +use crate::native_postgres_fault_tests::ready; +use std::process::{Command, Stdio}; + +const ENVIRONMENT: &str = "AUTHS_AP074_MUTATION_COMMIT_PEER"; + +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + outcome: Outcome, +} +impl Schedule { + const fn stage(self) -> &'static str { + match self.phase { + Phase::Admission => "reserved", + Phase::Entry => "entry-granted", + Phase::Response => "response-recorded", + } + } + const fn retained(self) -> Option<&'static str> { + match self.outcome { + Outcome::Committed => Some(self.stage()), + Outcome::Aborted => match self.phase { + Phase::Admission => None, + Phase::Entry => Some("reserved"), + Phase::Response => Some("entry-granted"), + }, + } + } + fn resumable(self) -> bool { + matches!(self.retained(), None | Some("reserved")) + } + fn writes(self) -> usize { + usize::from(matches!(self.phase, Phase::Response)) + } + fn projection(self) -> GatewaySubmitResult { + match self.retained() { + Some("reserved") => GatewaySubmitResult::Reserved { revision: 1 }, + Some("response-recorded") => GatewaySubmitResult::ResponseRecorded { status: 200 }, + Some("entry-granted") => GatewaySubmitResult::Unknown, + _ => panic!("absent operation has no retained projection"), + } + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct CommitSetup { + installation: Setup, + schedule: Schedule, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct ResultData { + process: u32, + result: GatewaySubmitResult, + errors: u64, + witness: GatewayExecutionWitness, +} + +fn operation_key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + Flavor::StripePlain.recipe().namespace(), + &LogicalOperationId::parse(OPERATIONS[0]).expect("operation"), + ) + .expect("key") +} + +#[test] +fn native_mutation_postgres_commit_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: CommitSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = TestAttempts::attach(Backend::Postgres, &setup.installation.location); + let witness = Arc::new(CommitWitness::new( + store.raw(), + operation_key(), + CrashProtocol::Mutation, + setup.schedule.stage(), + )); + let attempts = GatewayAttempts::new( + witness.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + "commit-mutation-worker", + attempts, + Flavor::StripePlain.controls(), + )); + let mut signal = crate::native_dependency_tests::connect(setup.installation.barrier_port); + signal.write_all(b"R").expect("ready"); + let mut marker = [0]; + signal.read_exact(&mut marker).expect("release"); + assert_eq!(marker, *b"G"); + let result = runtime.block_on(execute(&engine, &setup.installation.root, OPERATIONS[0])); + private( + &setup.installation.root.join("commit-mutation-result"), + &serde_json::to_vec(&ResultData { + process: std::process::id(), + result, + errors: witness.errors(), + witness: engine.execution_witness(), + }) + .expect("result"), + ); +} + +fn spawn(case: &MutationRace, schedule: Schedule, url: &str) -> Process { + let path = case.setup.root.join("commit-mutation.setup"); + private( + &path, + &serde_json::to_vec(&json!({"installation":case.setup,"schedule":schedule})) + .expect("setup"), + ); + Process(Command::new(std::env::current_exe().expect("test executable")) + .args(["--exact","native_mutation_crash_tests::window_capacity_tests::postgres_commit_tests::native_mutation_postgres_commit_peer","--nocapture"]) + .env(ENVIRONMENT,path).env("AUTHS_POSTGRES_URL",url) + .stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::piped()).spawn().expect("native worker")) +} +fn counts(charged: bool) -> BTreeMap { + let mut result = BTreeMap::from([ + ("connection".to_owned(), 1), + ("effect-configuration".to_owned(), 1), + ]); + if charged { + for kind in ["attempt", "count-slot", "sum-slot"] { + result.insert(kind.to_owned(), 1); + } + } + result +} +fn inputs_unchanged(case: &MutationRace) -> Vec> { + ["proof", "action", "approval", "binding"] + .map(|suffix| { + std::fs::read(case.setup.root.join(format!("{}.{suffix}", OPERATIONS[0]))) + .expect("signed input") + }) + .to_vec() +} + +fn interrupt(case: &MutationRace, schedule: Schedule, proxy: &Proxy, url: &str) -> Barrier { + let mut worker = spawn(case, schedule, &proxy.url(url)); + let mut signal = ready(&case.barrier); + let mut barrier = Barrier::install_target( + &case.store, + operation_key(), + CrashProtocol::Mutation, + schedule.stage(), + ); + signal.write_all(b"G").expect("release worker"); + let pid = barrier.waiter(); + proxy.hold_replies(); + match schedule.outcome { + Outcome::Committed => { + barrier.release(); + barrier.committed(schedule.retained()); + proxy.wait_for_withheld_reply(); + } + Outcome::Aborted => { + barrier.abort(pid); + barrier.committed(schedule.retained()); + } + } + proxy.disconnect_and_resume(); + worker.finish(); + barrier.retire(); + let result: ResultData = serde_json::from_slice( + &std::fs::read(case.setup.root.join("commit-mutation-result")).expect("result"), + ) + .expect("native result"); + assert_ne!(result.process, std::process::id()); + assert_eq!(result.errors, 1); + assert_eq!( + result.witness.credential_lease_calls, + u64::from(!matches!(schedule.phase, Phase::Admission)) + ); + assert_eq!(result.witness.read_transport_entries, 0); + assert_eq!( + result.witness.write_transport_entries, + schedule.writes() as u64 + ); + match &result.result { + GatewaySubmitResult::Indeterminate { code } => { + assert_eq!(code, "gateway.attempt.state-unavailable") + } + GatewaySubmitResult::Unknown => assert!(matches!( + schedule.retained(), + Some("entry-granted" | "response-recorded") + )), + other => assert_eq!(other, &schedule.projection()), + } + assert_eq!(case.provider.calls(), schedule.writes()); + assert_eq!( + case.store.postgres_gateway_record_counts(), + counts(schedule.retained().is_some()) + ); + barrier +} + +fn charges(case: &MutationRace, counters: &[Counter]) -> BTreeMap> { + let mut rows = BTreeMap::new(); + for counter in counters { + let key = counter.key(0); + let bytes = case + .store + .raw() + .load(counter.kind, &key) + .expect("load") + .expect("first charge"); + let value: Value = serde_json::from_slice(&bytes).expect("native charge"); + assert_eq!(value["slot"], 0); + assert_eq!(value["operation_id"], OPERATIONS[0]); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(value["amount"], AMOUNT); + assert_eq!(value["cumulative"], AMOUNT); + } + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(1)) + .expect("no duplicate") + .is_none() + ); + rows.insert( + format!("{:?}:{}", counter.kind, hex::encode(key.as_bytes())), + bytes, + ); + } + rows +} + +fn reopen( + case: &MutationRace, + schedule: Schedule, + counters: &[Counter], + barrier: &mut Barrier, +) -> Value { + let before = barrier.records(); + let prior_charges = schedule.retained().map(|_| charges(case, counters)); + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup, + "commit-mutation-reopened", + case.store.reopen(), + Flavor::StripePlain.controls(), + )); + let operation = LogicalOperationId::parse(OPERATIONS[0]).expect("operation"); + let history = case + .runtime + .block_on( + case.store + .attempts() + .read(Flavor::StripePlain.recipe().namespace(), &operation), + ) + .expect("history"); + if schedule.retained().is_none() { + assert!(history.is_none()); + } else { + assert_eq!( + crate::engine::stored_result(&history.expect("retained facts")), + schedule.projection() + ); + } + let witness = engine.execution_witness(); + let result = case + .runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])); + assert_eq!( + result, + if schedule.resumable() { + GatewaySubmitResult::ResponseRecorded { status: 200 } + } else { + schedule.projection() + } + ); + if !schedule.resumable() { + assert_eq!(engine.execution_witness(), witness); + assert_eq!(barrier.records(), before); + } + let total = schedule.writes() + usize::from(schedule.resumable()); + assert_eq!(case.provider.calls(), total); + if total == 1 { + assert_eq!( + case.provider.requests.lock().expect("requests")[0].body, + std::fs::read(case.setup.root.join(format!("{}.body", OPERATIONS[0]))) + .expect("exact native body") + ); + } + let slots = charges(case, counters); + assert_eq!(slots.len(), 2); + if let Some(prior) = prior_charges { + assert_eq!(slots, prior); + } + assert_eq!(case.store.postgres_gateway_record_counts(), counts(true)); + let record = case + .store + .raw() + .load(GatewayRecordKind::Attempt, &operation_key()) + .expect("load") + .expect("record"); + let value: Value = serde_json::from_slice(&record).expect("record"); + assert_eq!(value["evaluated_at"], NOW); + let rows = barrier.records(); + let witness = engine.execution_witness(); + assert_eq!( + case.runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])), + result + ); + assert_eq!(barrier.records(), rows); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(charges(case, counters), slots); + assert_eq!(case.provider.calls(), total); + json!({"phase":schedule.phase,"outcome":schedule.outcome,"selected_commit_uses_tls":true, + "actual_native_adapter_commit_errors":1,"independently_observed_commit_phase":schedule.retained(), + "provider_writes_before_reopen":schedule.writes(),"new_execution_allowed":schedule.resumable(), + "provider_writes_after_reopen":total,"native_result":result, + "exact_native_body_captured_when_sent":true,"one_count_and_one_amount_sum_slot":true, + "all_terminal_rows_and_execution_witness_unchanged_on_replay":true}) +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_mutation_commit_reply_loss_fixture_is_current() { + assert!(postgres_configured()); + let (url, port) = fixture_url(); + let mut cases = Vec::new(); + for phase in [Phase::Admission, Phase::Entry, Phase::Response] { + for outcome in [Outcome::Committed, Outcome::Aborted] { + let schedule = Schedule { phase, outcome }; + let case = MutationRace::new(Backend::Postgres); + let proxy = Proxy::start(port); + let counters = case.runtime.block_on(inputs( + &case.engine, + &case.setup.root, + OPERATIONS[0], + Limit::Both, + )); + let signed = inputs_unchanged(&case); + let mut barrier = interrupt(&case, schedule, &proxy, &url); + let result = reopen(&case, schedule, &counters, &mut barrier); + assert_eq!(inputs_unchanged(&case), signed); + cases.push(result); + } + } + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-commit-reply-loss/1","cases":cases, + "scope":"full native Stripe mutation with native signed bounded proof/exact approval, separate worker OS processes, actual end-to-end TLS COMMIT replies withheld by an opaque proxy, server-deferred barrier and independent TLS transaction-outcome observer, counting local provider without deduplication; fixed public test keys/clock", + "excluded":["file faults","server or power failure","hostile OS and live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-mutation-commit-reply-loss.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs b/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs index f6f82b95d..0bdb8d0f2 100644 --- a/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs +++ b/product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs @@ -96,13 +96,13 @@ fn attach( })); } -pub(super) struct Proxy { +pub(crate) struct Proxy { port: u16, shared: Arc, service: Option>, } impl Proxy { - pub(super) fn start(upstream_port: u16) -> Self { + pub(crate) fn start(upstream_port: u16) -> Self { let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).expect("proxy listener"); listener.set_nonblocking(true).expect("proxy polling"); let port = listener.local_addr().expect("proxy address").port(); @@ -140,7 +140,7 @@ impl Proxy { service: Some(service), } } - pub(super) fn url(&self, original: &str) -> String { + pub(crate) fn url(&self, original: &str) -> String { let mut replaced = 0; let parts: Vec<_> = original .split_ascii_whitespace() @@ -159,11 +159,11 @@ impl Proxy { ); parts.join(" ") } - pub(super) fn hold_replies(&self) { + pub(crate) fn hold_replies(&self) { assert!(!self.shared.hold.swap(true, Ordering::SeqCst)); assert_eq!(self.shared.withheld.load(Ordering::SeqCst), 0); } - pub(super) fn wait_for_withheld_reply(&self) { + pub(crate) fn wait_for_withheld_reply(&self) { let deadline = Instant::now() + Duration::from_secs(1); while self.shared.withheld.load(Ordering::SeqCst) == 0 { assert!( @@ -173,7 +173,7 @@ impl Proxy { thread::sleep(Duration::from_millis(1)); } } - pub(super) fn disconnect_and_resume(&self) { + pub(crate) fn disconnect_and_resume(&self) { self.shared.disconnect(); } } diff --git a/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs b/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs index 60feaf92d..f0308e538 100644 --- a/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs +++ b/product/runtime/auths-gateway/src/native_postgres_commit_tests.rs @@ -1,5 +1,6 @@ //! Real lost COMMIT replies over end-to-end TLS, with independent observation //! of both possible transaction outcomes. No adapter result is fabricated. +use crate::native_crash_tests::CrashProtocol; use crate::native_process_tests::{ NOW, Provider, Setup, acquire, authorize_policy, load_engine, private, recipe, runtime, }; @@ -34,15 +35,15 @@ use std::{ }; #[path = "native_postgres_commit_proxy.rs"] -mod proxy; -use proxy::Proxy; +pub(crate) mod proxy; +pub(crate) use proxy::Proxy; const OPERATION: &str = "commit-reply-loss"; const LOCK_GROUP: i32 = 1_095_780_184; #[derive(Clone, Copy, Debug, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] -enum Phase { +pub(crate) enum Phase { Admission, Entry, Response, @@ -58,7 +59,7 @@ impl Phase { } #[derive(Clone, Copy, Debug, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] -enum Outcome { +pub(crate) enum Outcome { Committed, Aborted, } @@ -110,18 +111,40 @@ fn key() -> GatewayAttemptKey { } /// Records only actual adapter errors after the unchanged native decision. -struct CommitWitness { +pub(crate) struct CommitWitness { inner: Arc, - phase: Phase, + key: GatewayAttemptKey, + protocol: CrashProtocol, + stage: &'static str, errors: AtomicU64, } impl CommitWitness { + pub(crate) fn new( + inner: Arc, + key: GatewayAttemptKey, + protocol: CrashProtocol, + stage: &'static str, + ) -> Self { + Self { + inner, + key, + protocol, + stage, + errors: AtomicU64::new(0), + } + } + pub(crate) fn errors(&self) -> u64 { + self.errors.load(Ordering::SeqCst) + } fn selected(&self, kind: GatewayRecordKind, target: GatewayAttemptKey, bytes: &[u8]) -> bool { - if kind != GatewayRecordKind::Attempt || target != key() { + if kind != GatewayRecordKind::Attempt || target != self.key { return false; } let record: Value = serde_json::from_slice(bytes).expect("native decision"); - record["state"]["facts"]["phase"]["stage"] == self.phase.stage() + record + .pointer(self.protocol.stage_pointer()) + .and_then(Value::as_str) + == Some(self.stage) } fn observe( &self, @@ -211,11 +234,12 @@ fn native_postgres_commit_peer() { let setup: CommitSetup = serde_json::from_slice(&std::fs::read(input).expect("setup")).expect("closed setup"); let store = TestAttempts::attach(Backend::Postgres, &setup.installation.location); - let witness = Arc::new(CommitWitness { - inner: store.raw(), - phase: setup.schedule.phase, - errors: AtomicU64::new(0), - }); + let witness = Arc::new(CommitWitness::new( + store.raw(), + key(), + CrashProtocol::Acquisition, + setup.schedule.phase.stage(), + )); let attempts = GatewayAttempts::new( witness.clone(), crate::effect::fixture_policy().expect("policy"), @@ -234,7 +258,7 @@ fn native_postgres_commit_peer() { assert_eq!(start, *b"G"); let result = runtime.block_on(acquire(&engine, &setup.installation.root, OPERATION)); let result = WorkerResult { - errors: witness.errors.load(Ordering::SeqCst), + errors: witness.errors(), witness: engine.execution_witness(), result, }; @@ -244,24 +268,46 @@ fn native_postgres_commit_peer() { ); } -struct Barrier { +pub(crate) struct Barrier { client: Client, schema: String, lock: i32, + key: GatewayAttemptKey, + protocol: CrashProtocol, } impl Barrier { fn install(store: &TestAttempts, phase: Phase) -> Self { + Self::install_target(store, key(), CrashProtocol::Acquisition, phase.stage()) + } + pub(crate) fn install_target( + store: &TestAttempts, + key: GatewayAttemptKey, + protocol: CrashProtocol, + stage: &'static str, + ) -> Self { + assert!(matches!( + stage, + "reserved" + | "entry-granted" + | "response-recorded" + | "content-response-recorded" + | "unknown" + | "acknowledged" + )); let (schema, mut client) = store.postgres_commit_observer(); let lock: i32 = client.query_one(&format!("SELECT (('{schema}.auths_gateway_records'::regclass::oid)::bigint - 2147483648)::integer"), &[]).expect("table lock identity").get(0); client .query_one("SELECT pg_advisory_lock($1, $2)", &[&LOCK_GROUP, &lock]) .expect("commit barrier"); - let stage = phase.stage(); - let target = hex::encode(key().as_bytes()); + let target = hex::encode(key.as_bytes()); + let path = protocol + .stage_pointer() + .trim_start_matches('/') + .replace('/', ","); client.batch_execute(&format!( "CREATE FUNCTION {schema}.fixture_commit_barrier() RETURNS trigger LANGUAGE plpgsql AS $body$ BEGIN - IF convert_from(NEW.record_bytes, 'UTF8')::jsonb #>> '{{state,facts,phase,stage}}' = '{stage}' THEN + IF convert_from(NEW.record_bytes, 'UTF8')::jsonb #>> '{{{path}}}' = '{stage}' THEN PERFORM pg_advisory_xact_lock({LOCK_GROUP}, {lock}); END IF; RETURN NEW; @@ -275,9 +321,11 @@ impl Barrier { client, schema, lock, + key, + protocol, } } - fn waiter(&mut self) -> i32 { + pub(crate) fn waiter(&mut self) -> i32 { let deadline = Instant::now() + Duration::from_secs(1); let group = i64::from(LOCK_GROUP); let object = i64::from(u32::from_ne_bytes(self.lock.to_ne_bytes())); @@ -295,7 +343,7 @@ impl Barrier { thread::sleep(Duration::from_millis(1)); } } - fn release(&mut self) { + pub(crate) fn release(&mut self) { let released: bool = self .client .query_one( @@ -306,7 +354,7 @@ impl Barrier { .get(0); assert!(released); } - fn abort(&mut self, pid: i32) { + pub(crate) fn abort(&mut self, pid: i32) { let terminated: bool = self .client .query_one("SELECT pg_terminate_backend($1)", &[&pid]) @@ -334,10 +382,15 @@ impl Barrier { } self.release(); } - fn phase(&mut self) -> Option { - self.client.query_opt(&format!("SELECT convert_from(record_bytes, 'UTF8')::jsonb #>> '{{state,facts,phase,stage}}' FROM {}.auths_gateway_records WHERE record_key = $1", self.schema), &[&&key().as_bytes()[..]]).expect("committed state").map(|row| row.get(0)) + pub(crate) fn phase(&mut self) -> Option { + let path = self + .protocol + .stage_pointer() + .trim_start_matches('/') + .replace('/', ","); + self.client.query_opt(&format!("SELECT convert_from(record_bytes, 'UTF8')::jsonb #>> '{{{path}}}' FROM {}.auths_gateway_records WHERE record_kind = 'attempt' AND record_key = $1", self.schema), &[&&self.key.as_bytes()[..]]).expect("committed state").map(|row| row.get(0)) } - fn committed(&mut self, expected: Option<&str>) { + pub(crate) fn committed(&mut self, expected: Option<&str>) { let deadline = Instant::now() + Duration::from_secs(1); loop { if self.phase().as_deref() == expected { @@ -350,7 +403,7 @@ impl Barrier { thread::sleep(Duration::from_millis(1)); } } - fn retire(&mut self) { + pub(crate) fn retire(&mut self) { self.client .batch_execute(&format!( "DROP TRIGGER fixture_commit_barrier ON {}.auths_gateway_records", @@ -358,12 +411,12 @@ impl Barrier { )) .expect("retire trigger"); } - fn records(&mut self) -> BTreeMap> { - self.client.query(&format!("SELECT encode(record_key, 'hex'), record_bytes FROM {}.auths_gateway_records ORDER BY record_key", self.schema), &[]).expect("record snapshot").into_iter().map(|row| (row.get(0), row.get(1))).collect() + pub(crate) fn records(&mut self) -> BTreeMap> { + self.client.query(&format!("SELECT record_kind, encode(record_key, 'hex'), record_bytes FROM {}.auths_gateway_records ORDER BY record_kind, record_key", self.schema), &[]).expect("record snapshot").into_iter().map(|row| (format!("{}:{}", row.get::<_,String>(0),row.get::<_,String>(1)), row.get(2))).collect() } } -fn fixture_url() -> (String, u16) { +pub(crate) fn fixture_url() -> (String, u16) { let url = std::env::var("AUTHS_POSTGRES_URL").expect("fixture URL"); let config = Config::from_str(&url).expect("fixture parameters"); assert_eq!(config.get_ssl_mode(), SslMode::Require); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index f9282ee71..95735d351 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "ed250726fc4863fa0ead03cc3cf30857958af791d74be23386afbb1bd9004894"; + "706b8c79a4cea91b9b366ca4dc99c500afbca2e9b1aec1e4835d77d73cc0b357"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 31cc0f699..598600985 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 419 +freeze_version = 420 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 419 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 162 +"auths.identity.protocol" = 163 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 419 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 159 +"auths.product.public-sdk-contract" = 160 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 419 +"auths.release.public-surface" = 420 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 29d61dbe9..72a36d75b 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 419, + "freezeVersion": 420, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 162, + "version": 163, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "9be14d24405f47726c04d54a595986bdd251cbc94085231cb67233a35e1fe4f3" + "sha256": "e22ae97f08b3c422ce2b9279bbd4faef2f0b75c07c21ff1394791b62528a99b2" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 159, + "version": 160, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "aa26eb8e034162f11f0f222700f052b041444aa564ee9ac129876eb691592987" + "sha256": "19f659691a731f26371c9b39b7aa2fa2ff3ebda339035ef369993454c552b16d" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 419, + "version": 420, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "cbb067b6614cf19f17ed21e026b1a112ae0324637a6967ccb0ad0befc4017702" + "sha256": "de00eb8c7528d3d3ed72600298b8cfbd2601c659010962ab2ddef9156aef64de" } ] } From a21295935e769c288c453488a319e5d601026dca Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 00:51:31 +0000 Subject: [PATCH 109/136] test(gateway): place entry evidence imports before statements --- .../runtime/auths-gateway/src/native_disclosure_entry_tests.rs | 3 ++- .../runtime/auths-gateway/src/native_mutation_entry_tests.rs | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs index e54fb1fdb..a95757d4b 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs @@ -594,6 +594,8 @@ async fn selected_evidence( target: &crate::effect::DisclosureTarget, input: &mut Input, ) -> Option { + use crate::observed_tests::threshold_testkit as kit; + if !matches!( race.scenario, Scenario::ObserverValid @@ -603,7 +605,6 @@ async fn selected_evidence( ) { return None; } - use crate::observed_tests::threshold_testkit as kit; let threshold = matches!( race.scenario, Scenario::ThresholdValid | Scenario::ThresholdChanged diff --git a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs index ccfdf2264..c436c053a 100644 --- a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs @@ -435,6 +435,8 @@ async fn selected_evidence( race: &Race, input: &mut Input, ) -> Option { + use crate::observed_tests::threshold_testkit as kit; + if !matches!( race.scenario, Scenario::ObserverValid @@ -444,7 +446,6 @@ async fn selected_evidence( ) { return None; } - use crate::observed_tests::threshold_testkit as kit; let threshold = matches!( race.scenario, Scenario::ThresholdValid | Scenario::ThresholdChanged From d9cea9146ada4ef83449b1854a44e89244a56e8c Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 01:07:46 +0000 Subject: [PATCH 110/136] test(gateway): exercise mutation and disclosure file persistence errors --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-disclosure-file-io-faults.json | 425 ++++++++++++++ .../native-mutation-file-io-faults.json | 246 ++++++++ compliance.toml | 2 + ...017-bound-effect-and-recovery-ownership.md | 23 + docs/plans/0074-implementation-status.md | 63 +- .../0009-bound-effect-and-recovery.md | 10 + ...ound-effects-and-recovery-state-machine.md | 17 + .../auths-gateway/semantic-closure.json | 2 +- .../src/native_disclosure_crash_testkit.rs | 15 +- .../src/native_disclosure_crash_tests.rs | 3 + .../src/native_disclosure_file_fault_tests.rs | 536 ++++++++++++++++++ .../src/native_disclosure_pg_commit_tests.rs | 2 +- .../src/native_file_fault_tests.rs | 52 +- .../src/native_mutation_budget_tests.rs | 3 + .../src/native_mutation_file_fault_tests.rs | 382 +++++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 19 files changed, 1778 insertions(+), 29 deletions(-) create mode 100644 bindings/fixtures/gateway/native-disclosure-file-io-faults.json create mode 100644 bindings/fixtures/gateway/native-mutation-file-io-faults.json create mode 100644 product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 94df5ce58..0d8645380 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -68,6 +68,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::window_capacity_tests::native_file_disclosure_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::window_capacity_tests::postgres_native_disclosure_window_capacity_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::file_fault_tests::native_file_mutation_io_fault_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::file_fault_tests::native_file_disclosure_io_fault_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_batch_tests::postgres_native_mutation_partial_batch_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_batch_tests::postgres_native_disclosure_partial_batch_fixture_is_current diff --git a/bindings/fixtures/gateway/native-disclosure-file-io-faults.json b/bindings/fixtures/gateway/native-disclosure-file-io-faults.json new file mode 100644 index 000000000..eb7fdc859 --- /dev/null +++ b/bindings/fixtures/gateway/native-disclosure-file-io-faults.json @@ -0,0 +1,425 @@ +{ + "schema": "auths.native-disclosure-file-io-faults/1", + "cases": [ + { + "phase": "admission", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "install-batch", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 1, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 2, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 3, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 1, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 2, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "entry", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "entry", + "point": "replace", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "new_native_delivery_allowed": true, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "entry", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "new_native_delivery_allowed": false, + "recipient_deliveries": 0, + "native_snapshot_before_historical_ack": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": false, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "acknowledgement", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "unknown", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "acknowledgement", + "point": "replace", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "unknown", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "acknowledgement", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "acknowledged", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "unknown", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "unknown", + "point": "replace", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 2, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + }, + { + "phase": "unknown", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "unknown", + "new_native_delivery_allowed": false, + "recipient_deliveries": 1, + "native_snapshot_before_historical_ack": { + "revision": 3, + "stage": "unknown", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 1, + "policy_byte_counters": 1 + }, + "native_historical_ack_refined_or_replayed": true, + "provider_source_reads": 1, + "additional_custody_or_provider_calls": 0, + "existing_source_and_charges_preserved": true, + "one_lifetime_allocation_count_and_byte_sum_slot": true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change": true + } + ], + "scope": "native source HTTP acquisition, release gateway and recipient in independent OS processes over same-UID Unix sockets, opaque wire capture, maintained file writer fence and four-row admission; syscall error simulated at actual adapter site, preceding writes/rollback/ACK/replay use maintained code and public fixture keys/clock", + "excluded": [ + "actual kernel/device EIO or power loss", + "whole-store rollback", + "hostile OS or live-provider qualification" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-file-io-faults.json b/bindings/fixtures/gateway/native-mutation-file-io-faults.json new file mode 100644 index 000000000..95f3f2523 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-file-io-faults.json @@ -0,0 +1,246 @@ +{ + "schema": "auths.native-mutation-file-io-faults/1", + "cases": [ + { + "phase": "admission", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "install-batch", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 1, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "install-target", + "skip": 2, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 1, + "injected_io_failures": 1, + "retained_phase_after_failure": null, + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "admission", + "point": "directory-sync", + "skip": 2, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "entry", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "entry", + "point": "replace", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "reserved", + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": true, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "entry", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "provider_writes_before_reopen": 0, + "new_native_execution_allowed": false, + "provider_writes_after_reopen": 0, + "native_result": { + "outcome": "unknown" + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "response", + "point": "data-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "provider_writes_before_reopen": 1, + "new_native_execution_allowed": false, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "unknown" + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "response", + "point": "replace", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "entry-granted", + "provider_writes_before_reopen": 1, + "new_native_execution_allowed": false, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "unknown" + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + }, + { + "phase": "response", + "point": "directory-sync", + "skip": 0, + "injected_io_failures": 1, + "retained_phase_after_failure": "response-recorded", + "provider_writes_before_reopen": 1, + "new_native_execution_allowed": false, + "provider_writes_after_reopen": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "one_count_and_one_amount_sum_slot": true, + "no_source_lifetime_allocation_for_mutation": true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness": true + } + ], + "scope": "native Stripe mutation in separate worker processes, actual maintained file writer fence and three-row atomic admission, rollback/reopen, native bounded proof/exact approval and counting local HTTP; I/O failure return simulated at adapter call site, fixed public fixture keys/clock", + "excluded": [ + "actual kernel/device EIO or power loss", + "whole-store rollback", + "hostile OS and live-provider qualification" + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index 52f2b30c4..0bdb736f4 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1832,6 +1832,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs#native_file_disclosure_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs#postgres_native_disclosure_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_file_fault_tests.rs#native_file_io_fault_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs#native_file_mutation_io_fault_fixture_is_current", + "product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs#native_file_disclosure_io_fault_fixture_is_current", "product/runtime/auths-gateway/src/native_postgres_fault_tests.rs#postgres_native_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs#postgres_native_mutation_partial_batch_fixture_is_current", "product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs#postgres_native_disclosure_partial_batch_fixture_is_current", diff --git a/docs/adr/0017-bound-effect-and-recovery-ownership.md b/docs/adr/0017-bound-effect-and-recovery-ownership.md index 5a184d7e1..98d680486 100644 --- a/docs/adr/0017-bound-effect-and-recovery-ownership.md +++ b/docs/adr/0017-bound-effect-and-recovery-ownership.md @@ -1383,3 +1383,26 @@ is invented when a lost grant sent no content. This is native transaction/transp evidence under fixture keys, clocks and same-UID local process policy; file faults, server/power loss, hostile OS containment and live-provider qualification remain separate work. + +## Native file-error parity across typed protocols + +The existing acquisition file-error selector now accepts an exact operation key +and typed native stage path. It still forwards each native decision unchanged and +arms only the maintained adapter's test-only syscall-error site. Fourteen mutation +and eighteen disclosure schedules cover batch data sync/publication, every target +install, all three admission directory-sync points, and data-sync/replace/directory +sync errors at grant and protocol outcome persistence. Failed syscall returns are +simulated; actual preceding writes, writer fences, rollback recovery, native +authorization and transport execute unchanged. + +Mutation atomically retains or removes attempt/count/amount-sum rows and has no +disclosure lifetime allocation. Disclosure preserves its actual source and charges +while treating ACK and Unknown as separate facts. A native recipient in another +OS process may deliberately withhold its ACK after exact content receipt; its +genuine signed ACK is retained for historical refinement. An opaque Unix relay +measures all gateway content frames. Lost grants never recreate permits or send +content, even with zero prior delivery. Absent/reserved work requires native +reauthorization; terminal replay and historical ACK refinement perform no new I/O +or charging. Existing charge bytes remain intact. These test-only additions do +not change a shipping owner, and establish neither actual kernel/device EIO, +power-loss/whole-store rollback safety nor hostile OS/provider qualification. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index eb7da028e..c446f0fd5 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3371,6 +3371,65 @@ Semantic inventory construction advances freeze420 and only its reported changed identity163/public-SDK160/public-surface420 subjects. Formal translation closure remains a002; these construction results are not fresh hosted or formal evidence. +## Native mutation/disclosure file-error checkpoint + +Thirty-two new native histories extend the maintained file-adapter error harness: +fourteen mutation schedules and eighteen disclosure schedules. Mutation admission +has three rows (attempt/count/amount sum); disclosure has four (attempt/lifetime +allocation/count/byte sum), in addition to its separately acquired source. Tests +simulate errors at batch data sync/publication, every target install and all three +admission directory-sync calls. Grant and protocol outcome persistence each cover +data sync, replacement and directory sync, including separate disclosure ACK and +Unknown transitions. The transparent selector now accepts an exact operation key +and typed native stage path and forwards every native decision unchanged. + +Workers run in separate OS processes and report exactly one reached adapter +failure site. Error returns are simulated; actual preceding writes, private file +permissions, native verification/approval, writer fences, all-or-none rollback and +transport execute unchanged. Pre-grant work retains no entry permission and can +continue only through full native reauthorization after reopening. A grant that +was installed before a lost directory-sync acknowledgement stays charged Unknown +even with zero actual send. Response or ACK persistence that did complete retains +its stronger fact. Terminal replay changes no journal bytes, execution witness or +charges and performs no new I/O. + +Disclosure uses a native recipient in another OS process and the existing opaque +Unix relay. Failed admission emits no challenge/content; failed final grant emits +no content. The recipient can deliberately withhold its network ACK only after +checking exact received content and storing its genuine native signed ACK. Failed +ACK persistence follows the existing native Unknown path, while a persisted ACK +cannot be overwritten with Unknown. Historical ACK submission can refine retained +uncertainty without new delivery, provider/custody access or changed source/charge +bytes. No ACK is invented for a lost grant that sent nothing. The sole provider +read remains the original acquisition. First-slot count/sum/lifetime records are +retained once, with no hidden duplicate or refund. Mutation has no disclosure +source-lifetime allocation. + +Required exact artifact constructors passed with one matched, nonignored test: +mutation 3.00s and disclosure 7.75s. The original acquisition file-error artifact +passed without update mode in 3.40s, and the original native disclosure file-crash +artifact passed without update mode in 13.34s after the recipient helper extension; +both committed artifacts stayed byte-identical. The workflow retains all prior 40 +native selectors and adds two for 42. The modeled file-error corpus now has 47 +histories across acquisition/mutation/disclosure. Compliance anchors name the two +new constructors. No shipping runtime/store or decision owner changed. + +The CI subagent's two-site import-order repair is integrated as `a2129593` before +closure refresh. Both imports moved ahead of statements; assertions, behavior and +fixtures are unchanged. Its isolated reproduction of the actual failed strict +Clippy check passed. Main did not inspect CI or duplicate that check. + +These are local constructor results, not new-head hosted qualification or proof +of actual kernel/device EIO, power loss, whole-store rollback, hostile OS isolation +or live-provider behavior. Remaining adverse/installed/runtime-refinement and +durability assumptions stay explicit. A06/A08 remain partial. AP070 and the paused +AP073 worktree are untouched; all CI inspection/publication remains delegated. + +Native source-closure construction and rebuilt non-update verification passed. +Semantic metadata construction advances freeze421 and only reported changed +identity164/public-SDK161/public-surface421 subjects. Formal translation closure +remains a002; metadata construction is not new hosted or formal qualification. + ## Phase gates | Phase | State | Outstanding gate | @@ -3394,9 +3453,9 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | | A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | | A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / native file I/O failures, server-rejected PostgreSQL batches and actual COMMIT reply loss / fifteen acquisition file faults, eleven admission-prefix aborts and twenty committed/aborted reply-loss histories across all protocols | Mutation/disclosure file I/O schedules and remaining durability/adverse cases required | +| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / 47 modeled file-error histories, eleven actual PostgreSQL admission-prefix aborts and twenty committed/aborted reply-loss histories across all protocols | Remaining adverse/installed cases and runtime-refinement/durability assumptions required | | A07 | Revoke between acquisition and disclosure | Partial / daemon corpus plus native file/TLS PostgreSQL worker/operator release races / withdrawal before final grant produces no post-authentication wire bytes or ACK, while grant-first records exact delivery/ACK | Complete revocation scopes and installed boundary races | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash and actual COMMIT-reply-loss corpora / fifty-six release crash histories plus eight committed/aborted release transactions cover lost grant replies, ACK/Unknown persistence, late genuine ACKs and no redelivery with conserved charges | Remaining file I/O-error, adverse races and full installed boundary evidence pending | +| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash, commit-reply loss and file-error corpora / fifty-six release crash histories, eight committed/aborted release transactions and eighteen file-error histories retain charges through lost grants and ACK/Unknown persistence; genuine late ACKs never authorize redelivery | Remaining adverse races, runtime links and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | | A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index e873d5689..a699f3f84 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -938,3 +938,13 @@ grant and historical ACK owners are unchanged. Late recipient evidence may refine Unknown, while lost grants and terminal replay cannot authorize I/O or new charges. The additional six mutation/eight disclosure histories introduce no shipping abstraction, provider branch or application-owned decision system. + +Native file-error fixtures reuse the acquisition adapter's exact call-site fault +control with typed mutation/disclosure stage selection. They add fourteen +mutation and eighteen disclosure histories, including separate ACK and Unknown +persistence. The only recipient fixture extension deliberately withholds a native +ACK after verified receipt; it introduces no new approval or grant authority. +Opaque wire capture, raw file/charge comparisons, native reauthorization and +historical ACK refinement exercise the existing owners. This is test-only parity +under simulated syscall returns, not extraction of a shipping lifecycle mechanism +or qualification of kernel/device/power-loss behavior. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index bf0a2d9a7..13bc7789c 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -805,6 +805,23 @@ request. The failed I/O return is simulated, and production builds contain no selector. Actual device faults/power loss, PostgreSQL commit delivery and the complete mutation/disclosure fault matrix remain separate requirements. +`native-mutation-file-io-faults.json` adds fourteen native mutation schedules for +the three-row admission batch, grant and response persistence. +`native-disclosure-file-io-faults.json` adds eighteen release schedules for its +four-row admission batch, grant, exact ACK and Unknown persistence. Both use the +same actual file writer fence and syscall-error selector as acquisition, with +typed stage paths and operation keys. They cover batch data sync/publication, +each target install and all three admission directory-sync points, plus data +sync/replace/directory sync at the modeled grant/outcome boundaries. Error returns +are simulated; preceding writes, rollback/reopen, native decisions, transport +and recipient signatures execute unchanged. Existing source and charge bytes +remain intact. A lost grant acknowledgement sends nothing and never remints a +permit; absent/reserved work continues only through native reauthorization. +Separate native recipients and opaque Unix wire capture verify exact delivery +or zero content, and genuine historical ACKs refine retained uncertainty without +redelivery or new charging. These histories do not qualify actual kernel/device +EIO, power-loss/whole-store rollback, hostile OS containment or live providers. + `native-postgres-partial-batch.json` separately rejects each insert of a four-record native admission transaction using a server trigger confined to an owned test schema. A nontransactional sequence witnesses the reached row prefix, diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index cdd312d29..24bf88376 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"7749be04fc61faffda398df6b7655d47a6378d4f068d127b7d7728f90fbf1a5c"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"69f387fce82f44d6de7aca93fa30a185302fa45e98546b43c4d05f44d2b47a40"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"3c869d48b7e0d55f7b49046b75dc2dd06665e2beba329b5850ccc30bc875968e"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"affe9ded085abfb3954b24f235dd545b44127603e21b5c0c5d11e0a108bb355a"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"a14ceb28d18eaf85acb3b8880ad06801a3001d9f09e40c81918e8d7ead598949"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"3ed93201c69b94104e00516bde614761c562e2a679c738603f398283ead58a44"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"600b0727cdb6f44f85e3cbe44c801fa5f074f3c35684abab31d76fb65b6ce6bd"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"cdc1e051cb0a51521195281d1e78fff07067ccf21c3335064b0de9a06086e454"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"861ebc3df0aca81c7d7b67d9dced049efbdfd008d466fef3d9ea4cfe34379a9d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"492391f3839c5314efcebfc9ab35a9abd73d7e51627a6d25080c1456f29a92f8"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"b68e122728e8a13de303d201f90b9795fc7a5e5ae65742dda188f85d1741f302"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"e9bf6376d2ccbbd9fea1d841ca266aadf5184262b4d18f56c6e863a61475ded5"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"cdc1e051cb0a51521195281d1e78fff07067ccf21c3335064b0de9a06086e454"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs index 18fc88599..401460616 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs @@ -37,6 +37,7 @@ pub(super) enum Role { Gateway, Recipient, ResumeRecipient, + RecipientWithoutAck, } #[derive(Deserialize, Serialize)] @@ -302,6 +303,9 @@ pub(super) async fn recipient(setup: &CrashSetup, resume: bool) { &root.join(format!("{prefix}-result.json")), &serde_json::to_vec(&json!({"received_full":true,"bytes":CONTENT.len()})).expect("result"), ); + if matches!(setup.role, Role::RecipientWithoutAck) { + return; + } if !resume && matches!(setup.point, Point::AfterDeliveryBeforeAck) { let port = setup.installation.barrier_port; tokio::task::spawn_blocking(move || pause_at(port)) @@ -314,12 +318,20 @@ pub(super) async fn recipient(setup: &CrashSetup, resume: bool) { pub(super) struct Recipient(Child); impl Recipient { pub(super) fn start(setup: &CrashSetup, resume: bool) -> Self { + Self::start_mode(setup, resume, true) + } + pub(super) fn without_ack(setup: &CrashSetup) -> Self { + Self::start_mode(setup, false, false) + } + fn start_mode(setup: &CrashSetup, resume: bool, acknowledge: bool) -> Self { let path = setup.installation.root.join(if resume { "resume-recipient-setup.json" } else { "recipient-setup.json" }); - let role = if resume { + let role = if !acknowledge { + Role::RecipientWithoutAck + } else if resume { Role::ResumeRecipient } else { Role::Recipient @@ -387,6 +399,7 @@ pub(super) fn peer() { Role::Gateway => Box::pin(gateway(&setup)).await, Role::Recipient => recipient(&setup, false).await, Role::ResumeRecipient => recipient(&setup, true).await, + Role::RecipientWithoutAck => recipient(&setup, false).await, } }); } diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs index a8bafefbf..793641627 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs @@ -43,6 +43,9 @@ mod postgres_batch_tests; #[path = "native_disclosure_pg_commit_tests.rs"] mod postgres_commit_tests; +#[path = "native_disclosure_file_fault_tests.rs"] +mod file_fault_tests; + const SOURCE: &str = "crash-release-source"; const RELEASE: &str = "crash-release"; diff --git a/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs new file mode 100644 index 000000000..8c8fe4926 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs @@ -0,0 +1,536 @@ +//! Simulated file syscall errors exercise native release persistence, independent +//! recipient processes and exact historical ACKs without fabricating decisions. +use super::*; +use crate::native_dependency_tests::Peer as Process; +use crate::native_file_fault_tests::{FailureStore, journal_files}; +use crate::store::FileIoPoint; +use crate::{FileGatewayAttemptStore, GatewayExecutionWitness, GatewaySubmitResult}; +use std::{ + process::{Command, Stdio}, + sync::Arc, +}; + +const ENVIRONMENT: &str = "AUTHS_AP074_DISCLOSURE_FILE_FAULT_PEER"; +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(rename_all = "kebab-case")] +enum Phase { + Admission, + Entry, + Acknowledgement, + Unknown, +} +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + point: FileIoPoint, + skip: usize, +} +impl Schedule { + fn all() -> Vec { + let mut result = vec![ + Self { + phase: Phase::Admission, + point: FileIoPoint::DataSync, + skip: 0, + }, + Self { + phase: Phase::Admission, + point: FileIoPoint::InstallBatch, + skip: 0, + }, + ]; + for skip in 0..4 { + result.push(Self { + phase: Phase::Admission, + point: FileIoPoint::InstallTarget, + skip, + }); + } + for skip in 0..3 { + result.push(Self { + phase: Phase::Admission, + point: FileIoPoint::DirectorySync, + skip, + }); + } + for phase in [Phase::Entry, Phase::Acknowledgement, Phase::Unknown] { + for point in [ + FileIoPoint::DataSync, + FileIoPoint::Replace, + FileIoPoint::DirectorySync, + ] { + result.push(Self { + phase, + point, + skip: 0, + }); + } + } + assert_eq!(result.len(), 18); + result + } + const fn stage(self) -> &'static str { + match self.phase { + Phase::Admission => "reserved", + Phase::Entry => "entry-granted", + Phase::Acknowledgement => "acknowledged", + Phase::Unknown => "unknown", + } + } + const fn retained(self) -> Option<&'static str> { + match self.phase { + Phase::Admission => { + if matches!(self.point, FileIoPoint::DirectorySync) && self.skip == 2 { + Some("reserved") + } else { + None + } + } + Phase::Entry => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("entry-granted") + } else { + Some("reserved") + } + } + Phase::Acknowledgement => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("acknowledged") + } else { + Some("unknown") + } + } + Phase::Unknown => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("unknown") + } else { + Some("entry-granted") + } + } + } + } + fn resumable(self) -> bool { + matches!(self.retained(), None | Some("reserved")) + } + fn delivered(self) -> bool { + matches!(self.phase, Phase::Acknowledgement | Phase::Unknown) + } + fn projection(self) -> DisclosureStage { + match self.retained() { + Some("reserved") => DisclosureStage::Reserved, + Some("acknowledged") => DisclosureStage::Acknowledged, + _ => DisclosureStage::Unknown, + } + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct FaultSetup { + fixture: CrashSetup, + schedule: Schedule, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct ResultData { + process: u32, + injected: usize, + result: Result, + witness: GatewayExecutionWitness, + recipient: Value, + challenge_sent: bool, + content_wire_bytes: u64, +} + +#[test] +fn native_disclosure_file_fault_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: FaultSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let fixture = &setup.fixture; + let store = Arc::new( + FileGatewayAttemptStore::open(&fixture.installation.location).expect("file adapter"), + ); + let failure = Arc::new(FailureStore::new( + store.clone(), + key(RELEASE), + CrashProtocol::Disclosure, + setup.schedule.stage(), + setup.schedule.point, + setup.schedule.skip, + )); + let attempts = GatewayAttempts::new(failure, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &fixture.installation, + "file-release-worker", + attempts, + controls(Gate::Current), + )); + let result = runtime.block_on(async { + let input = Input::read(&fixture.installation.root); + let target = kit::target(&engine, fixture).await; + let listener = UnixListener::bind(fixture.installation.root.join("release.sock")) + .expect("owned native endpoint"); + let mut recipient = if matches!(setup.schedule.phase, Phase::Unknown) { + Recipient::without_ack(fixture) + } else { + Recipient::start(fixture, false) + }; + let (stream, _) = listener + .accept() + .await + .expect("independent native recipient"); + let (server, recorder) = UnixStream::pair().expect("opaque recorder channel"); + let (result, (challenge_sent, content_wire_bytes)) = tokio::join!( + engine.disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(server, fixture.channel.clone()) + ), + super::postgres_commit_tests::relay(recorder, stream) + ); + recipient.finish(false); + let recipient: Value = serde_json::from_slice( + &std::fs::read(fixture.installation.root.join("recipient-result.json")) + .expect("recipient outcome"), + ) + .expect("native recipient"); + ResultData { + process: std::process::id(), + injected: store.injected_io_failures().expect("fault count"), + result, + witness: engine.execution_witness(), + recipient, + challenge_sent, + content_wire_bytes, + } + }); + private( + &fixture.installation.root.join("file-release-result"), + &serde_json::to_vec(&result).expect("result"), + ); +} + +fn assert_source(case: &Case) { + assert_eq!(case.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!( + case.store + .raw() + .load(GatewayRecordKind::Attempt, &key(SOURCE)) + .expect("load") + .expect("source"), + case.source + ); + for (name, expected) in ["release.proof", "release.action", "release.approval"] + .iter() + .zip(&case.signed_inputs) + { + assert_eq!( + &std::fs::read(case.setup.installation.root.join(name)).expect("original signed input"), + expected + ); + } +} +fn fail(case: &Case, schedule: Schedule) { + let source_charges = case.source_charges.records(&case.store, true); + let path = case.setup.installation.root.join("file-release.setup"); + private( + &path, + &serde_json::to_vec(&json!({"fixture":case.setup,"schedule":schedule})).expect("setup"), + ); + let mut worker=Process(Command::new(std::env::current_exe().expect("test executable")) + .args(["--exact","native_disclosure_crash_tests::file_fault_tests::native_disclosure_file_fault_peer","--nocapture"]) + .env(ENVIRONMENT,path).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::piped()).spawn().expect("native worker")); + worker.finish(); + let result: ResultData = serde_json::from_slice( + &std::fs::read(case.setup.installation.root.join("file-release-result")).expect("result"), + ) + .expect("native result"); + assert_ne!(result.process, std::process::id()); + assert_eq!(result.injected, 1); + assert_eq!( + ( + result.witness.credential_lease_calls, + result.witness.read_transport_entries, + result.witness.write_transport_entries + ), + (0, 0, 0) + ); + assert_eq!(result.recipient["received_full"], schedule.delivered()); + if schedule.delivered() { + assert_eq!(result.recipient["bytes"], CONTENT.len()); + } else { + assert_eq!(result.recipient["code"], "gateway.disclosure.read"); + } + assert_eq!( + case.setup.installation.root.join("recipient.ack").exists(), + schedule.delivered() + ); + assert_eq!( + result.challenge_sent, + !matches!(schedule.phase, Phase::Admission) + ); + assert_eq!( + result.content_wire_bytes, + if schedule.delivered() { + (CONTENT.len() + 4) as u64 + } else { + 0 + } + ); + let raw = case + .store + .raw() + .load(GatewayRecordKind::Attempt, &key(RELEASE)) + .expect("recovered state"); + if let Some(stage) = schedule.retained() { + let value: Value = + serde_json::from_slice(raw.as_ref().expect("record")).expect("native record"); + assert_eq!(value["state"]["facts"]["phase"]["stage"], stage); + assert_eq!(value["evaluated_at"], NOW); + assert_eq!(value["state"]["facts"]["allocation"], 0); + assert_eq!(!value["entry"].is_null(), stage != "reserved"); + match result.result { + Ok(snapshot) => assert_eq!(snapshot.stage, schedule.projection()), + Err(GatewaySubmitResult::Indeterminate { code }) => { + assert_eq!(code, "gateway.attempt.state-unavailable") + } + other => panic!("unexpected retained projection: {other:?}"), + } + } else { + assert!(raw.is_none()); + assert_eq!( + result.result, + Err(GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned() + }) + ); + } + let files = journal_files(Path::new(&case.setup.installation.location)); + assert!(!files.contains_key(".batch.json")); + let admitted = usize::from(schedule.retained().is_some()); + for prefix in ["claim-", "allocation-"] { + assert_eq!( + files.keys().filter(|name| name.starts_with(prefix)).count(), + 1 + admitted + ); + } + for prefix in ["slot-", "sum-"] { + assert_eq!( + files.keys().filter(|name| name.starts_with(prefix)).count(), + admitted + ); + } + case.release_charges + .records(&case.store, schedule.retained().is_some()); + assert_eq!( + case.source_charges.records(&case.store, true), + source_charges + ); + assert_source(case); +} + +fn resume(case: &Case, engine: &GatewayEngine) -> DisclosureSnapshot { + let (snapshot, mut recipient) = case.runtime.block_on(async { + let input = Input::read(&case.setup.installation.root); + let target = kit::target(engine, &case.setup).await; + let listener = UnixListener::bind(case.setup.installation.root.join("resume.sock")) + .expect("owned resume endpoint"); + let recipient = Recipient::start(&case.setup, true); + let (stream, _) = listener + .accept() + .await + .expect("independent native recipient"); + let (server, recorder) = UnixStream::pair().expect("opaque recorder channel"); + let (snapshot, (challenge, wire)) = tokio::join!( + engine.disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(server, case.setup.channel.clone()) + ), + super::postgres_commit_tests::relay(recorder, stream) + ); + assert!(challenge); + assert_eq!(wire, (CONTENT.len() + 4) as u64); + (snapshot.expect("fresh native reauthorization"), recipient) + }); + recipient.finish(false); + assert_eq!(snapshot.stage, DisclosureStage::Acknowledged); + let received: Value = serde_json::from_slice( + &std::fs::read( + case.setup + .installation + .root + .join("resumed-recipient-result.json"), + ) + .expect("recipient outcome"), + ) + .expect("recipient"); + assert_eq!(received["received_full"], true); + assert_eq!(received["bytes"], CONTENT.len()); + snapshot +} +fn replay(case: &Case, engine: &GatewayEngine, expected: &DisclosureSnapshot) { + let rows = journal_files(Path::new(&case.setup.installation.location)); + let witness = engine.execution_witness(); + case.runtime.block_on(async { + let input = Input::read(&case.setup.installation.root); + let target = kit::target(engine, &case.setup).await; + let (server, mut client) = UnixStream::pair().expect("replay channel"); + let reader = async { + let mut bytes = Vec::new(); + client.read_to_end(&mut bytes).await.expect("EOF"); + assert!(bytes.is_empty()); + }; + let (actual, ()) = tokio::join!( + engine.disclose( + &target, + &input.proof, + &input.action, + input.approval, + DisclosureConnection::new(server, case.setup.channel.clone()) + ), + reader + ); + assert_eq!(&actual.expect("retained facts"), expected); + }); + assert_eq!(engine.execution_witness(), witness); + assert_eq!( + journal_files(Path::new(&case.setup.installation.location)), + rows + ); + assert_source(case); +} +fn late_ack( + case: &Case, + engine: &GatewayEngine, + schedule: Schedule, + snapshot: &DisclosureSnapshot, +) -> bool { + let prefix = if schedule.resumable() { + "resumed-recipient" + } else { + "recipient" + }; + let path = case.setup.installation.root.join(format!("{prefix}.ack")); + if !path.exists() { + assert!( + matches!(schedule.phase, Phase::Entry) + && matches!(schedule.point, FileIoPoint::DirectorySync) + ); + assert_eq!(snapshot.stage, DisclosureStage::Unknown); + return false; + } + let ack = DisclosureAcknowledgement::from_private_bytes( + &std::fs::read(path).expect("genuine native ACK"), + ) + .expect("ACK"); + let charges = case.release_charges.records(&case.store, true); + let mut before = journal_files(Path::new(&case.setup.installation.location)); + let witness = engine.execution_witness(); + let after = case + .runtime + .block_on(engine.acknowledge_disclosure(RELEASE, &ack)) + .expect("historical ACK"); + assert_eq!(after.stage, DisclosureStage::Acknowledged); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(case.release_charges.records(&case.store, true), charges); + let mut retained = journal_files(Path::new(&case.setup.installation.location)); + let file = format!("claim-{}.json", hex::encode(key(RELEASE).as_bytes())); + assert!(before.remove(&file).is_some()); + assert!(retained.remove(&file).is_some()); + assert_eq!(retained, before); + replay(case, engine, &after); + true +} +fn reopen(case: &Case, schedule: Schedule) -> Value { + let before = journal_files(Path::new(&case.setup.installation.location)); + let source = case.source_charges.records(&case.store, true); + let prior = schedule + .retained() + .map(|_| case.release_charges.records(&case.store, true)); + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup.installation, + "file-release-reopened", + case.store.reopen(), + controls(Gate::Current), + )); + let history = case.runtime.block_on(engine.content_history(RELEASE)); + if schedule.retained().is_none() { + assert!(history.is_err()); + } else { + let ContentHistory::Disclosure(snapshot) = history.expect("history") else { + panic!("protocol"); + }; + assert_eq!(snapshot.stage, schedule.projection()); + } + let snapshot = if schedule.resumable() { + resume(case, &engine) + } else { + let ContentHistory::Disclosure(snapshot) = case + .runtime + .block_on(engine.content_history(RELEASE)) + .expect("history") + else { + panic!("protocol"); + }; + assert_eq!( + journal_files(Path::new(&case.setup.installation.location)), + before + ); + snapshot + }; + assert_eq!( + ( + snapshot.reserved_deliveries, + snapshot.reserved_bytes, + snapshot.policy_count_counters, + snapshot.policy_byte_counters + ), + (1, CONTENT.len() as u64, 1, 1) + ); + let charges = case.release_charges.records(&case.store, true); + assert_eq!(charges.len(), 3); + if let Some(prior) = prior { + assert_eq!(charges, prior); + } + assert_eq!(case.source_charges.records(&case.store, true), source); + replay(case, &engine, &snapshot); + let historical = late_ack(case, &engine, schedule, &snapshot); + assert_source(case); + json!({"phase":schedule.phase,"point":schedule.point,"skip":schedule.skip,"injected_io_failures":1, + "retained_phase_after_failure":schedule.retained(),"new_native_delivery_allowed":schedule.resumable(), + "recipient_deliveries":usize::from(schedule.delivered()||schedule.resumable()),"native_snapshot_before_historical_ack":snapshot, + "native_historical_ack_refined_or_replayed":historical,"provider_source_reads":1,"additional_custody_or_provider_calls":0, + "existing_source_and_charges_preserved":true,"one_lifetime_allocation_count_and_byte_sum_slot":true, + "terminal_replay_has_no_wire_bytes_or_journal_or_witness_change":true}) +} + +#[test] +fn native_file_disclosure_io_fault_fixture_is_current() { + let cases: Vec<_> = Schedule::all() + .into_iter() + .map(|schedule| { + let case = Case::new(Backend::File, Point::BeforeReservationCommit, Gate::Current); + fail(&case, schedule); + reopen(&case, schedule) + }) + .collect(); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-disclosure-file-io-faults/1","cases":cases, + "scope":"native source HTTP acquisition, release gateway and recipient in independent OS processes over same-UID Unix sockets, opaque wire capture, maintained file writer fence and four-row admission; syscall error simulated at actual adapter site, preceding writes/rollback/ACK/replay use maintained code and public fixture keys/clock", + "excluded":["actual kernel/device EIO or power loss","whole-store rollback","hostile OS or live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-disclosure-file-io-faults.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs index 41d422c44..1b641897b 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs @@ -225,7 +225,7 @@ async fn recipient(setup: &CommitSetup) { ); } -async fn relay(gateway: UnixStream, recipient: UnixStream) -> (bool, u64) { +pub(super) async fn relay(gateway: UnixStream, recipient: UnixStream) -> (bool, u64) { let (mut from_gateway, mut to_gateway) = gateway.into_split(); let (mut from_recipient, mut to_recipient) = recipient.into_split(); let outbound = async { diff --git a/product/runtime/auths-gateway/src/native_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_file_fault_tests.rs index 22d276301..8acca7204 100644 --- a/product/runtime/auths-gateway/src/native_file_fault_tests.rs +++ b/product/runtime/auths-gateway/src/native_file_fault_tests.rs @@ -1,6 +1,7 @@ //! Injected errors at file adapter I/O boundaries under actual native decisions. //! The failed syscall is simulated; real preceding writes, fences, rollback, //! native verification, custody and HTTP run in independent OS processes. +use crate::native_crash_tests::CrashProtocol; use crate::native_process_tests::{ NOW, Provider, Setup, acquire, authorize_policy, load_engine, private, recipe, runtime, }; @@ -150,25 +151,49 @@ fn operation_key() -> GatewayAttemptKey { .expect("key") } -struct FailureStore { +pub(crate) struct FailureStore { inner: Arc, - schedule: Schedule, + key: GatewayAttemptKey, + protocol: CrashProtocol, + stage: &'static str, + point: FileIoPoint, + skip: usize, armed: AtomicBool, } impl FailureStore { + pub(crate) fn new( + inner: Arc, + key: GatewayAttemptKey, + protocol: CrashProtocol, + stage: &'static str, + point: FileIoPoint, + skip: usize, + ) -> Self { + Self { + inner, + key, + protocol, + stage, + point, + skip, + armed: AtomicBool::new(false), + } + } fn arm( &self, kind: GatewayRecordKind, key: GatewayAttemptKey, bytes: &[u8], ) -> Result<(), GatewayAttemptError> { - if kind == GatewayRecordKind::Attempt && key == operation_key() { + if kind == GatewayRecordKind::Attempt && key == self.key { let value: Value = serde_json::from_slice(bytes).expect("unchanged native decision"); - if value["state"]["facts"]["phase"]["stage"] == self.schedule.decision() + if value + .pointer(self.protocol.stage_pointer()) + .and_then(Value::as_str) + == Some(self.stage) && !self.armed.swap(true, Ordering::SeqCst) { - self.inner - .arm_io_failure(self.schedule.point, self.schedule.skip)?; + self.inner.arm_io_failure(self.point, self.skip)?; } } Ok(()) @@ -248,11 +273,14 @@ fn native_file_fault_peer() { let store = Arc::new( FileGatewayAttemptStore::open(&setup.installation.location).expect("file adapter"), ); - let failure = Arc::new(FailureStore { - inner: store.clone(), - schedule: setup.schedule, - armed: AtomicBool::new(false), - }); + let failure = Arc::new(FailureStore::new( + store.clone(), + operation_key(), + CrashProtocol::Acquisition, + setup.schedule.decision(), + setup.schedule.point, + setup.schedule.skip, + )); let attempts = GatewayAttempts::new(failure, crate::effect::fixture_policy().expect("policy")) .expect("attempts"); let runtime = runtime(); @@ -315,7 +343,7 @@ fn execute(setup: &FaultSetup) -> WorkerResult { .expect("native result") } -fn journal_files(path: &Path) -> BTreeMap> { +pub(crate) fn journal_files(path: &Path) -> BTreeMap> { std::fs::read_dir(path) .expect("directory") .map(|entry| { diff --git a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs index 1d059ebe2..2f436fae8 100644 --- a/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_budget_tests.rs @@ -15,6 +15,9 @@ mod postgres_batch_tests; #[path = "native_mutation_pg_commit_tests.rs"] mod postgres_commit_tests; +#[path = "native_mutation_file_fault_tests.rs"] +mod file_fault_tests; + #[derive(Clone, Copy)] enum Limit { Count, diff --git a/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs new file mode 100644 index 000000000..678a9c368 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs @@ -0,0 +1,382 @@ +//! Simulated file syscall errors at actual native mutation persistence sites. +//! All decisions, preceding writes, rollback/reopen and HTTP are maintained code. +use super::*; +use crate::FileGatewayAttemptStore; +use crate::native_dependency_tests::Peer as Process; +use crate::native_file_fault_tests::{FailureStore, journal_files}; +use crate::native_postgres_commit_tests::Phase; +use crate::store::FileIoPoint; +use std::process::{Command, Stdio}; + +const ENVIRONMENT: &str = "AUTHS_AP074_MUTATION_FILE_FAULT_PEER"; +#[derive(Clone, Copy, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Schedule { + phase: Phase, + point: FileIoPoint, + skip: usize, +} +impl Schedule { + fn all() -> Vec { + let mut cases = vec![ + Self { + phase: Phase::Admission, + point: FileIoPoint::DataSync, + skip: 0, + }, + Self { + phase: Phase::Admission, + point: FileIoPoint::InstallBatch, + skip: 0, + }, + ]; + for skip in 0..3 { + cases.push(Self { + phase: Phase::Admission, + point: FileIoPoint::InstallTarget, + skip, + }); + } + for skip in 0..3 { + cases.push(Self { + phase: Phase::Admission, + point: FileIoPoint::DirectorySync, + skip, + }); + } + for phase in [Phase::Entry, Phase::Response] { + for point in [ + FileIoPoint::DataSync, + FileIoPoint::Replace, + FileIoPoint::DirectorySync, + ] { + cases.push(Self { + phase, + point, + skip: 0, + }); + } + } + assert_eq!(cases.len(), 14); + cases + } + const fn stage(self) -> &'static str { + match self.phase { + Phase::Admission => "reserved", + Phase::Entry => "entry-granted", + Phase::Response => "response-recorded", + } + } + const fn retained(self) -> Option<&'static str> { + match self.phase { + Phase::Admission => { + if matches!(self.point, FileIoPoint::DirectorySync) && self.skip == 2 { + Some("reserved") + } else { + None + } + } + Phase::Entry => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("entry-granted") + } else { + Some("reserved") + } + } + Phase::Response => { + if matches!(self.point, FileIoPoint::DirectorySync) { + Some("response-recorded") + } else { + Some("entry-granted") + } + } + } + } + fn resumable(self) -> bool { + matches!(self.retained(), None | Some("reserved")) + } + fn writes(self) -> usize { + usize::from(matches!(self.phase, Phase::Response)) + } + fn projection(self) -> GatewaySubmitResult { + match self.retained() { + Some("reserved") => GatewaySubmitResult::Reserved { revision: 1 }, + Some("response-recorded") => GatewaySubmitResult::ResponseRecorded { status: 200 }, + Some("entry-granted") => GatewaySubmitResult::Unknown, + _ => panic!("absent operation has no history"), + } + } +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct FaultSetup { + installation: Setup, + schedule: Schedule, +} +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct ResultData { + process: u32, + injected: usize, + result: GatewaySubmitResult, + witness: GatewayExecutionWitness, +} +fn operation_key() -> GatewayAttemptKey { + GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + Flavor::StripePlain.recipe().namespace(), + &LogicalOperationId::parse(OPERATIONS[0]).expect("operation"), + ) + .expect("key") +} + +#[test] +fn native_mutation_file_fault_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let setup: FaultSetup = + serde_json::from_slice(&std::fs::read(path).expect("setup")).expect("closed setup"); + let store = Arc::new( + FileGatewayAttemptStore::open(&setup.installation.location).expect("file adapter"), + ); + let failure = Arc::new(FailureStore::new( + store.clone(), + operation_key(), + CrashProtocol::Mutation, + setup.schedule.stage(), + setup.schedule.point, + setup.schedule.skip, + )); + let attempts = GatewayAttempts::new(failure, crate::effect::fixture_policy().expect("policy")) + .expect("attempts"); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &setup.installation, + "file-mutation-worker", + attempts, + Flavor::StripePlain.controls(), + )); + let result = runtime.block_on(execute(&engine, &setup.installation.root, OPERATIONS[0])); + private( + &setup.installation.root.join("file-mutation-result"), + &serde_json::to_vec(&ResultData { + process: std::process::id(), + injected: store.injected_io_failures().expect("fault count"), + result, + witness: engine.execution_witness(), + }) + .expect("result"), + ); +} +fn signed_inputs(case: &MutationRace) -> Vec> { + ["proof", "action", "approval", "binding"] + .map(|suffix| { + std::fs::read(case.setup.root.join(format!("{}.{suffix}", OPERATIONS[0]))) + .expect("original input") + }) + .to_vec() +} +fn fail(case: &MutationRace, schedule: Schedule, counters: &[Counter]) { + let path = case.setup.root.join("file-mutation.setup"); + private( + &path, + &serde_json::to_vec(&json!({"installation":case.setup,"schedule":schedule})) + .expect("setup"), + ); + let mut worker=Process(Command::new(std::env::current_exe().expect("test executable")) + .args(["--exact","native_mutation_crash_tests::window_capacity_tests::file_fault_tests::native_mutation_file_fault_peer","--nocapture"]) + .env(ENVIRONMENT,path).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::piped()).spawn().expect("native worker")); + worker.finish(); + let result: ResultData = serde_json::from_slice( + &std::fs::read(case.setup.root.join("file-mutation-result")).expect("result"), + ) + .expect("native result"); + assert_ne!(result.process, std::process::id()); + assert_eq!(result.injected, 1); + assert_eq!( + result.witness.credential_lease_calls, + u64::from(!matches!(schedule.phase, Phase::Admission)) + ); + assert_eq!(result.witness.read_transport_entries, 0); + assert_eq!( + result.witness.write_transport_entries, + schedule.writes() as u64 + ); + assert_eq!(case.provider.calls(), schedule.writes()); + let raw = case + .store + .raw() + .load(GatewayRecordKind::Attempt, &operation_key()) + .expect("recovered state"); + if let Some(stage) = schedule.retained() { + let record: Value = + serde_json::from_slice(raw.as_ref().expect("record")).expect("native record"); + assert_eq!(record["state"]["facts"]["stage"], stage); + assert_eq!(record["evaluated_at"], NOW); + assert_eq!(!record["entry"].is_null(), stage != "reserved"); + match &result.result { + GatewaySubmitResult::Indeterminate { code } => { + assert_eq!(code, "gateway.attempt.state-unavailable") + } + GatewaySubmitResult::Unknown => { + assert!(matches!(stage, "entry-granted" | "response-recorded")) + } + other => assert_eq!(other, &schedule.projection()), + } + } else { + assert!(raw.is_none()); + assert_eq!( + result.result, + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned() + } + ); + } + let files = journal_files(Path::new(&case.setup.location)); + assert!(!files.contains_key(".batch.json")); + for prefix in ["claim-", "slot-", "sum-"] { + assert_eq!( + files.keys().filter(|name| name.starts_with(prefix)).count(), + usize::from(schedule.retained().is_some()) + ); + } + assert!( + !files.keys().any(|name| name.starts_with("allocation-")), + "mutation has no source lifetime allocation" + ); + for counter in counters { + assert_eq!( + case.store + .raw() + .load(counter.kind, &counter.key(0)) + .expect("charge") + .is_some(), + schedule.retained().is_some() + ); + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(1)) + .expect("no extra slot") + .is_none() + ); + } +} + +fn reopen(case: &MutationRace, schedule: Schedule, counters: &[Counter]) -> Value { + let before = journal_files(Path::new(&case.setup.location)); + let prior = slot_bytes(case, counters, schedule.retained().is_some()); + let (engine, _) = case.runtime.block_on(load_controlled_engine( + &case.setup, + "file-mutation-reopened", + case.store.reopen(), + Flavor::StripePlain.controls(), + )); + let witness = engine.execution_witness(); + let result = case + .runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])); + assert_eq!( + result, + if schedule.resumable() { + GatewaySubmitResult::ResponseRecorded { status: 200 } + } else { + schedule.projection() + } + ); + if !schedule.resumable() { + assert_eq!(engine.execution_witness(), witness); + assert_eq!(journal_files(Path::new(&case.setup.location)), before); + } + let total = schedule.writes() + usize::from(schedule.resumable()); + assert_eq!(case.provider.calls(), total); + if total == 1 { + assert_eq!( + case.provider.requests.lock().expect("requests")[0].body, + std::fs::read(case.setup.root.join(format!("{}.body", OPERATIONS[0]))) + .expect("exact native body") + ); + } + let slots = slot_bytes(case, counters, true); + if !prior.is_empty() { + assert_eq!(slots, prior); + } + let rows = journal_files(Path::new(&case.setup.location)); + let witness = engine.execution_witness(); + assert_eq!( + case.runtime + .block_on(execute(&engine, &case.setup.root, OPERATIONS[0])), + result + ); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(journal_files(Path::new(&case.setup.location)), rows); + assert_eq!(case.provider.calls(), total); + assert_eq!(slot_bytes(case, counters, true), slots); + json!({"phase":schedule.phase,"point":schedule.point,"skip":schedule.skip,"injected_io_failures":1, + "retained_phase_after_failure":schedule.retained(),"provider_writes_before_reopen":schedule.writes(), + "new_native_execution_allowed":schedule.resumable(),"provider_writes_after_reopen":total,"native_result":result, + "one_count_and_one_amount_sum_slot":true,"no_source_lifetime_allocation_for_mutation":true, + "terminal_replay_changes_no_journal_bytes_or_execution_witness":true}) +} +fn slot_bytes(case: &MutationRace, counters: &[Counter], present: bool) -> Vec> { + counters + .iter() + .filter_map(|counter| { + let value = case + .store + .raw() + .load(counter.kind, &counter.key(0)) + .expect("slot"); + assert_eq!(value.is_some(), present); + assert!( + case.store + .raw() + .load(counter.kind, &counter.key(1)) + .expect("no duplicate") + .is_none() + ); + value.map(|bytes| { + let data: Value = serde_json::from_slice(&bytes).expect("native slot"); + assert_eq!(data["slot"], 0); + assert_eq!(data["operation_id"], OPERATIONS[0]); + if counter.kind == GatewayRecordKind::SumSlot { + assert_eq!(data["amount"], AMOUNT); + assert_eq!(data["cumulative"], AMOUNT); + } + bytes + }) + }) + .collect() +} + +#[test] +fn native_file_mutation_io_fault_fixture_is_current() { + let cases: Vec<_> = Schedule::all() + .into_iter() + .map(|schedule| { + let case = MutationRace::new(Backend::File); + let counters = case.runtime.block_on(inputs( + &case.engine, + &case.setup.root, + OPERATIONS[0], + Limit::Both, + )); + let signed = signed_inputs(&case); + fail(&case, schedule, &counters); + assert_eq!(signed_inputs(&case), signed); + let result = reopen(&case, schedule, &counters); + assert_eq!(signed_inputs(&case), signed); + result + }) + .collect(); + let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-file-io-faults/1","cases":cases, + "scope":"native Stripe mutation in separate worker processes, actual maintained file writer fence and three-row atomic admission, rollback/reopen, native bounded proof/exact approval and counting local HTTP; I/O failure return simulated at adapter call site, fixed public fixture keys/clock", + "excluded":["actual kernel/device EIO or power loss","whole-store rollback","hostile OS and live-provider qualification"]})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-mutation-file-io-faults.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("write"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 95735d351..d46845eaa 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "706b8c79a4cea91b9b366ca4dc99c500afbca2e9b1aec1e4835d77d73cc0b357"; + "beeffaf90c992ad9fd06add58831299ef67e47c61a6306797bc5f427eca7f568"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 598600985..656084227 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 420 +freeze_version = 421 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 420 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 163 +"auths.identity.protocol" = 164 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 420 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 160 +"auths.product.public-sdk-contract" = 161 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 27 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 420 +"auths.release.public-surface" = 421 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 72a36d75b..83fa6d5e6 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 420, + "freezeVersion": 421, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 163, + "version": 164, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "e22ae97f08b3c422ce2b9279bbd4faef2f0b75c07c21ff1394791b62528a99b2" + "sha256": "d31f69cbcb8920f3b393749754550f7c928eec7d26a7188708b8704fa64b5e5c" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 160, + "version": 161, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "19f659691a731f26371c9b39b7aa2fa2ff3ebda339035ef369993454c552b16d" + "sha256": "7858985d21cf0e97667fa6fee118d944c91ecf29df4f6c32dde43d0880f84b56" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 420, + "version": 421, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "de00eb8c7528d3d3ed72600298b8cfbd2601c659010962ab2ddef9156aef64de" + "sha256": "3005c300d253a328b479ae9b54b2d25f3ecedd8924975e433702ef3aa3a34b4e" } ] } From a3835fa5dabee43486629fb6f1950ae71e14aaaa Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 01:22:26 +0000 Subject: [PATCH 111/136] test(gateway): satisfy strict lint in durability evidence helpers --- .../auths-gateway/src/native_disclosure_crash_testkit.rs | 3 +-- .../src/native_disclosure_file_fault_tests.rs | 2 +- .../src/native_disclosure_pg_commit_tests.rs | 2 +- .../src/native_mutation_file_fault_tests.rs | 9 ++++----- .../auths-gateway/src/native_mutation_pg_commit_tests.rs | 2 +- 5 files changed, 8 insertions(+), 10 deletions(-) diff --git a/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs index 401460616..f28995920 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs @@ -397,9 +397,8 @@ pub(super) fn peer() { runtime.block_on(async { match setup.role { Role::Gateway => Box::pin(gateway(&setup)).await, - Role::Recipient => recipient(&setup, false).await, + Role::Recipient | Role::RecipientWithoutAck => recipient(&setup, false).await, Role::ResumeRecipient => recipient(&setup, true).await, - Role::RecipientWithoutAck => recipient(&setup, false).await, } }); } diff --git a/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs index 8c8fe4926..b6321ec0b 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs @@ -299,7 +299,7 @@ fn fail(case: &Case, schedule: Schedule) { match result.result { Ok(snapshot) => assert_eq!(snapshot.stage, schedule.projection()), Err(GatewaySubmitResult::Indeterminate { code }) => { - assert_eq!(code, "gateway.attempt.state-unavailable") + assert_eq!(code, "gateway.attempt.state-unavailable"); } other => panic!("unexpected retained projection: {other:?}"), } diff --git a/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs index 1b641897b..46d3d8e90 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs @@ -450,7 +450,7 @@ fn interrupt(case: &Case, setup: &CommitSetup, proxy: &Proxy, url: &str) -> Barr assert_eq!(snapshot.stage, setup.schedule.projection()); } Err(GatewaySubmitResult::Indeterminate { code }) => { - assert_eq!(code, "gateway.attempt.state-unavailable") + assert_eq!(code, "gateway.attempt.state-unavailable"); } Err(other) => panic!("unexpected projection: {other:?}"), } diff --git a/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs b/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs index 678a9c368..f1c248bf6 100644 --- a/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs @@ -217,10 +217,10 @@ fn fail(case: &MutationRace, schedule: Schedule, counters: &[Counter]) { assert_eq!(!record["entry"].is_null(), stage != "reserved"); match &result.result { GatewaySubmitResult::Indeterminate { code } => { - assert_eq!(code, "gateway.attempt.state-unavailable") + assert_eq!(code, "gateway.attempt.state-unavailable"); } GatewaySubmitResult::Unknown => { - assert!(matches!(stage, "entry-granted" | "response-recorded")) + assert!(matches!(stage, "entry-granted" | "response-recorded")); } other => assert_eq!(other, &schedule.projection()), } @@ -336,15 +336,14 @@ fn slot_bytes(case: &MutationRace, counters: &[Counter], present: bool) -> Vec { - assert_eq!(code, "gateway.attempt.state-unavailable") + assert_eq!(code, "gateway.attempt.state-unavailable"); } GatewaySubmitResult::Unknown => assert!(matches!( schedule.retained(), From 1085b8f7dfcaad5b848e3c36ae9db59360fabc88 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 01:29:01 +0000 Subject: [PATCH 112/136] feat(gateway): report retained recovery budgets and escalation --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/content-process-journey.json | 19 +- .../native-independent-recovery-file.json | 156 +++- .../native-independent-recovery-postgres.json | 156 +++- .../gateway/native-recovery-limits-file.json | 758 ++++++++++++++++++ .../native-recovery-limits-postgres.json | 758 ++++++++++++++++++ .../fixtures/gateway/recovery-refinement.json | 199 ++++- bindings/python/README.md | 6 + bindings/typescript/README.md | 6 + compliance.toml | 4 +- docs/plans/0074-implementation-status.md | 59 +- ...ound-effects-and-recovery-state-machine.md | 19 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/effect.rs | 2 + .../auths-gateway/src/effect/acquisition.rs | 2 +- .../auths-gateway/src/effect_native_tests.rs | 8 + product/runtime/auths-gateway/src/lib.rs | 6 +- .../src/native_recovery_actor_tests.rs | 36 +- .../src/native_recovery_limits_tests.rs | 283 +++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 5 +- .../auths-gateway/src/store/acquisition.rs | 3 +- .../src/store/acquisition/recovery.rs | 178 +++- .../auths-gateway/tests/content_journey.rs | 6 + release/semantic-freeze-versions.toml | 10 +- release/semantic-freeze.json | 18 +- 26 files changed, 2611 insertions(+), 92 deletions(-) create mode 100644 bindings/fixtures/gateway/native-recovery-limits-file.json create mode 100644 bindings/fixtures/gateway/native-recovery-limits-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_recovery_limits_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 0d8645380..07b45817d 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -92,6 +92,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::entry_tests::postgres_native_disclosure_entry_order_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::limits_tests::native_file_recovery_limits_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::limits_tests::postgres_native_recovery_limits_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres } 2>&1 | tee target/ap074-native-adapter-evidence.log - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 diff --git a/bindings/fixtures/gateway/content-process-journey.json b/bindings/fixtures/gateway/content-process-journey.json index 7760fda23..f04442e11 100644 --- a/bindings/fixtures/gateway/content-process-journey.json +++ b/bindings/fixtures/gateway/content-process-journey.json @@ -48,7 +48,7 @@ "observation": { "outcome": "recovery-report", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -68,7 +68,22 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": "actual-runtime-time-checked" } }, "revoked_disclosure": { diff --git a/bindings/fixtures/gateway/native-independent-recovery-file.json b/bindings/fixtures/gateway/native-independent-recovery-file.json index 473772d73..a5d6564cb 100644 --- a/bindings/fixtures/gateway/native-independent-recovery-file.json +++ b/bindings/fixtures/gateway/native-independent-recovery-file.json @@ -27,7 +27,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -47,10 +47,25 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -70,7 +85,22 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed-by-provider", "replay_journals_and_execution_unchanged": true @@ -89,7 +119,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed", "revision": 4, @@ -109,10 +139,25 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed", "revision": 4, @@ -132,7 +177,22 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed", "replay_journals_and_execution_unchanged": true @@ -151,7 +211,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -171,10 +231,25 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -194,7 +269,22 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed-by-provider", "replay_journals_and_execution_unchanged": true @@ -213,7 +303,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 3, @@ -233,10 +323,27 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 3, @@ -256,7 +363,24 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "unknown", "replay_journals_and_execution_unchanged": true diff --git a/bindings/fixtures/gateway/native-independent-recovery-postgres.json b/bindings/fixtures/gateway/native-independent-recovery-postgres.json index 4a57c38e8..19773bd95 100644 --- a/bindings/fixtures/gateway/native-independent-recovery-postgres.json +++ b/bindings/fixtures/gateway/native-independent-recovery-postgres.json @@ -27,7 +27,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -47,10 +47,25 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -70,7 +85,22 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed-by-provider", "replay_journals_and_execution_unchanged": true @@ -89,7 +119,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed", "revision": 4, @@ -109,10 +139,25 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed", "revision": 4, @@ -132,7 +177,22 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed", "replay_journals_and_execution_unchanged": true @@ -151,7 +211,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -171,10 +231,25 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 4, @@ -194,7 +269,22 @@ "response_bytes": 125, "response_version_ok": true }, - "disposition": "already-recorded" + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "observed-by-provider", "replay_journals_and_execution_unchanged": true @@ -213,7 +303,7 @@ "source_identity_entry_charges_unchanged": true, "original_signed_bytes_unchanged": true, "recovery": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 3, @@ -233,10 +323,27 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 }, "replay": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 3, @@ -256,7 +363,24 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 }, "historical_writer_replay_stage": "unknown", "replay_journals_and_execution_unchanged": true diff --git a/bindings/fixtures/gateway/native-recovery-limits-file.json b/bindings/fixtures/gateway/native-recovery-limits-file.json new file mode 100644 index 000000000..56d7d6b29 --- /dev/null +++ b/bindings/fixtures/gateway/native-recovery-limits-file.json @@ -0,0 +1,758 @@ +{ + "schema": "auths.native-recovery-limits/1", + "adapter": "file", + "scope": "native signed independent recovery, exact approvals, withdrawn writer root, actual bounded HTTP and durable source-lifetime rows; writer uses a separate OS process", + "excluded": [ + "live provider and custody", + "hostile OS or device power failure", + "total prerequisite transport time" + ], + "cases": [ + { + "case": "zero-match", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 404, + "response_bytes": 2, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "multiple-matches", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 75, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 2, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 32768, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "unrelated-echo", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 76, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 3, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 49152, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "incomplete-json", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 1, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 4, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 65536, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "truncated-http", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 5, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 81920, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "oversized-response", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 6, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 98304, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 7, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 114688, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 8, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 131072, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 9, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 147456, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 10, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 163840, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 11, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 180224, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 12, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 196608, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 13, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 212992, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 14, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 229376, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 15, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 245760, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + } + ], + "exhausted": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": null + }, + "reopen_preserves_lifetime_usage": true, + "freshness_30_inclusive_31_stale": true, + "out_of_range_clock_refuses_report": true, + "source_actor_entry_and_all_original_charges_unchanged": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-recovery-limits-postgres.json b/bindings/fixtures/gateway/native-recovery-limits-postgres.json new file mode 100644 index 000000000..8fe708be6 --- /dev/null +++ b/bindings/fixtures/gateway/native-recovery-limits-postgres.json @@ -0,0 +1,758 @@ +{ + "schema": "auths.native-recovery-limits/1", + "adapter": "postgres", + "scope": "native signed independent recovery, exact approvals, withdrawn writer root, actual bounded HTTP and durable source-lifetime rows; writer uses a separate OS process", + "excluded": [ + "live provider and custody", + "hostile OS or device power failure", + "total prerequisite transport time" + ], + "cases": [ + { + "case": "zero-match", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 404, + "response_bytes": 2, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "multiple-matches", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 75, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 2, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 32768, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "unrelated-echo", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 76, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 3, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 49152, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "incomplete-json", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 1, + "response_version_ok": true + }, + "disposition": "response-unusable", + "budget": { + "retained_attempts": 4, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 65536, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-unusable", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "truncated-http", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 5, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 81920, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "oversized-response", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 6, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 98304, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 7, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 114688, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 8, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 131072, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 9, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 147456, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 10, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 163840, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 11, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 180224, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 12, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 196608, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 13, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 212992, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 14, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 229376, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 15, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 245760, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + }, + { + "case": "state-equality-without-causation", + "report": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "replay_no_io_or_new_charge": true + } + ], + "exhausted": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "not-entered", + "reserved_calls": 0, + "reserved_bytes": 0, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": null + }, + "reopen_preserves_lifetime_usage": true, + "freshness_30_inclusive_31_stale": true, + "out_of_range_clock_refuses_report": true, + "source_actor_entry_and_all_original_charges_unchanged": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/recovery-refinement.json b/bindings/fixtures/gateway/recovery-refinement.json index ce49f36f4..c16f8de21 100644 --- a/bindings/fixtures/gateway/recovery-refinement.json +++ b/bindings/fixtures/gateway/recovery-refinement.json @@ -6,7 +6,7 @@ "case": "http-error", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -26,14 +26,30 @@ "response_bytes": 176, "response_version_ok": true }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "wrong-version", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -53,14 +69,30 @@ "response_bytes": 176, "response_version_ok": false }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "missing-field", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -80,14 +112,30 @@ "response_bytes": 2, "response_version_ok": true }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "malformed-json", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -107,14 +155,30 @@ "response_bytes": 1, "response_version_ok": true }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "multiple-records", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -134,14 +198,30 @@ "response_bytes": 75, "response_version_ok": true }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "duplicate-members", "disposition": "response-unusable", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -161,14 +241,30 @@ "response_bytes": 148, "response_version_ok": true }, - "disposition": "response-unusable" + "disposition": "response-unusable", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "state-match-without-echo", "disposition": "inconclusive", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -188,14 +284,30 @@ "response_bytes": 36, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "unrelated-echo", "disposition": "inconclusive", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -215,14 +327,30 @@ "response_bytes": 61, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "wrong-value", "disposition": "inconclusive", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "unknown", "revision": 2, @@ -242,14 +370,30 @@ "response_bytes": 124, "response_version_ok": true }, - "disposition": "inconclusive" + "disposition": "inconclusive", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "capacity-exhausted", + "next_actions": [ + "inspect-retained-evidence", + "escalate" + ], + "acquisition_received_at": 1790000004 } }, { "case": "exact-linked-evidence", "disposition": "recorded", "report": { - "schema": "auths.gateway-recovery/1", + "schema": "auths.gateway-recovery/2", "source": { "stage": "observed-by-provider", "revision": 3, @@ -269,7 +413,22 @@ "response_bytes": 176, "response_version_ok": true }, - "disposition": "recorded" + "disposition": "recorded", + "budget": { + "retained_attempts": 16, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 262144, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000004 } } ], diff --git a/bindings/python/README.md b/bindings/python/README.md index ff88d3de2..6a4eac8a1 100644 --- a/bindings/python/README.md +++ b/bindings/python/README.md @@ -47,6 +47,12 @@ approval=...)`, returning bounded native recovery-report/refusal JSON bytes. It returns no provider content or disclosure acknowledgement. The former unapproved `observe_read_back` route is removed. +The native `auths.gateway-recovery/2` report includes retained lifetime read and +response-byte reservations, observation transport and freshness limits, the +selected response receipt time, escalation and proposed next actions. Requesting +another observation requires fresh independent authorization and exact approval. +The report grants no retry, redelivery or refund authority. + The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, approvals from any two of three managers, gateway submission, and an offline audit. diff --git a/bindings/typescript/README.md b/bindings/typescript/README.md index ce0c84934..c1dc268ae 100644 --- a/bindings/typescript/README.md +++ b/bindings/typescript/README.md @@ -48,6 +48,12 @@ returning bounded native recovery-report/refusal JSON bytes. It returns no provider content or disclosure acknowledgement. The former unapproved `observeReadBack` route is removed. +The native `auths.gateway-recovery/2` report includes retained lifetime read and +response-byte reservations, observation transport and freshness limits, the +selected response receipt time, escalation and proposed next actions. Requesting +another observation requires fresh independent authorization and exact approval. +The report grants no retry, redelivery or refund authority. + The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, a 2-of-3 approval quorum, gateway submission, and an offline audit. diff --git a/compliance.toml b/compliance.toml index 0bdb736f4..ecf82603e 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1641,7 +1641,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/2", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1825,6 +1825,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_dependency_tests.rs#postgres_native_dependency_order_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#native_file_independent_recovery_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#postgres_native_independent_recovery_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#native_file_recovery_limits_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#postgres_native_recovery_limits_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#native_file_mutation_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index c446f0fd5..207f00e09 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3458,7 +3458,7 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash, commit-reply loss and file-error corpora / fifty-six release crash histories, eight committed/aborted release transactions and eighteen file-error histories retain charges through lost grants and ACK/Unknown persistence; genuine late ACKs never authorize redelivery | Remaining adverse races, runtime links and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | -| A11 | Missing/multiple/unrelated/incomplete reconciliation | Partial / native file corpus / synthetic response only | Installed transport and complete recovery projections | +| A11 | Missing/multiple/unrelated/incomplete reconciliation | Native implementation and file/TLS PostgreSQL HTTP constructors now cover zero, multiple, unrelated and incomplete observations, conservative unknown state, lifetime usage and escalation | Current-head hosted confirmation; actual transport timeout and remaining A15/A22 authority/store/interface cases remain outstanding | | A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus 24 mutation and 24 disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native acquisition/mutation/disclosure proof/approval/observer/threshold lock waits / eligible and expired controls executed on file/TLS PostgreSQL, with zero post-authentication disclosure wire bytes on refusal | Remaining dependency/revocation scopes and installed/adverse evidence required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls across all three protocols / 12 file/TLS PostgreSQL threshold histories preserve Authorized proof while changed selected authority invalidates the old still-current exact approval | Complete installed language/UI and remaining selected-authority/adverse boundaries required | @@ -3480,3 +3480,60 @@ Recipient authentication is a transport assumption. Whole-store rollback is outside the guarantee without an independent monotonic anchor; a restored database cannot attest to its own freshness. No new live-provider qualification or deployment claim is made by AP074 source work. + +## Native recovery lifetime reporting and adverse HTTP checkpoint + +- `auths.gateway-recovery/2` now projects retained observation count and declared + response-byte reservations from all sixteen permanent source allocations under + the existing source/read writer fence. It validates canonical row identity and + the selected read's allocation; malformed or discontinuous retained usage cannot + produce a zero-usage report. No recovery ledger or decision owner was added. +- The projection includes the selected complete response receipt time, a finite + 16-attempt / per-read response-byte ceiling, the maintained 15-second observation + deadline, its 240-second aggregate transport allowance, and the existing + 30-second evidence age. The aggregate excludes separate prerequisite transports + and is not a wall-clock completion promise. Reservations are not actual bytes + received and never imply a refund. +- Native escalation distinguishes incomplete, unusable, stale and inconclusive + evidence; unresolved exhaustion takes precedence. Next actions are inspection, + requesting a separately authorized observation if capacity remains, and + escalation. None grants retry, disclosure, non-entry or accounting authority. +- New file and TLS PostgreSQL constructors execute sixteen independently signed, + exactly approved reads after withdrawing the writer root. Actual HTTP returns + 404/no match, multiple records, unrelated echo, incomplete JSON, truncated HTTP, + an oversized body and state equality without causal linkage. Every source + record and its original signed inputs remain byte-identical and unknown. + Replaying every read adds no lease, request or charge. Read seventeen is + durably not-entered with no local allocation, while its public report retains + all sixteen earlier allocations and 262,144 reserved response bytes. Reopening + the adapter preserves exhaustion and authorizes no new I/O. +- The constructors also exercise age 30 inclusively and age 31 as stale without + renewing receipt time, plus refusal of an out-of-range deployment clock. They + do not claim an actual elapsed transport-timeout experiment, unavailable store + or every revocation scope. Those remain explicit acceptance work. +- Construction results: new file constructor 1 passed / 0 ignored (3.34 s), new + PostgreSQL constructor 1 passed / 0 ignored (5.79 s); maintained independent + reader constructors passed on file (1.55 s) and PostgreSQL (2.49 s); the exact + synthetic recovery report constructor passed (3.22 s); CLI/daemon content + journey constructor passed (3.21 s). These construct the changed artifacts, + not fresh hosted qualification. The initial mistyped synthetic selector + matched zero tests; its corrected fully qualified selector executed one test. +- Both new selectors join the explicit adapter workflow, increasing the native + selector inventory from 42 to 44. Bindings return the native report bytes and + contain no parallel recovery calculation. AP070 remains independent with its + narrower application-owned claims; AP073 is untouched. +- The CI subagent's seven-diagnostic durability-helper repair is integrated as + `a3835fa5` (source commit `ca1125bf`). It changes five test files only and + preserves assertions, recipient modes and returned slot bytes. The subagent + reports the specific failed strict Clippy reproduction passed; the main agent + did not inspect CI. Full AP074 completion is not claimed. +- After the final helper cleanup, both new artifact checks passed unchanged: + file 1 passed / 0 ignored (3.36 s), TLS PostgreSQL 1 passed / 0 ignored + (5.12 s). The ordinary provider double still requires successful response + writes; only its explicit oversized-response fault permits a bounded client + to close early. Gateway semantic closure is + `d9b45da9ef5aa30a6601a673c3243b473c01c50fda922d602b3d4fe7d59f8b4e`; + its exact constructor and rebuilt non-update check each passed. Semantic + freeze 422 updates identity 165, public SDK 162, vocabulary 28 and public + surface 422 as required by the inventory generator. These source/metadata + construction results do not replace the exact-head hosted gate. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 13bc7789c..4eea788c9 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -1010,6 +1010,25 @@ native operator projections. Exhaustion or unavailable evidence leaves the effect unresolved and charged; it does not schedule an implicit retry, redelivery or refund. Recovery may remain unresolved indefinitely. +The native `auths.gateway-recovery/2` projection reports source-lifetime retained +observation allocations and response-byte reservations, the per-observation and +aggregate transport deadlines, the evidence-age limit, and the selected read's +complete-response receipt time when available. Usage is read from all sixteen +permanent allocation rows under the same journal fence as source refinement; +changing read operation IDs, replaying, restarting, or refusing a seventeenth +read cannot reset it. The aggregate transport deadline is the sum of the sixteen +observation transport deadlines, not a wall-clock completion bound or a bound on +separately authorized prerequisite transports. Retained byte reservations are +not actual received-byte measurements and are never refunded for failed reads. + +Unusable, incomplete, stale or inconclusive evidence produces native escalation +guidance; unresolved exhaustion takes precedence. Proposed next actions are +inspection, requesting a separately authorized observation while capacity +remains, and escalation. These projections grant no capability and contain no +retry, redelivery, non-entry assertion, evidence override or refund command. +Unavailable or corrupt journal/clock inputs return typed unavailability rather +than fabricating zero usage or an actionable report. + Administrative annotations must remain distinguishable from verified provider evidence. Any administrative resolution that changes evidence or accounting must be an explicit, separately authorized command accepted by the sole reducer under diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 24bf88376..ab8cb2463 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"b98df36f7145c119db8f9bb90ead5961498fb4bd899dca9d16c76c84d0e93dd6"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"31d2405455570abbb71f4061674a4ca7366b943a7226b37131cc37ba112d1f44"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"135b3872e612241b4fa3fe1e71c41e79bc9af6ea5d99dd4f4b6d2cefb2b930ec"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"6c523a767c9a64e7c17032ad49d25cdc6e647e5a02cfe492d225beee2b4cbd2c"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"861ebc3df0aca81c7d7b67d9dced049efbdfd008d466fef3d9ea4cfe34379a9d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"492391f3839c5314efcebfc9ab35a9abd73d7e51627a6d25080c1456f29a92f8"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"b68e122728e8a13de303d201f90b9795fc7a5e5ae65742dda188f85d1741f302"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"e9bf6376d2ccbbd9fea1d841ca266aadf5184262b4d18f56c6e863a61475ded5"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"cdc1e051cb0a51521195281d1e78fff07067ccf21c3335064b0de9a06086e454"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"2e8cc9919b4252bbe12a196f41f9c87796c977303e77bbd60b013bd07612b16e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"0181e8f2710a34ea8385a713a03a28038c4409ed7f9b05fbe5cf58be09d20194"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"c6428074da7a2942636c214705e6865130480792eb4ea104c306778b9b2c4025"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"413f052850c0acb6531f178c9f9a77d4ce1b1beba58b109d6069008194287013"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"ad83076daf87d8fcb5c3e034ab7621972040d3bd9e469ad02336f7e2f8d6f08e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"27d4855ba67d85a7d9e440765dc644d04eb9830353f83210ae415f50c2f92d18"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect.rs b/product/runtime/auths-gateway/src/effect.rs index e887e35e2..c2710a46c 100644 --- a/product/runtime/auths-gateway/src/effect.rs +++ b/product/runtime/auths-gateway/src/effect.rs @@ -47,6 +47,8 @@ pub use candidate::{ CANDIDATE_CHECK_TOOL, CandidateCredentialTarget, compile_candidate_credential, }; mod prerequisite; +#[cfg(test)] +pub(crate) use acquisition::MAX_RECOVERY_ATTEMPTS; pub(crate) use acquisition::{ AcquisitionPlan, MAX_RECOVERY_EVIDENCE_AGE_SECONDS, RECOVERY_READ_TOOL, RecoveryPlan, }; diff --git a/product/runtime/auths-gateway/src/effect/acquisition.rs b/product/runtime/auths-gateway/src/effect/acquisition.rs index 136469dd4..234e45763 100644 --- a/product/runtime/auths-gateway/src/effect/acquisition.rs +++ b/product/runtime/auths-gateway/src/effect/acquisition.rs @@ -84,7 +84,7 @@ impl RecoveryReadTarget { "echo_pointer": self.request.echo_pointer(), "echo": self.echo, "maximum_attempts": MAX_RECOVERY_ATTEMPTS, - "maximum_transport_seconds": 15, + "maximum_transport_seconds": crate::transport::MAX_TRANSPORT_DURATION.as_secs(), "maximum_evidence_age_seconds": MAX_RECOVERY_EVIDENCE_AGE_SECONDS, "disclosure": "none", }) diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 092a3643a..8bd7dd16b 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -695,6 +695,12 @@ async fn exercise_recovery_refinement( .expect("incomplete history"); assert_eq!(unknown.disposition, D::AcquisitionIncomplete); assert_eq!(unknown.source, before); + assert_eq!(unknown.budget.retained_attempts, 16); + assert_eq!( + unknown.report().escalation, + crate::RecoveryEscalation::CapacityExhausted + ); + assert_eq!(unknown.acquisition_received_at, None); let mut outcomes = Vec::new(); for ((name, status, version_ok, body, expected), read) in cases.into_iter().zip(&available) { let operation = LogicalOperationId::parse(read.effect().binding().journal_identity().1) @@ -793,6 +799,8 @@ async fn exercise_recovery_refinement( }; assert_eq!(result.disposition, expected, "{name}"); assert_eq!(result.acquisition.reserved_calls, 1); + assert_eq!(result.budget, unknown.budget); + assert_eq!(result.acquisition_received_at, Some(NOW + 4)); if expected == D::Recorded { assert_eq!( result.source.stage(), diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index c207a7140..46664f6ba 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -145,9 +145,9 @@ pub use store::{ GatewayInsert, GatewayObservationFact, GatewayOperationStage, GatewayPreEntry, GatewayProviderEvidence, GatewayRecordEntry, GatewayRecordKind, GatewayRecoveryReport, GatewayRelativeBasis, ObservableGatewayAttempt, PostgresGatewayAttemptStore, - PrivateDirectoryError, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, - ReservedAcquisition, RetainedContent, check_private_directory, - check_private_directory_owned_by, pre_entry_digest, + PrivateDirectoryError, RecoveryBudget, RecoveryDisposition, RecoveryEscalation, + RecoveryNextAction, RecoverySnapshot, RecoverySourceFacts, ReservedAcquisition, + RetainedContent, check_private_directory, check_private_directory_owned_by, pre_entry_digest, }; pub use support::{ MAX_SUPPORT_ATTEMPTS, SUPPORT_BUNDLE_SCHEMA, SupportConnection, SupportConnectionState, diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index 5b061d2fa..c61e78d4e 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -31,6 +31,9 @@ const RECOVERY: &str = "independent-reader"; const PEER_ENV: &str = "AUTHS_AP074_RECOVERY_ACTOR_PEER"; const TARGET: &str = "/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001"; +#[path = "native_recovery_limits_tests.rs"] +mod limits_tests; + #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] enum Outcome { @@ -188,6 +191,14 @@ struct Provider { requests: Arc>>, stop: Arc, worker: Option>, + read_response: Arc>>, +} + +/// Fault data for the provider double only; the native transport is unchanged. +struct ReadResponse { + status: u16, + body: Vec, + declared_length: usize, } fn receive(stream: &mut TcpStream) -> (String, Vec) { stream @@ -234,6 +245,8 @@ impl Provider { let captured = requests.clone(); let stop = Arc::new(AtomicBool::new(false)); let done = stop.clone(); + let read_response = Arc::new(Mutex::new(None::)); + let scripted = read_response.clone(); let worker = thread::spawn(move || { let mut state = Value::Null; while !done.load(Ordering::SeqCst) { @@ -268,9 +281,25 @@ impl Provider { .expect("fields") .remove("auths_echo"); } - let bytes = serde_json::to_vec(&response).expect("response"); - stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n", bytes.len()).as_bytes()).expect("response header"); - stream.write_all(&bytes).expect("response body"); + let body = serde_json::to_vec(&response).expect("response"); + let response = if line.starts_with("GET ") { + scripted.lock().expect("script").take() + } else { + None + } + .unwrap_or(ReadResponse { + status: 200, + declared_length: body.len(), + body, + }); + stream.write_all(format!("HTTP/1.1 {} Fixture\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n", response.status, response.declared_length).as_bytes()).expect("response header"); + if response.body.len() > 16_384 { + // This explicit oversized-response fault permits the + // bounded client to close before receiving the body. + let _ = stream.write_all(&response.body); + } else { + stream.write_all(&response.body).expect("response body"); + } } }); Self { @@ -278,6 +307,7 @@ impl Provider { requests, stop, worker: Some(worker), + read_response, } } } diff --git a/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs b/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs new file mode 100644 index 000000000..b7117ca6e --- /dev/null +++ b/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs @@ -0,0 +1,283 @@ +//! Native recovery accounting and refusal through the maintained engine and HTTP. +use super::*; +use crate::{ + AcquisitionStage, RecoveryDisposition as D, RecoveryEscalation as E, RecoveryNextAction as N, +}; + +fn response(status: u16, body: &[u8]) -> ReadResponse { + ReadResponse { + status, + body: body.to_vec(), + declared_length: body.len(), + } +} + +fn script(index: u64) -> (&'static str, Option, D, E) { + match index { + 0 => ( + "zero-match", + Some(response(404, b"{}")), + D::ResponseUnusable, + E::EvidenceUnusable, + ), + 1 => ( + "multiple-matches", + Some(response( + 200, + br#"[{"fields":{"DemoStatus":"Approved"}},{"fields":{"DemoStatus":"Approved"}}]"#, + )), + D::ResponseUnusable, + E::EvidenceUnusable, + ), + 2 => ( + "unrelated-echo", + Some(response( + 200, + br#"{"fields":{"DemoStatus":"Approved","auths_echo":"unrelated-public-fixture"}}"#, + )), + D::Inconclusive, + E::Inconclusive, + ), + 3 => ( + "incomplete-json", + Some(response(200, b"{")), + D::ResponseUnusable, + E::EvidenceUnusable, + ), + 4 => ( + "truncated-http", + Some(ReadResponse { + status: 200, + body: b"{".to_vec(), + declared_length: 100, + }), + D::AcquisitionIncomplete, + E::EvidenceIncomplete, + ), + 5 => ( + "oversized-response", + Some(ReadResponse { + status: 200, + body: vec![b' '; 16_385], + declared_length: 16_385, + }), + D::AcquisitionIncomplete, + E::EvidenceIncomplete, + ), + _ => ( + "state-equality-without-causation", + None, + D::Inconclusive, + E::Inconclusive, + ), + } +} + +#[allow( + clippy::too_many_lines, + reason = "one bounded native history constructs the recovery limits artifact" +)] +fn matrix(backend: Backend) { + let case = Case::start(backend, Outcome::LostState); + let runtime = runtime(); + let reader_controls = controls(true); + let clock = Arc::clone(&reader_controls.clock); + let (engine, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "bounded-reader", + case.store.reopen(), + reader_controls, + )); + let revision = engine + .effect_configuration_revision() + .expect("operator revision"); + engine + .activate_effect_configuration(revision) + .expect("withdraw writer root"); + runtime.block_on(reject_withdrawn_writer( + &engine, + &case.setup.installation.root, + )); + let mut cases = Vec::new(); + let mut last_operation = String::new(); + for index in 0..crate::effect::MAX_RECOVERY_ATTEMPTS { + let operation = format!("bounded-reader-{index}"); + let (name, response, disposition, escalation) = script(index); + *case.provider.read_response.lock().expect("script") = response; + let call = runtime + .block_on(engine.recovery_authorization_call(SOURCE, &operation)) + .expect("closed native call"); + let signed = author::signed(&call, true); + let effect = runtime + .block_on(engine.compile_recovery_effect(SOURCE, &signed.proof, &signed.action)) + .expect("native independent authority"); + let approval = author::approval(&effect, NOW + 1); + let result = runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &signed.proof, + &signed.action, + approval.clone(), + ))) + .expect("bounded observation"); + assert_eq!(result.disposition, disposition, "{name}"); + assert_eq!(result.source.stage(), crate::GatewayAttemptStage::Unknown); + assert_eq!( + record(&case.store, SOURCE), + case.original, + "inconclusive evidence cannot rewrite the source" + ); + let report = result.report(); + assert_eq!(report.budget.retained_attempts, index + 1); + assert_eq!(report.budget.retained_response_bytes, (index + 1) * 16_384); + assert_eq!(report.budget.maximum_total_response_bytes, 16 * 16_384); + assert_eq!(report.budget.maximum_transport_seconds, 15); + assert_eq!(report.budget.maximum_total_transport_seconds, 240); + assert_eq!(report.budget.maximum_evidence_age_seconds, 30); + let exhausted = index + 1 == crate::effect::MAX_RECOVERY_ATTEMPTS; + assert_eq!( + report.escalation, + if exhausted { + E::CapacityExhausted + } else { + escalation + } + ); + assert_eq!( + report + .next_actions + .contains(&N::RequestIndependentObservation), + !exhausted + ); + assert!(report.next_actions.contains(&N::Escalate)); + assert_eq!( + case.provider.requests.lock().expect("requests").len() as u64, + index + 2 + ); + let witness = engine.execution_witness(); + let retained_read = record(&case.store, &operation); + let replay = runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &signed.proof, + &signed.action, + approval, + ))) + .expect("historical read"); + assert_eq!(replay.report(), report); + assert_eq!( + engine.execution_witness(), + witness, + "replay never leases or sends again" + ); + assert_eq!(record(&case.store, &operation), retained_read); + if index == 6 { + clock.set(NOW + 31); + let at_limit = runtime + .block_on(engine.refine_recovery(SOURCE, &operation)) + .expect("freshness boundary"); + assert_eq!(at_limit.disposition, D::Inconclusive); + clock.set(NOW + 32); + let stale = runtime + .block_on(engine.refine_recovery(SOURCE, &operation)) + .expect("stale evidence remains history"); + assert_eq!(stale.disposition, D::EvidenceStale); + assert_eq!(stale.report().escalation, E::EvidenceStale); + assert_eq!(stale.budget, result.budget); + assert_eq!(engine.execution_witness(), witness); + clock.set(u64::MAX); + assert_eq!( + runtime + .block_on(engine.refine_recovery(SOURCE, &operation)) + .expect_err("out-of-range clock cannot fabricate a report"), + "gateway.recovery.unavailable" + ); + clock.set(NOW + 1); + } + cases.push(json!({"case":name, "report":report, "replay_no_io_or_new_charge":true})); + last_operation = operation; + } + let witness = engine.execution_witness(); + let requests = case.provider.requests.lock().expect("requests").len(); + let call = runtime + .block_on(engine.recovery_authorization_call(SOURCE, "bounded-reader-over-limit")) + .expect("proposed read"); + let signed = author::signed(&call, true); + let effect = runtime + .block_on(engine.compile_recovery_effect(SOURCE, &signed.proof, &signed.action)) + .expect("authority does not imply capacity"); + let approval = author::approval(&effect, NOW + 1); + let refused = runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &signed.proof, + &signed.action, + approval, + ))) + .expect("retained exhausted attempt"); + assert_eq!(refused.acquisition.stage, AcquisitionStage::NotEntered); + assert_eq!(refused.acquisition.reserved_calls, 0); + assert_eq!(refused.acquisition.reserved_bytes, 0); + assert_eq!(refused.report().escalation, E::CapacityExhausted); + assert_eq!(refused.budget.retained_attempts, 16); + assert_eq!(refused.budget.retained_response_bytes, 16 * 16_384); + assert_eq!( + refused.report().next_actions, + [N::InspectRetainedEvidence, N::Escalate] + ); + assert_eq!( + engine.execution_witness(), + witness, + "exhaustion precedes custody and transport" + ); + assert_eq!( + case.provider.requests.lock().expect("requests").len(), + requests + ); + assert_eq!(record(&case.store, SOURCE), case.original); + assert_eq!( + signed_bytes(&case.setup.installation.root, SOURCE), + case.signed_source + ); + let reopened_runtime = runtime; + let (reopened, _) = reopened_runtime.block_on(load_controlled_engine( + &case.setup.installation, + "reopened-reader", + case.store.reopen(), + controls(true), + )); + let retained = reopened_runtime + .block_on(reopened.refine_recovery(SOURCE, &last_operation)) + .expect("retained lifetime usage after reopen"); + assert_eq!(retained.budget, refused.budget); + assert_eq!(retained.report().escalation, E::CapacityExhausted); + assert_eq!(reopened.execution_witness().credential_lease_calls, 0); + let artifact = serde_json::to_vec_pretty(&json!({ + "schema":"auths.native-recovery-limits/1", "adapter":backend.label(), + "scope":"native signed independent recovery, exact approvals, withdrawn writer root, actual bounded HTTP and durable source-lifetime rows; writer uses a separate OS process", + "excluded":["live provider and custody", "hostile OS or device power failure", "total prerequisite transport time"], + "cases":cases, "exhausted":refused.report(), "reopen_preserves_lifetime_usage":true, + "freshness_30_inclusive_31_stale":true, "out_of_range_clock_refuses_report":true, + "source_actor_entry_and_all_original_charges_unchanged":true + })).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-recovery-limits-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} + +#[test] +fn native_file_recovery_limits_fixture_is_current() { + matrix(Backend::File); +} + +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_recovery_limits_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index d46845eaa..b81b07511 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "beeffaf90c992ad9fd06add58831299ef67e47c61a6306797bc5f427eca7f568"; + "d9b45da9ef5aa30a6601a673c3243b473c01c50fda922d602b3d4fe7d59f8b4e"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 91373d890..34b7059f6 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -745,8 +745,9 @@ mod capacity; mod disclosure; pub use acquisition::{ AcquisitionClaim, AcquisitionSnapshot, AcquisitionStage, CandidatePublication, - ContentProjectionStatus, GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, - RecoverySourceFacts, ReservedAcquisition, RetainedContent, + ContentProjectionStatus, GatewayRecoveryReport, RecoveryBudget, RecoveryDisposition, + RecoveryEscalation, RecoveryNextAction, RecoverySnapshot, RecoverySourceFacts, + ReservedAcquisition, RetainedContent, }; pub(crate) use acquisition::{AcquisitionEntryPermit, AcquisitionRequest, PrerequisiteResponse}; #[cfg(unix)] diff --git a/product/runtime/auths-gateway/src/store/acquisition.rs b/product/runtime/auths-gateway/src/store/acquisition.rs index c003e8cf4..49ccd50a2 100644 --- a/product/runtime/auths-gateway/src/store/acquisition.rs +++ b/product/runtime/auths-gateway/src/store/acquisition.rs @@ -16,7 +16,8 @@ pub use candidate::CandidatePublication; mod recovery; pub(super) use recovery::RecoveryEvidenceLink; pub use recovery::{ - GatewayRecoveryReport, RecoveryDisposition, RecoverySnapshot, RecoverySourceFacts, + GatewayRecoveryReport, RecoveryBudget, RecoveryDisposition, RecoveryEscalation, + RecoveryNextAction, RecoverySnapshot, RecoverySourceFacts, }; /// Public facts about a bounded acquisition, with no content or private digest. diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index 5d8410555..afd6732f8 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -36,6 +36,63 @@ pub struct RecoverySnapshot { pub acquisition: AcquisitionSnapshot, /// The bounded evidence decision, without implying a new execution permit. pub disposition: RecoveryDisposition, + /// Source-lifetime charges inspected under the same source/read fence. + pub budget: RecoveryBudget, + /// Receipt time of this read's complete response, never refreshed by replay. + pub acquisition_received_at: Option, +} + +/// Native lifetime accounting, including failed and ambiguous observations. +/// These are retained reservations, not measurements of bytes actually received. +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +pub struct RecoveryBudget { + /// Permanent observation allocations for this source, across operation IDs. + pub retained_attempts: u64, + /// Maximum number of independently authorized observation entries. + pub maximum_attempts: u64, + /// Maximum retained response bytes for each observation. + pub maximum_response_bytes: u64, + /// Sum of the permanent response-byte reservations, without refunds. + pub retained_response_bytes: u64, + /// Maximum response-byte reservation across all observation entries. + pub maximum_total_response_bytes: u64, + /// Deadline for each observation transport, excluding prerequisite transports. + pub maximum_transport_seconds: u64, + /// Sum of the observation transport deadlines at the lifetime attempt limit. + pub maximum_total_transport_seconds: u64, + /// Maximum evidence age when independently acquired evidence is recorded. + pub maximum_evidence_age_seconds: u64, +} + +/// Reason to seek operator attention; it never changes evidence or accounting. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub enum RecoveryEscalation { + /// No additional escalation follows from the retained recovery facts. + None, + /// No observation capacity remains and the source is still unresolved. + CapacityExhausted, + /// The observation has no complete retained response. + EvidenceIncomplete, + /// The response does not satisfy the declared observation contract. + EvidenceUnusable, + /// The evidence is outside the declared freshness interval. + EvidenceStale, + /// The observation cannot establish the source effect or its causal link. + Inconclusive, +} + +/// Operator proposals, never execution permits. All provider I/O still requires +/// fresh native authorization, exact approval, admission and an entry grant. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case")] +pub enum RecoveryNextAction { + /// Inspect retained evidence without changing the original attribution. + InspectRetainedEvidence, + /// Request a new independently authorized read, subject to all current gates. + RequestIndependentObservation, + /// Seek operator attention while preserving uncertainty and every charge. + Escalate, } /// Public recovery projection containing no response bytes, locators, echo, @@ -50,6 +107,14 @@ pub struct GatewayRecoveryReport { pub acquisition: AcquisitionSnapshot, /// Evidence decision; response alone never implies mutation success. pub disposition: RecoveryDisposition, + /// Same-fence lifetime accounting; no separate recovery ledger is maintained. + pub budget: RecoveryBudget, + /// Why the unresolved source requires operator attention. + pub escalation: RecoveryEscalation, + /// Proposals only; none authorizes mutation retry, redelivery or refund. + pub next_actions: Vec, + /// Complete response receipt time even when its contents are unusable. + pub acquisition_received_at: Option, } /// Safe source facts without the protected evidence used to establish them. @@ -74,8 +139,37 @@ impl RecoverySnapshot { /// or provider response, even when the source has linked evidence. #[must_use] pub fn report(&self) -> GatewayRecoveryReport { + let can_observe = !matches!( + self.source.stage(), + GatewayAttemptStage::NotEntered + | GatewayAttemptStage::Observed + | GatewayAttemptStage::ObservedByProvider + ); + let exhausted = self.budget.retained_attempts >= self.budget.maximum_attempts; + let escalation = if !can_observe { + RecoveryEscalation::None + } else if exhausted { + RecoveryEscalation::CapacityExhausted + } else { + match self.disposition { + RecoveryDisposition::AcquisitionIncomplete => { + RecoveryEscalation::EvidenceIncomplete + } + RecoveryDisposition::ResponseUnusable => RecoveryEscalation::EvidenceUnusable, + RecoveryDisposition::EvidenceStale => RecoveryEscalation::EvidenceStale, + RecoveryDisposition::Inconclusive => RecoveryEscalation::Inconclusive, + _ => RecoveryEscalation::None, + } + }; + let mut next_actions = vec![RecoveryNextAction::InspectRetainedEvidence]; + if can_observe && !exhausted { + next_actions.push(RecoveryNextAction::RequestIndependentObservation); + } + if escalation != RecoveryEscalation::None { + next_actions.push(RecoveryNextAction::Escalate); + } GatewayRecoveryReport { - schema: "auths.gateway-recovery/1", + schema: "auths.gateway-recovery/2", source: RecoverySourceFacts { stage: self.source.stage(), revision: self.source.revision(), @@ -86,6 +180,10 @@ impl RecoverySnapshot { }, acquisition: self.acquisition.clone(), disposition: self.disposition, + budget: self.budget.clone(), + escalation, + next_actions, + acquisition_received_at: self.acquisition_received_at, } } } @@ -264,6 +362,63 @@ fn refinement( Ok(Ok(next)) } +/// Inspect the finite permanent allocation set; never infer usage from just +/// the selected read, which may itself have been refused without an allocation. +fn recovery_budget( + read: &Record, + read_key: GatewayAttemptKey, + capacity: &SourceCapacity, + snapshots: &[Option>], +) -> Result { + if snapshots.len() + != usize::try_from(capacity.attempts).map_err(|_| GatewayAttemptError::Corrupt)? + { + return Err(GatewayAttemptError::Corrupt); + } + let mut retained_attempts = 0_u64; + let mut vacant = false; + for (slot, bytes) in (0..capacity.attempts).zip(snapshots) { + let Some(bytes) = bytes else { + vacant = true; + continue; + }; + if vacant { + return Err(GatewayAttemptError::Corrupt); + } + let row: capacity::SourceAllocation = + serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + row.validate_occupied(&allocation(&read.state.plan, read_key, slot)?, bytes) + .map_err(|_| GatewayAttemptError::Corrupt)?; + retained_attempts += 1; + } + if let Some(slot) = read.state.allocation + && snapshots + .get(usize::try_from(slot).map_err(|_| GatewayAttemptError::Corrupt)?) + .and_then(|bytes| bytes.as_deref()) + != Some(canonical(&allocation(&read.state.plan, read_key, slot)?)?.as_slice()) + { + return Err(GatewayAttemptError::Corrupt); + } + Ok(RecoveryBudget { + retained_attempts, + maximum_attempts: capacity.attempts, + maximum_response_bytes: capacity.maximum_bytes, + retained_response_bytes: retained_attempts + .checked_mul(capacity.maximum_bytes) + .ok_or(GatewayAttemptError::Corrupt)?, + maximum_total_response_bytes: capacity + .attempts + .checked_mul(capacity.maximum_bytes) + .ok_or(GatewayAttemptError::Corrupt)?, + maximum_transport_seconds: crate::transport::MAX_TRANSPORT_DURATION.as_secs(), + maximum_total_transport_seconds: capacity + .attempts + .checked_mul(crate::transport::MAX_TRANSPORT_DURATION.as_secs()) + .ok_or(GatewayAttemptError::Corrupt)?, + maximum_evidence_age_seconds: MAX_RECOVERY_EVIDENCE_AGE_SECONDS, + }) +} + impl GatewayAttempts { /// Records supported evidence from an already authorized read. It never /// re-verifies the expired writer or performs provider/custody I/O. The @@ -304,7 +459,10 @@ impl GatewayAttempts { (GatewayRecordKind::Attempt, key), (GatewayRecordKind::Attempt, read_key), ]; - if let Some(slot) = read.state.allocation { + // The bounded lifetime rows, rather than just this read's row, + // establish retained usage. The adapter's existing writer fence + // orders them with concurrent admissions and source refinement. + for slot in 0..capacity.attempts { keys.push(( GatewayRecordKind::EffectAllocation, capacity::allocation_key(&capacity, slot), @@ -331,14 +489,7 @@ impl GatewayAttempts { { return Err(GatewayAttemptError::BindingConflict); } - if let Some(slot) = read.state.allocation - && snapshots[2].as_deref() - != Some( - canonical(&allocation(&read.state.plan, read_key, slot)?)?.as_slice(), - ) - { - return Err(GatewayAttemptError::Corrupt); - } + let budget = recovery_budget(&read, read_key, &capacity, &snapshots[2..])?; let now = clock .effect_time() .filter(|now| *now <= MAX_JSON_INTEGER) @@ -355,6 +506,13 @@ impl GatewayAttempts { source, acquisition: read.snapshot()?, disposition, + acquisition_received_at: match &read.state.phase { + AcquisitionPhase::ResponseRecorded { response } => { + Some(response.received_at) + } + _ => None, + }, + budget, }); if let Some(bytes) = next { Ok(bytes) diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index b8fd135e7..2d2bc6a09 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -956,6 +956,12 @@ fn native_content_process_journey_fixture_is_current() { .is_some_and(|time| time >= now) ); observed["report"]["source"]["recovery_received_at"] = json!("actual-runtime-time-checked"); + assert!( + observed["report"]["acquisition_received_at"] + .as_u64() + .is_some_and(|time| time >= now) + ); + observed["report"]["acquisition_received_at"] = json!("actual-runtime-time-checked"); let artifact=serde_json::to_vec_pretty(&json!({"schema":"auths.content-process-journey/1", "scope":"production CLI and daemon processes, native proofs/exact approval, real file custody/journal and counting loopback HTTP; public fixed signing keys simulate reviewer, actor and recipient; no human presence, UID containment, installed language package, power loss or PostgreSQL claim", "provider_requests":provider.calls(),"acquisition":acquired,"disclosure":disclosed,"mutation":written,"observation":observed, diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 656084227..d73a2807a 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 421 +freeze_version = 422 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 421 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 164 +"auths.identity.protocol" = 165 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 421 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 161 +"auths.product.public-sdk-contract" = 162 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 -"auths.product.vocabulary" = 27 +"auths.product.vocabulary" = 28 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 421 +"auths.release.public-surface" = 422 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 83fa6d5e6..856b3b38a 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 421, + "freezeVersion": 422, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 164, + "version": 165, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "d31f69cbcb8920f3b393749754550f7c928eec7d26a7188708b8704fa64b5e5c" + "sha256": "178e90e8862f5a43f8965a3a34163e7e0d4d836a8f3a8af9b913d488a9e24642" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 161, + "version": 162, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "7858985d21cf0e97667fa6fee118d944c91ecf29df4f6c32dde43d0880f84b56" + "sha256": "b4c84b6cc90dccc248ca6b302489414bcc98a55da4f3e72805834a9e9d9f32a3" }, { "id": "auths.product.receipts", @@ -947,7 +947,7 @@ }, { "id": "auths.product.vocabulary", - "version": 27, + "version": 28, "classification": "frozen-meaning", "categories": [ "customer-vocabulary", @@ -965,7 +965,7 @@ "product/sdk/auths-sdk/Cargo.toml", "xtask/src/sdk_vocabulary.rs" ], - "sha256": "479285a6ee17be76f01fde6b88f2b3e75eea73bf4a37084f080e7c43650c0dde" + "sha256": "4162f24053837ece3e947e0f9d9085a24b5e18709bee1745f0c6e0b22e4f1478" }, { "id": "auths.release.benchmark-contract", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 421, + "version": 422, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "3005c300d253a328b479ae9b54b2d25f3ecedd8924975e433702ef3aa3a34b4e" + "sha256": "b7defade2ef034d0963625c6c4ef2a28e37e6c6a0bc494adffb0deaa986c8136" } ] } From 0d774a01cadfd2829561ea88bb5c8f9a46f5c3b1 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 01:49:13 +0000 Subject: [PATCH 113/136] fix(gateway): retain recovery history after reader withdrawal --- .github/workflows/postgres-lifecycle.yml | 2 + .../gateway/native-recovery-history-file.json | 567 ++++++++++++++++++ .../native-recovery-history-postgres.json | 567 ++++++++++++++++++ .../gateway/native-recovery-limits-file.json | 20 +- .../native-recovery-limits-postgres.json | 20 +- compliance.toml | 2 + docs/plans/0074-implementation-status.md | 67 ++- ...ound-effects-and-recovery-state-machine.md | 10 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/engine.rs | 90 ++- .../src/native_recovery_actor_tests.rs | 30 + .../src/native_recovery_authoring.rs | 17 +- .../src/native_recovery_history_tests.rs | 489 +++++++++++++++ .../src/native_recovery_limits_tests.rs | 26 + .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 17 files changed, 1864 insertions(+), 69 deletions(-) create mode 100644 bindings/fixtures/gateway/native-recovery-history-file.json create mode 100644 bindings/fixtures/gateway/native-recovery-history-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_recovery_history_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 07b45817d..4a2df91a7 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -94,6 +94,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::limits_tests::native_file_recovery_limits_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::limits_tests::postgres_native_recovery_limits_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::history_tests::native_file_recovery_history_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::history_tests::postgres_native_recovery_history_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres } 2>&1 | tee target/ap074-native-adapter-evidence.log - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 diff --git a/bindings/fixtures/gateway/native-recovery-history-file.json b/bindings/fixtures/gateway/native-recovery-history-file.json new file mode 100644 index 000000000..322ebfe79 --- /dev/null +++ b/bindings/fixtures/gateway/native-recovery-history-file.json @@ -0,0 +1,567 @@ +{ + "schema": "auths.native-recovery-history/1", + "adapter": "file", + "scope": "native signed proofs and exact approvals, real local HTTP including elapsed 15-second timeout, maintained durable adapters, operator root withdrawal and connection disable", + "assumptions": [ + "trusted maintained host and fixed test clock", + "public fixed fixture keys" + ], + "excluded": [ + "database outage or filesystem-device failure qualification", + "live provider and custody", + "hostile OS and power failure" + ], + "store_error_scope": "controlled load error and error inside the actual adapter writer fence; no synthetic journal facts", + "cases": [ + { + "case": "linked-response", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "inconclusive-response", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "evidence-stale", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-stale", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "pre-grant-reservation", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "elapsed-native-transport-timeout", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-recovery-history-postgres.json b/bindings/fixtures/gateway/native-recovery-history-postgres.json new file mode 100644 index 000000000..c59f96d67 --- /dev/null +++ b/bindings/fixtures/gateway/native-recovery-history-postgres.json @@ -0,0 +1,567 @@ +{ + "schema": "auths.native-recovery-history/1", + "adapter": "postgres", + "scope": "native signed proofs and exact approvals, real local HTTP including elapsed 15-second timeout, maintained durable adapters, operator root withdrawal and connection disable", + "assumptions": [ + "trusted maintained host and fixed test clock", + "public fixed fixture keys" + ], + "excluded": [ + "database outage or filesystem-device failure qualification", + "live provider and custody", + "hostile OS and power failure" + ], + "store_error_scope": "controlled load error and error inside the actual adapter writer fence; no synthetic journal facts", + "cases": [ + { + "case": "linked-response", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "observed-by-provider", + "revision": 4, + "response_status": null, + "observation_match": null, + "provider_linked": true, + "recovery_received_at": 1790000001 + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 125, + "response_version_ok": true + }, + "disposition": "already-recorded", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "none", + "next_actions": [ + "inspect-retained-evidence" + ], + "acquisition_received_at": 1790000001 + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "inconclusive-response", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "evidence-stale", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-stale", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 36, + "response_version_ok": true + }, + "disposition": "inconclusive", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "inconclusive", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": 1790000001 + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "pre-grant-reservation", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": false + }, + { + "case": "elapsed-native-transport-timeout", + "first": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "expired": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "withdrawn": { + "schema": "auths.gateway-recovery/2", + "source": { + "stage": "unknown", + "revision": 3, + "response_status": null, + "observation_match": null, + "provider_linked": false, + "recovery_received_at": null + }, + "acquisition": { + "revision": 3, + "stage": "unknown", + "reserved_calls": 1, + "reserved_bytes": 16384, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "disposition": "acquisition-incomplete", + "budget": { + "retained_attempts": 1, + "maximum_attempts": 16, + "maximum_response_bytes": 16384, + "retained_response_bytes": 16384, + "maximum_total_response_bytes": 262144, + "maximum_transport_seconds": 15, + "maximum_total_transport_seconds": 240, + "maximum_evidence_age_seconds": 30 + }, + "escalation": "evidence-incomplete", + "next_actions": [ + "inspect-retained-evidence", + "request-independent-observation", + "escalate" + ], + "acquisition_received_at": null + }, + "unavailable_store": [ + { + "outcome": "indeterminate", + "code": "gateway.attempt.state-unavailable" + }, + { + "outcome": "indeterminate", + "code": "gateway.recovery.unavailable" + } + ], + "original_attribution_and_charges_preserved": true, + "receipt_time_never_refreshed": true, + "expired_and_withdrawn_new_read_refused": true, + "altered_inputs_source_or_approval_refused": true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable": true, + "elapsed_timeout_checked_against_native_deadline": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-recovery-limits-file.json b/bindings/fixtures/gateway/native-recovery-limits-file.json index 56d7d6b29..32d0c0a90 100644 --- a/bindings/fixtures/gateway/native-recovery-limits-file.json +++ b/bindings/fixtures/gateway/native-recovery-limits-file.json @@ -273,7 +273,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "response-byte-limit-accepted", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -292,7 +292,7 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 16384, "response_version_ok": true }, "disposition": "inconclusive", @@ -317,7 +317,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "empty-success-response", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -336,10 +336,10 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 2, "response_version_ok": true }, - "disposition": "inconclusive", + "disposition": "response-unusable", "budget": { "retained_attempts": 8, "maximum_attempts": 16, @@ -350,7 +350,7 @@ "maximum_total_transport_seconds": 240, "maximum_evidence_age_seconds": 30 }, - "escalation": "inconclusive", + "escalation": "evidence-unusable", "next_actions": [ "inspect-retained-evidence", "request-independent-observation", @@ -361,7 +361,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "duplicate-response-members", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -380,10 +380,10 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 59, "response_version_ok": true }, - "disposition": "inconclusive", + "disposition": "response-unusable", "budget": { "retained_attempts": 9, "maximum_attempts": 16, @@ -394,7 +394,7 @@ "maximum_total_transport_seconds": 240, "maximum_evidence_age_seconds": 30 }, - "escalation": "inconclusive", + "escalation": "evidence-unusable", "next_actions": [ "inspect-retained-evidence", "request-independent-observation", diff --git a/bindings/fixtures/gateway/native-recovery-limits-postgres.json b/bindings/fixtures/gateway/native-recovery-limits-postgres.json index 8fe708be6..d8c17870b 100644 --- a/bindings/fixtures/gateway/native-recovery-limits-postgres.json +++ b/bindings/fixtures/gateway/native-recovery-limits-postgres.json @@ -273,7 +273,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "response-byte-limit-accepted", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -292,7 +292,7 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 16384, "response_version_ok": true }, "disposition": "inconclusive", @@ -317,7 +317,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "empty-success-response", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -336,10 +336,10 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 2, "response_version_ok": true }, - "disposition": "inconclusive", + "disposition": "response-unusable", "budget": { "retained_attempts": 8, "maximum_attempts": 16, @@ -350,7 +350,7 @@ "maximum_total_transport_seconds": 240, "maximum_evidence_age_seconds": 30 }, - "escalation": "inconclusive", + "escalation": "evidence-unusable", "next_actions": [ "inspect-retained-evidence", "request-independent-observation", @@ -361,7 +361,7 @@ "replay_no_io_or_new_charge": true }, { - "case": "state-equality-without-causation", + "case": "duplicate-response-members", "report": { "schema": "auths.gateway-recovery/2", "source": { @@ -380,10 +380,10 @@ "policy_count_counters": 0, "policy_byte_counters": 0, "response_status": 200, - "response_bytes": 36, + "response_bytes": 59, "response_version_ok": true }, - "disposition": "inconclusive", + "disposition": "response-unusable", "budget": { "retained_attempts": 9, "maximum_attempts": 16, @@ -394,7 +394,7 @@ "maximum_total_transport_seconds": 240, "maximum_evidence_age_seconds": 30 }, - "escalation": "inconclusive", + "escalation": "evidence-unusable", "next_actions": [ "inspect-retained-evidence", "request-independent-observation", diff --git a/compliance.toml b/compliance.toml index ecf82603e..c8cb6fd5e 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1827,6 +1827,8 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_recovery_actor_tests.rs#postgres_native_independent_recovery_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#native_file_recovery_limits_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#postgres_native_recovery_limits_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#native_file_recovery_history_fixture_is_current", + "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#postgres_native_recovery_history_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#native_file_mutation_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 207f00e09..58ef9d7aa 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3458,11 +3458,11 @@ separate claim. No complete AP074 acceptance gate is currently closed or externa | A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash, commit-reply loss and file-error corpora / fifty-six release crash histories, eight committed/aborted release transactions and eighteen file-error histories retain charges through lost grants and ACK/Unknown persistence; genuine late ACKs never authorize redelivery | Remaining adverse races, runtime links and full installed boundary evidence pending | | A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | | A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | -| A11 | Missing/multiple/unrelated/incomplete reconciliation | Native implementation and file/TLS PostgreSQL HTTP constructors now cover zero, multiple, unrelated and incomplete observations, conservative unknown state, lifetime usage and escalation | Current-head hosted confirmation; actual transport timeout and remaining A15/A22 authority/store/interface cases remain outstanding | +| A11 | Missing/multiple/unrelated/incomplete reconciliation | Native implementation and file/TLS PostgreSQL HTTP constructors cover zero, multiple, unrelated and incomplete observations; elapsed native transport timeout; lifetime usage, escalation and conservative unavailable-store responses | Current-head hosted confirmation; full installed/interface evidence remains under A22 | | A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus 24 mutation and 24 disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | | A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native acquisition/mutation/disclosure proof/approval/observer/threshold lock waits / eligible and expired controls executed on file/TLS PostgreSQL, with zero post-authentication disclosure wire bytes on refusal | Remaining dependency/revocation scopes and installed/adverse evidence required | | A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls across all three protocols / 12 file/TLS PostgreSQL threshold histories preserve Authorized proof while changed selected authority invalidates the old still-current exact approval | Complete installed language/UI and remaining selected-authority/adverse boundaries required | -| A15 | Recovery actor differs; original authority revoked | Partial / native independent writer/reader OS-process journey / eight file/TLS PostgreSQL histories execute after operator withdrawal of writer root, with original entry/identity/charges preserved and fresh independent reader approval | Other revocation scopes and full installed language/authenticated UI evidence remain required | +| A15 | Recovery actor differs; original authority revoked | Native implementation / eight independent writer/reader OS-process histories plus eight retained-history schedules on file/TLS PostgreSQL; writer withdrawal, reader grant/approval expiry and root withdrawal preserve attribution/charges while blocking new entry | Current-head hosted confirmation; further final-entry scopes remain under A12/A13 and installed owner/interface evidence under A22 | | A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | | A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | | A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | @@ -3537,3 +3537,66 @@ or deployment claim is made by AP074 source work. freeze 422 updates identity 165, public SDK 162, vocabulary 28 and public surface 422 as required by the inventory generator. These source/metadata construction results do not replace the exact-head hosted gate. + +## Exact retained recovery history and elapsed timeout checkpoint + +- Fixed a production discrepancy in `GatewayEngine::recover`: it previously + recompiled the reader's current authority for every request, including exact + replay. `acquire_recovery` already supported exact historical retrieval. Both + entry points now use one acquisition helper and the same native journal match. + The read operation comes from either the compiled binding or a journal-validated + canonical-action hint whose proof/action digests, complete binding, installed + scope and pinned approval signature have matched. Hints alone expose no facts. +- Reader grant/approval expiry, operator withdrawal of the reader root and a + disabled connection cannot erase completed, ambiguous or reserved read facts. + A retained reservation is returned unchanged when fresh authorization fails; + it cannot resume or create a permit. New inputs still need current native + authority, exact approval, admission and the final durable grant. Historical + refinement preserves the original source actor, entry, charges and response + receipt time; stale unresolved evidence stays stale. +- New file and TLS PostgreSQL history constructors execute four scenarios each: + linked response, inconclusive response, pre-grant reservation and actual + elapsed transport timeout. A provider control channel withholds every response + byte while the maintained 15-second native deadline fires; the test then + releases the provider. It checks the actual elapsed interval, the provider + still waiting at timeout, one GET only, unknown acquisition and retained + capacity. No synthetic transport timeout result is supplied. +- The pre-grant scenario lets native admission and grant validation run through + the real adapter, then returns a controlled error before the grant is written. + Later expiry/withdrawal cannot resume this reserved read. Additional controlled + errors at attempt load and inside the actual adapter writer fence return typed + unavailability without a public zero-usage report, source/read mutation or I/O. + These are adapter-port refusal tests, not a claim about a physical database + outage, filesystem/device error or power failure. Earlier syscall/transaction + fault artifacts retain their separate claims. +- Each scenario preserves the source/read and all sixteen allocation-key + snapshots across expiry, withdrawal, unavailable-store probes and connection + disable. Altered proof, action, source hint or approval is refused. Previously + approved inputs for a different, never-entered read cannot acquire custody or + contact HTTP after expiry or root withdrawal. +- Exact constructor results: file history 1 passed / 0 ignored (17.07 s); TLS + PostgreSQL history 1 passed / 0 ignored (17.92 s). Existing independent-reader + artifacts passed unchanged on file (1.73 s) and PostgreSQL (2.43 s). These are + required artifact construction results, not hosted qualification. Both new + selectors are explicit in the adapter workflow, increasing the inventory + from 44 to 46. No AP070 or AP073 files were changed. +- After restricting the pre-grant fault to this exact recovery operation key, + both new artifacts passed unchanged: file 1 passed / 0 ignored (17.15 s), + TLS PostgreSQL 1 passed / 0 ignored (17.90 s). Existing exhaustion artifacts + passed unchanged on file (3.31 s) and PostgreSQL (4.69 s); the exact + CLI/daemon content journey artifact passed unchanged (3.27 s). No broad + local CI gate was run, and no current-head hosted completion is claimed. +- The same batch expands the existing actual-HTTP lifetime corpus with a + complete 16,384-byte response at the exact declared limit, an empty successful + response and duplicate response members. The limit response is completely + recorded and compared without implying causation; empty/multiple/duplicate + responses are unusable. The existing 16,385-byte case remains unknown, with + its full reservation retained. Updated constructors passed on file (3.29 s) + and PostgreSQL (5.10 s), each 1 passed / 0 ignored. +- Final exact-limit assertions passed unchanged on file (4.59 s) and TLS + PostgreSQL (5.63 s), each 1 passed / 0 ignored. Gateway semantic closure is + `7371aee21694d1783a11ce8fc8977b8db6c921df83ca6407cfb01012136525fd`; + its constructor and rebuilt non-update check each passed. Semantic freeze + 423 updates identity 166, public SDK 163 and public surface 423, the only + changed subjects reported by the generator. The runtime orchestration change + adds no reducer transition, permit constructor or accounting authority. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 4eea788c9..6e4d39f7b 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -1001,6 +1001,16 @@ For this milestone, provider-entry and disclosure-entry permits are one-use, and continuing it, refunding charges or modifying the journal. - Provider idempotency may improve provider guarantees but does not override the default prohibition on Auths re-entry. Any future retry mode requires an explicit versioned protocol and evidence for key scope, retention, fencing and late requests. - Late valid response/ACK evidence can refine an unknown outcome. Revocation or expiry must not erase legitimate history or prevent recording a previously authorized delivery's exact ACK. Recording history confers no current execution authority. +- The combined recovery entry point MUST use the same exact historical lookup + as acquisition before attempting current reader compilation. Expired or + withdrawn reader authority and a disabled connection prevent new entry; they + do not erase completed, unknown or pre-grant reserved read facts. Historical + recovery obtains its read operation identity from that validated journal match, + while new recovery obtains it from the native compiled binding. A retained + reservation can resume only through fresh authorization and the final grant; + returning its history cannot resume it. Source/read refinement still requires + a usable deployment clock and available journal, and never refreshes receipt + time or fabricates a zero-usage report on failure. - Read-only recovery requires its own bounded authority and accounting. It cannot borrow a revoked writer's proof, use an expired approval as current authority, acquire broader credentials or change the original actor attribution. Unresolved effects also have an operational contract. Declare finite observation diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index ab8cb2463..8d09a1496 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"aafaf3472769497a480f76a51291f7da787dca28ba5dc6a7ba762f6bc0b3c3b7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"ad83076daf87d8fcb5c3e034ab7621972040d3bd9e469ad02336f7e2f8d6f08e"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"8dbc23381e1ac2edb578bff18635156bafb70e4446ce00ad8e7a09cd089fa109"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"27d4855ba67d85a7d9e440765dc644d04eb9830353f83210ae415f50c2f92d18"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"00fe8b9cbabfee5e18333dc2012d669b7456c20fee59d4914a8ccb4e73526606"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"606f6ffe0bcea6ae7dc81f420938fc65943fb1a44b5e5e67b0e9a31493cb833a"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index e93930578..d98515698 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -396,6 +396,13 @@ struct PreparedEntry { transport: GatewayHttpTransport, } +/// A lookup hint becomes a historical identity only after the journal matches +/// the exact native inputs, retained binding and its pinned approval signature. +struct RetainedHistory { + operation: crate::LogicalOperationId, + submission: crate::store::RetainedSubmission, +} + /// Data-only endpoint constraints for retained history. Native compilation still /// owns all fresh authorization and grants; these checks bind extra API inputs /// to the exact historical action rather than trusting an operation-ID hint. @@ -1876,19 +1883,39 @@ impl GatewayEngine { action: &[u8], approval: ExactEffectApproval, ) -> Result { + self.acquire_recovery_with_operation(source_operation, proof, action, approval) + .await + .map(|(_, snapshot)| snapshot) + } + + async fn acquire_recovery_with_operation( + &self, + source_operation: &str, + proof: &[u8], + action: &[u8], + approval: ExactEffectApproval, + ) -> Result<(crate::LogicalOperationId, crate::AcquisitionSnapshot), GatewaySubmitResult> { let started = Instant::now(); - let retained = self - .retained_acquisition( + let retained = match self + .retained_submission( proof, action, &approval, RetainedRoute::Recovery(source_operation), ) - .await?; - if let Some(snapshot) = &retained + .await? + { + Some(RetainedHistory { + operation, + submission: crate::store::RetainedSubmission::Acquisition(snapshot), + }) => Some((operation, snapshot)), + None => None, + Some(_) => return Err(not_entered("gateway.effect.operation-conflict")), + }; + if let Some((operation, snapshot)) = &retained && snapshot.stage != crate::AcquisitionStage::Reserved { - return Ok(snapshot.clone()); + return Ok((operation.clone(), snapshot.clone())); } let current = async { let effect = self @@ -1901,7 +1928,11 @@ impl GatewayEngine { Ok(current) => current, Err(result) => return retained.ok_or(result), }; - self.acquire_read_approved(approved, now, started).await + let operation = + crate::LogicalOperationId::parse(approved.effect().binding().journal_identity().1) + .map_err(|_| not_entered("gateway.acquisition.binding"))?; + let snapshot = self.acquire_read_approved(approved, now, started).await?; + Ok((operation, snapshot)) } async fn acquire_read_approved( @@ -1973,8 +2004,10 @@ impl GatewayEngine { } /// Acquires and records independently approved recovery evidence. The read - /// operation comes from the native compiled effect, never an extra transport - /// parameter. A completed response remains distinct from source refinement. + /// operation comes from the native compiled effect or an exact historical + /// submission match, never an extra transport parameter. Expiry or withdrawal + /// prevents new entry, not retrieval of retained facts. A completed response + /// remains distinct from source refinement. /// /// # Errors /// Returns a native refusal or indeterminate state. No failure authorizes @@ -1986,22 +2019,10 @@ impl GatewayEngine { action: &[u8], approval: ExactEffectApproval, ) -> Result { - let started = Instant::now(); - let effect = self - .compile_recovery_effect(source_operation, proof, action) + let (operation, _) = self + .acquire_recovery_with_operation(source_operation, proof, action, approval) .await?; - let now = self - .qualification - .effect_time() - .ok_or_else(|| not_entered("gateway.verify.clock-unavailable"))?; - let approved = Arc::new( - effect - .approve(approval, self.effect_policy.approver(), now) - .map_err(|_| not_entered("gateway.effect.approval"))?, - ); - let operation = approved.effect().binding().journal_identity().1.to_owned(); - self.acquire_read_approved(approved, now, started).await?; - self.refine_recovery(source_operation, &operation) + self.refine_recovery(source_operation, operation.as_str()) .await .map_err(|code| GatewaySubmitResult::Indeterminate { code: code.to_owned(), @@ -2128,7 +2149,10 @@ impl GatewayEngine { .retained_submission(proof_cbor, action_cbor, &approval, RetainedRoute::Mutation) .await { - Ok(Some(crate::store::RetainedSubmission::Mutation(snapshot))) => Some(*snapshot), + Ok(Some(RetainedHistory { + submission: crate::store::RetainedSubmission::Mutation(snapshot), + .. + })) => Some(*snapshot), Ok(None) => None, Ok(Some(_)) => return not_entered("gateway.effect.operation-conflict"), Err(result) => return result, @@ -2175,7 +2199,7 @@ impl GatewayEngine { action: &[u8], approval: &ExactEffectApproval, route: RetainedRoute<'_>, - ) -> Result, GatewaySubmitResult> { + ) -> Result, GatewaySubmitResult> { if proof.is_empty() || proof.len() > MAX_PROOF_BYTES || action.is_empty() @@ -2227,6 +2251,12 @@ impl GatewayEngine { approval, ) .await + .map(|submission| { + submission.map(|submission| RetainedHistory { + operation, + submission, + }) + }) .map_err(|error| match error { crate::GatewayAttemptError::BindingConflict => { not_entered("gateway.effect.operation-conflict") @@ -2248,7 +2278,10 @@ impl GatewayEngine { .retained_submission(proof, action, approval, route) .await? { - Some(crate::store::RetainedSubmission::Acquisition(snapshot)) => Ok(Some(snapshot)), + Some(RetainedHistory { + submission: crate::store::RetainedSubmission::Acquisition(snapshot), + .. + }) => Ok(Some(snapshot)), None => Ok(None), Some(_) => Err(not_entered("gateway.effect.operation-conflict")), } @@ -2265,7 +2298,10 @@ impl GatewayEngine { .retained_submission(proof, action, approval, RetainedRoute::Disclosure(target)) .await? { - Some(crate::store::RetainedSubmission::Disclosure(snapshot)) => Ok(Some(snapshot)), + Some(RetainedHistory { + submission: crate::store::RetainedSubmission::Disclosure(snapshot), + .. + }) => Ok(Some(snapshot)), None => Ok(None), Some(_) => Err(not_entered("gateway.effect.operation-conflict")), } diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index c61e78d4e..17d938fcd 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -31,6 +31,8 @@ const RECOVERY: &str = "independent-reader"; const PEER_ENV: &str = "AUTHS_AP074_RECOVERY_ACTOR_PEER"; const TARGET: &str = "/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001"; +#[path = "native_recovery_history_tests.rs"] +mod history_tests; #[path = "native_recovery_limits_tests.rs"] mod limits_tests; @@ -192,6 +194,12 @@ struct Provider { stop: Arc, worker: Option>, read_response: Arc>>, + read_pause: Arc>>, +} + +struct ReadPause { + release: std::sync::mpsc::Receiver<()>, + waiting: Arc, } /// Fault data for the provider double only; the native transport is unchanged. @@ -247,6 +255,8 @@ impl Provider { let done = stop.clone(); let read_response = Arc::new(Mutex::new(None::)); let scripted = read_response.clone(); + let read_pause = Arc::new(Mutex::new(None::)); + let paused = read_pause.clone(); let worker = thread::spawn(move || { let mut state = Value::Null; while !done.load(Ordering::SeqCst) { @@ -273,6 +283,15 @@ impl Provider { assert_eq!(line, format!("GET {TARGET} HTTP/1.1")); assert!(body.is_empty()); assert!(!state.is_null(), "read follows actual write"); + if let Some(pause) = paused.lock().expect("pause").take() { + pause.waiting.store(true, Ordering::SeqCst); + let released = pause.release.recv_timeout( + crate::transport::MAX_TRANSPORT_DURATION + Duration::from_secs(15), + ); + pause.waiting.store(false, Ordering::SeqCst); + released.expect("native transport must time out before the fallback"); + continue; + } } let mut response = state.clone(); if !outcome.echo() { @@ -308,8 +327,19 @@ impl Provider { stop, worker: Some(worker), read_response, + read_pause, } } + + fn pause_next_read(&self) -> (std::sync::mpsc::Sender<()>, Arc) { + let (release, receive) = std::sync::mpsc::channel(); + let waiting = Arc::new(AtomicBool::new(false)); + *self.read_pause.lock().expect("pause") = Some(ReadPause { + release: receive, + waiting: Arc::clone(&waiting), + }); + (release, waiting) + } } impl Drop for Provider { fn drop(&mut self) { diff --git a/product/runtime/auths-gateway/src/native_recovery_authoring.rs b/product/runtime/auths-gateway/src/native_recovery_authoring.rs index 9650b9cd0..de3d704e5 100644 --- a/product/runtime/auths-gateway/src/native_recovery_authoring.rs +++ b/product/runtime/auths-gateway/src/native_recovery_authoring.rs @@ -12,17 +12,20 @@ pub(crate) fn recipe() -> CompiledRecipe { } pub(crate) fn trust(writer_present: bool) -> Vec { + trust_roots(if writer_present { + &[0x11, 0x12] + } else { + &[0x12] + }) +} + +pub(crate) fn trust_roots(seeds: &[u8]) -> Vec { let recipe = recipe(); let tools = [recipe.review().tool(), crate::effect::RECOVERY_READ_TOOL] .map(|tool| McpToolCall::new(recipe.review().service(), tool, Map::new()).expect("tool")); - let writer_root = signer(0x11); - let reader_root = signer(0x12); let observer = signer(h::OBSERVER_SEED); - let roots = if writer_present { - vec![&writer_root, &reader_root] - } else { - vec![&reader_root] - }; + let signers: Vec<_> = seeds.iter().map(|seed| signer(*seed)).collect(); + let roots: Vec<_> = signers.iter().collect(); let context = h::context_for_tools_with_roots(&roots, &observer.principal, NOW, &tools).expect("trust"); auths_codec::encode_verifier_context(&context).expect("context bytes") diff --git a/product/runtime/auths-gateway/src/native_recovery_history_tests.rs b/product/runtime/auths-gateway/src/native_recovery_history_tests.rs new file mode 100644 index 000000000..949e41cd4 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_recovery_history_tests.rs @@ -0,0 +1,489 @@ +//! Retained recovery after expiry/withdrawal, actual timeout, and store errors. +use super::*; +use crate::{ + AcquisitionStage, GatewayAttemptError, GatewayAttemptStore, GatewayAttempts, + GatewayFenceDecision, GatewayInsert, GatewayRecordEntry, RecoveryDisposition as D, +}; +use std::{sync::atomic::AtomicUsize, time::Instant}; + +#[derive(Clone, Copy, Eq, PartialEq)] +enum Fault { + None, + LoadUnavailable, + FenceUnavailable, + RefuseGrant, +} + +/// Controlled adapter-port errors. Healthy calls and every writer fence use the +/// maintained durable adapter; this is not a database-outage qualification. +struct FaultStore { + inner: Arc, + grant_key: GatewayAttemptKey, + fault: Mutex, + failures: AtomicUsize, +} +impl FaultStore { + fn mode(&self) -> Fault { + *self.fault.lock().expect("fault") + } + fn refuse(&self) -> Result { + self.failures.fetch_add(1, Ordering::SeqCst); + Err(GatewayAttemptError::Unavailable) + } +} +impl GatewayAttemptStore for FaultStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + self.inner.fenced_insert_all(entries, dependencies, decide) + } + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + self.inner.fenced_replace(keys, &mut |snapshots| { + if self.mode() == Fault::FenceUnavailable { + return self.refuse(); + } + let next = decide(snapshots)?; + if self.mode() == Fault::RefuseGrant + && keys.first() == Some(&(GatewayRecordKind::Attempt, self.grant_key)) + && serde_json::from_slice::(&next) + .expect("unchanged native decision") + .pointer("/state/facts/phase/stage") + .and_then(Value::as_str) + == Some("entry-granted") + { + return self.refuse(); + } + Ok(next) + }) + } + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.inner.insert_all(entries) + } + fn replace( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + self.inner.replace(kind, key, current, next) + } + fn load( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + if kind == GatewayRecordKind::Attempt && self.mode() == Fault::LoadUnavailable { + return self.refuse(); + } + self.inner.load(kind, key) + } + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.inner.sweep_expired(now, limit) + } + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.inner.attempt_keys(limit) + } +} + +#[derive(Clone, Copy)] +enum Scenario { + Linked, + Inconclusive, + Reserved, + Timeout, +} +impl Scenario { + const fn name(self) -> &'static str { + match self { + Self::Linked => "linked-response", + Self::Inconclusive => "inconclusive-response", + Self::Reserved => "pre-grant-reservation", + Self::Timeout => "elapsed-native-transport-timeout", + } + } + const fn stage(self) -> AcquisitionStage { + match self { + Self::Linked | Self::Inconclusive => AcquisitionStage::ResponseRecorded, + Self::Reserved => AcquisitionStage::Reserved, + Self::Timeout => AcquisitionStage::Unknown, + } + } +} + +struct SignedRead { + signed: crate::harness::authoring::ToolFixture, + approval: ExactEffectApproval, + keys: Vec<(GatewayRecordKind, GatewayAttemptKey)>, +} +fn signed_read( + engine: &GatewayEngine, + runtime: &tokio::runtime::Runtime, + operation: &str, +) -> SignedRead { + let call = runtime + .block_on(engine.recovery_authorization_call(SOURCE, operation)) + .expect("native closed call"); + let signed = author::signed(&call, true); + let effect = runtime + .block_on(engine.compile_recovery_effect(SOURCE, &signed.proof, &signed.action)) + .expect("native authority before withdrawal"); + let approval = author::approval(&effect, NOW + 1); + let policy = crate::effect::fixture_policy().expect("policy"); + let approved = effect + .approve(approval.clone(), policy.approver(), NOW + 1) + .expect("exact approval"); + let capacity = approved + .recovery_plan() + .expect("native plan") + .capacity() + .expect("capacity"); + let mut keys: Vec<_> = [SOURCE, operation] + .into_iter() + .map(|operation| { + ( + GatewayRecordKind::Attempt, + GatewayAttemptKey::for_operation( + &policy, + author::recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key"), + ) + }) + .collect(); + keys.extend((0..capacity.attempts).map(|slot| { + ( + GatewayRecordKind::EffectAllocation, + GatewayAttemptKey::from_bytes(crate::bounds::count_slot_key(&capacity.count_key, slot)), + ) + })); + SignedRead { + signed, + approval, + keys, + } +} +fn stored(store: &FaultStore, read: &SignedRead) -> Vec>> { + read.keys + .iter() + .map(|(kind, key)| store.inner.load(*kind, key).expect("retained row")) + .collect() +} +fn recover( + engine: &GatewayEngine, + runtime: &tokio::runtime::Runtime, + read: &SignedRead, +) -> Result { + runtime.block_on(Box::pin(engine.recover( + SOURCE, + &read.signed.proof, + &read.signed.action, + read.approval.clone(), + ))) +} + +fn unavailable_history( + engine: &GatewayEngine, + runtime: &tokio::runtime::Runtime, + store: &FaultStore, + read: &SignedRead, +) -> Value { + let retained = stored(store, read); + let witness = engine.execution_witness(); + let mut refusals = Vec::new(); + for (fault, code) in [ + (Fault::LoadUnavailable, "gateway.attempt.state-unavailable"), + (Fault::FenceUnavailable, "gateway.recovery.unavailable"), + ] { + let failures = store.failures.load(Ordering::SeqCst); + *store.fault.lock().expect("fault") = fault; + let refused = recover(engine, runtime, read).expect_err("no fabricated zero-usage report"); + assert_eq!( + refused, + GatewaySubmitResult::Indeterminate { + code: code.to_owned() + } + ); + assert_eq!(store.failures.load(Ordering::SeqCst), failures + 1); + *store.fault.lock().expect("fault") = Fault::None; + assert_eq!(stored(store, read), retained); + assert_eq!(engine.execution_witness(), witness); + refusals.push(json!(refused)); + } + json!(refusals) +} + +fn substitutions( + engine: &GatewayEngine, + runtime: &tokio::runtime::Runtime, + read: &SignedRead, + source_approval: ExactEffectApproval, +) { + let witness = engine.execution_witness(); + let mut proof = read.signed.proof.clone(); + proof[0] ^= 1; + assert!( + runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &proof, + &read.signed.action, + read.approval.clone() + ))) + .is_err() + ); + let mut action = read.signed.action.clone(); + action[0] ^= 1; + assert!( + runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &read.signed.proof, + &action, + read.approval.clone() + ))) + .is_err() + ); + assert!( + runtime + .block_on(Box::pin(engine.recover( + "unrelated-source", + &read.signed.proof, + &read.signed.action, + read.approval.clone() + ))) + .is_err() + ); + assert!( + runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &read.signed.proof, + &read.signed.action, + source_approval + ))) + .is_err() + ); + assert_eq!(engine.execution_witness(), witness); +} + +#[allow( + clippy::too_many_lines, + reason = "one native historical recovery schedule preserves source, read, allocation, expiry and withdrawal evidence" +)] +fn history(backend: Backend, scenario: Scenario) -> Value { + let case = Case::start( + backend, + if matches!(scenario, Scenario::Linked) { + Outcome::LostEcho + } else { + Outcome::LostState + }, + ); + let runtime = runtime(); + let faults = Arc::new(FaultStore { + inner: case.store.raw(), + grant_key: GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + author::recipe().namespace(), + &LogicalOperationId::parse(RECOVERY).expect("read operation"), + ) + .expect("read key"), + fault: Mutex::new(Fault::None), + failures: AtomicUsize::new(0), + }); + let attempts = GatewayAttempts::new( + faults.clone(), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("attempts"); + let reader_controls = controls(true); + let clock = Arc::clone(&reader_controls.clock); + let (engine, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "history-reader", + attempts.clone(), + reader_controls, + )); + engine + .activate_effect_configuration( + engine + .effect_configuration_revision() + .expect("operator revision"), + ) + .expect("withdraw writer root"); + let read = signed_read(&engine, &runtime, RECOVERY); + let fresh = signed_read(&engine, &runtime, "never-entered-reader"); + let pause = if matches!(scenario, Scenario::Timeout) { + Some(case.provider.pause_next_read()) + } else { + None + }; + if matches!(scenario, Scenario::Reserved) { + *faults.fault.lock().expect("fault") = Fault::RefuseGrant; + } + let started = Instant::now(); + let first = recover(&engine, &runtime, &read).expect("native recovery"); + let elapsed = started.elapsed(); + *faults.fault.lock().expect("fault") = Fault::None; + if let Some((release, waiting)) = pause { + assert!( + waiting.load(Ordering::SeqCst), + "provider still withholds every response byte when the native deadline fires" + ); + assert!( + elapsed + >= crate::transport::MAX_TRANSPORT_DURATION.saturating_sub(Duration::from_secs(1)) + ); + assert!(elapsed < crate::transport::MAX_TRANSPORT_DURATION + Duration::from_secs(10)); + release + .send(()) + .expect("release provider after real timeout"); + } + if matches!(scenario, Scenario::Reserved) { + assert_eq!(faults.failures.load(Ordering::SeqCst), 1); + } + assert_eq!(first.acquisition.stage, scenario.stage()); + assert_eq!(first.budget.retained_attempts, 1); + assert_eq!(first.budget.retained_response_bytes, 16_384); + let retained = stored(&faults, &read); + let witness = engine.execution_witness(); + let expected_requests = if matches!(scenario, Scenario::Reserved) { + 1 + } else { + 2 + }; + assert_eq!( + case.provider.requests.lock().expect("requests").len(), + expected_requests + ); + clock.set(NOW + 3_601); + let expired = + recover(&engine, &runtime, &read).expect("expired reader retains exact historical facts"); + assert_eq!(expired.acquisition, first.acquisition); + assert_eq!(expired.source, first.source); + assert_eq!(expired.budget, first.budget); + assert_eq!( + expired.acquisition_received_at, + first.acquisition_received_at + ); + assert_eq!( + expired.disposition, + match scenario { + Scenario::Linked => D::AlreadyRecorded, + Scenario::Inconclusive => D::EvidenceStale, + Scenario::Reserved | Scenario::Timeout => D::AcquisitionIncomplete, + } + ); + assert!( + recover(&engine, &runtime, &fresh).is_err(), + "expired input with no journal match cannot start a read" + ); + assert_eq!(stored(&faults, &read), retained); + assert_eq!(engine.execution_witness(), witness); + let mut withdrawn_controls = controls(true); + withdrawn_controls.trust = Some(author::trust_roots(&[0x13])); + let (withdrawn, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "reader-withdrawn", + attempts, + withdrawn_controls, + )); + withdrawn + .activate_effect_configuration( + withdrawn + .effect_configuration_revision() + .expect("operator revision"), + ) + .expect("withdraw reader root too"); + let after_withdrawal = + recover(&withdrawn, &runtime, &read).expect("withdrawal does not erase exact history"); + assert_eq!(after_withdrawal.source, first.source); + assert_eq!(after_withdrawal.acquisition, first.acquisition); + assert_eq!(after_withdrawal.budget, first.budget); + assert_eq!( + after_withdrawal.acquisition_received_at, + first.acquisition_received_at + ); + assert_eq!( + recover(&withdrawn, &runtime, &fresh) + .expect_err("untrusted reader cannot start a new read"), + GatewaySubmitResult::Denied { + code: "untrusted-root".to_owned() + } + ); + let (_, _, source_approval) = input(&case.setup.installation.root, SOURCE); + substitutions(&withdrawn, &runtime, &read, source_approval); + let unavailable = unavailable_history(&withdrawn, &runtime, &faults, &read); + assert_eq!(stored(&faults, &read), retained); + assert_eq!(withdrawn.execution_witness().credential_lease_calls, 0); + runtime + .block_on(withdrawn.disable_connection()) + .expect("disable connection after delivery"); + let disabled = recover(&withdrawn, &runtime, &read) + .expect("disabled connection preserves historical recovery"); + assert_eq!(disabled.report(), after_withdrawal.report()); + assert_eq!(stored(&faults, &read), retained); + assert_eq!(withdrawn.execution_witness().credential_lease_calls, 0); + assert_eq!( + case.provider.requests.lock().expect("requests").len(), + expected_requests + ); + assert_eq!( + signed_bytes(&case.setup.installation.root, SOURCE), + case.signed_source + ); + assert_fixed_source(&case.original, &record(&case.store, SOURCE)); + json!({"case": scenario.name(), "first":first.report(), "expired":expired.report(), + "withdrawn":after_withdrawal.report(), "unavailable_store":unavailable, + "original_attribution_and_charges_preserved":true, "receipt_time_never_refreshed":true, + "expired_and_withdrawn_new_read_refused":true, "altered_inputs_source_or_approval_refused":true, + "retained_rows_and_no_io_after_expiry_withdrawal_or_disable":true, + "elapsed_timeout_checked_against_native_deadline":matches!(scenario, Scenario::Timeout)}) +} + +fn matrix(backend: Backend) { + let cases: Vec<_> = [ + Scenario::Linked, + Scenario::Inconclusive, + Scenario::Reserved, + Scenario::Timeout, + ] + .into_iter() + .map(|scenario| history(backend, scenario)) + .collect(); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-recovery-history/1", "adapter":backend.label(), + "scope":"native signed proofs and exact approvals, real local HTTP including elapsed 15-second timeout, maintained durable adapters, operator root withdrawal and connection disable", + "assumptions":["trusted maintained host and fixed test clock", "public fixed fixture keys"], + "excluded":["database outage or filesystem-device failure qualification", "live provider and custody", "hostile OS and power failure"], + "store_error_scope":"controlled load error and error inside the actual adapter writer fence; no synthetic journal facts", "cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-recovery-history-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} +#[test] +fn native_file_recovery_history_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_recovery_history_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs b/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs index b7117ca6e..b3c535136 100644 --- a/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_limits_tests.rs @@ -64,6 +64,31 @@ fn script(index: u64) -> (&'static str, Option, D, E) { D::AcquisitionIncomplete, E::EvidenceIncomplete, ), + 6 => { + let mut body = br#"{"fields":{"DemoStatus":"Approved"}}"#.to_vec(); + body.resize(16_384, b' '); + ( + "response-byte-limit-accepted", + Some(response(200, &body)), + D::Inconclusive, + E::Inconclusive, + ) + } + 7 => ( + "empty-success-response", + Some(response(200, b"[]")), + D::ResponseUnusable, + E::EvidenceUnusable, + ), + 8 => ( + "duplicate-response-members", + Some(response( + 200, + br#"{"fields":{"DemoStatus":"Pending","DemoStatus":"Approved"}}"#, + )), + D::ResponseUnusable, + E::EvidenceUnusable, + ), _ => ( "state-equality-without-causation", None, @@ -172,6 +197,7 @@ fn matrix(backend: Backend) { ); assert_eq!(record(&case.store, &operation), retained_read); if index == 6 { + assert_eq!(result.acquisition.response_bytes, Some(16_384)); clock.set(NOW + 31); let at_limit = runtime .block_on(engine.refine_recovery(SOURCE, &operation)) diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index b81b07511..d4800ffe5 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "d9b45da9ef5aa30a6601a673c3243b473c01c50fda922d602b3d4fe7d59f8b4e"; + "7371aee21694d1783a11ce8fc8977b8db6c921df83ca6407cfb01012136525fd"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index d73a2807a..b25220583 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 422 +freeze_version = 423 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 422 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 165 +"auths.identity.protocol" = 166 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 422 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 162 +"auths.product.public-sdk-contract" = 163 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 28 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 422 +"auths.release.public-surface" = 423 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 856b3b38a..f70f146ce 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 422, + "freezeVersion": 423, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 165, + "version": 166, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "178e90e8862f5a43f8965a3a34163e7e0d4d836a8f3a8af9b913d488a9e24642" + "sha256": "713817d4ea3bd8bc14879c5bb6de774bb898d7d07aacacf9506018c8bc749510" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 162, + "version": 163, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "b4c84b6cc90dccc248ca6b302489414bcc98a55da4f3e72805834a9e9d9f32a3" + "sha256": "6c3ed223092a2d7835c6a9a6969c5f25b46700e605cb2ff7ca2d751a311e3dbe" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 422, + "version": 423, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "b7defade2ef034d0963625c6c4ef2a28e37e6c6a0bc494adffb0deaa986c8136" + "sha256": "56d3d7496df23701cb7fa8af2b1a9879f77136ec19d086f8030bc8c0321d8085" } ] } From bb68a372f094abbf55fc20e379409e26612b2e76 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 02:42:58 +0000 Subject: [PATCH 114/136] fix(gateway): harden admin frames and inventory managed interfaces --- .github/workflows/gateway-isolation.yml | 11 + .../gateway/admin-request-boundary.json | 594 ++++++ .../gateway/managed-cli-inventory.json | 1642 +++++++++++++++++ .../gateway/managed-interface-unix.json | 593 ++++++ compliance.toml | 4 + docs/plans/0074-implementation-status.md | 62 + ...ound-effects-and-recovery-state-machine.md | 9 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/admin.rs | 95 +- .../auths-gateway/src/admin_boundary_tests.rs | 151 ++ product/runtime/auths-gateway/src/app.rs | 56 +- .../auths-gateway/src/bin/auths-gateway.rs | 56 +- .../auths-gateway/src/semantic_closure.rs | 2 +- .../tests/content_interface_tests.rs | 528 ++++++ .../auths-gateway/tests/content_journey.rs | 42 +- .../tests/managed_interface_probe.py | 141 ++ release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 18 files changed, 3955 insertions(+), 55 deletions(-) create mode 100644 bindings/fixtures/gateway/admin-request-boundary.json create mode 100644 bindings/fixtures/gateway/managed-cli-inventory.json create mode 100644 bindings/fixtures/gateway/managed-interface-unix.json create mode 100644 product/runtime/auths-gateway/src/admin_boundary_tests.rs create mode 100644 product/runtime/auths-gateway/tests/content_interface_tests.rs create mode 100644 product/runtime/auths-gateway/tests/managed_interface_probe.py diff --git a/.github/workflows/gateway-isolation.yml b/.github/workflows/gateway-isolation.yml index 252326fd5..93cc3c5cd 100644 --- a/.github/workflows/gateway-isolation.yml +++ b/.github/workflows/gateway-isolation.yml @@ -28,3 +28,14 @@ jobs: compiler-cache: "false" - name: Probe actual app UID against gateway credential and admin socket run: cargo test --locked -p auths-gateway --test isolated_process -- --ignored --nocapture + - name: Exercise every managed application schema from a distinct unprivileged UID + env: + AUTHS_EVIDENCE_SOURCE_REVISION: ${{ github.event.pull_request.head.sha || github.sha }} + run: cargo test --locked -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --ignored --exact interface_tests::distinct_uid_managed_interface_evidence --nocapture + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + if: always() + with: + name: ap074-managed-interface-isolation-${{ github.run_id }}-${{ github.run_attempt }} + path: target/ap074-managed-interface-isolation.json + if-no-files-found: error + retention-days: 30 diff --git a/bindings/fixtures/gateway/admin-request-boundary.json b/bindings/fixtures/gateway/admin-request-boundary.json new file mode 100644 index 000000000..4201ce22d --- /dev/null +++ b/bindings/fixtures/gateway/admin-request-boundary.json @@ -0,0 +1,594 @@ +{ + "schema": "auths.admin-request-boundary/1", + "scope": "native closed decoder and enum-generated interface catalog; decoding grants no operator, provider or recovery authority", + "maximum_command_bytes": 4096, + "oversized_advertised_length_refused_before_body": true, + "application_schemas": [ + "auths.gateway-submit/2", + "auths.gateway-observe/3", + "auths.gateway-recover/1", + "auths.gateway-content/1", + "auths.gateway-disclose/1", + "auths.gateway-content-history/1", + "auths.gateway-disclosure-acknowledge/1" + ], + "operator_commands": [ + "disable", + "enable", + "revoke", + "rotate", + "rotate-prepare", + "rotate-commit", + "status", + "execution-witness", + "qualification-reload", + "recover", + "recovery-record" + ], + "cases": [ + { + "case": "disable:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\"}", + "accepted": true, + "refusal": null + }, + { + "case": "disable:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "disable:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "disable:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"command\":\"disable\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "disable:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "disable:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "disable:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"disable\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\"}", + "accepted": true, + "refusal": null + }, + { + "case": "enable:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\",\"command\":\"enable\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"enable\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "enable:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"enable\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\"}", + "accepted": true, + "refusal": null + }, + { + "case": "revoke:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\",\"command\":\"revoke\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"revoke\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "revoke:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"revoke\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\"}", + "accepted": true, + "refusal": null + }, + { + "case": "rotate:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\",\"command\":\"rotate\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"rotate\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\"}", + "accepted": true, + "refusal": null + }, + { + "case": "rotate-prepare:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\",\"command\":\"rotate-prepare\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-prepare\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-prepare:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"rotate-prepare\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\"}", + "accepted": true, + "refusal": null + }, + { + "case": "rotate-commit:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"command\":\"rotate-commit\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:duplicate-commitment-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:duplicate-commitment-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"commitment\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"rotate-commit\",\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "rotate-commit:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"rotate-commit\"},\"commitment\":\"0000000000000000000000000000000000000000000000000000000000000000\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\"}", + "accepted": true, + "refusal": null + }, + { + "case": "status:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\",\"command\":\"status\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "status:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"status\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\"}", + "accepted": true, + "refusal": null + }, + { + "case": "execution-witness:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\",\"command\":\"execution-witness\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"execution-witness\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "execution-witness:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"execution-witness\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\"}", + "accepted": true, + "refusal": null + }, + { + "case": "qualification-reload:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\",\"command\":\"qualification-reload\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"qualification-reload\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "qualification-reload:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"qualification-reload\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\"}", + "accepted": true, + "refusal": null + }, + { + "case": "recover:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"command\":\"recover\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:duplicate-source_operation-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"source_operation\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:duplicate-source_operation-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"source_operation\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recover:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"recover\"},\"source_operation\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\"}", + "accepted": true, + "refusal": null + }, + { + "case": "recovery-record:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"command\":\"recovery-record\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-source_operation-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"source_operation\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-source_operation-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"source_operation\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-acquisition_operation-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"acquisition_operation\":\"independent-read\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:duplicate-acquisition_operation-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"acquisition_operation\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recovery-record\",\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "recovery-record:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"recovery-record\"},\"source_operation\":\"original\",\"acquisition_operation\":\"independent-read\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "escaped-duplicate-schema", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"\\u0073chema\":\"auths.gateway-admin-request/2\",\"command\":\"status\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "duplicate-command-first-invalid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"unsupported\",\"command\":\"status\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "argument-for-other-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"disable\",\"commitment\":\"public\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "nested-source", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":{\"id\":\"original\"}}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "obsolete-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"reobserve\",\"operation_id\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "non-object", + "input": "[]", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "trailing-data", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\"} null", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "byte-limit", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\"} ", + "accepted": true, + "refusal": null + }, + { + "case": "byte-limit-plus-one", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"status\"} ", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/managed-cli-inventory.json b/bindings/fixtures/gateway/managed-cli-inventory.json new file mode 100644 index 000000000..6fa9ffb3d --- /dev/null +++ b/bindings/fixtures/gateway/managed-cli-inventory.json @@ -0,0 +1,1642 @@ +{ + "schema": "auths.managed-cli-inventory/1", + "scope": "all native Clap command and argument declarations; catalog data grants no authority; loopback-provider is test-only and excluded", + "application_schemas": [ + "auths.gateway-submit/2", + "auths.gateway-observe/3", + "auths.gateway-recover/1", + "auths.gateway-content/1", + "auths.gateway-disclose/1", + "auths.gateway-content-history/1", + "auths.gateway-disclosure-acknowledge/1" + ], + "operator_commands": [ + "disable", + "enable", + "revoke", + "rotate", + "rotate-prepare", + "rotate-commit", + "status", + "execution-witness", + "qualification-reload", + "recover", + "recovery-record" + ], + "cli": [ + { + "command": "app-recover", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "source_operation", + "long": "source-operation", + "required": true + } + ] + }, + { + "command": "audit", + "arguments": [ + { + "name": "allow_unverified_refusals", + "long": "allow-unverified-refusals", + "required": false + }, + { + "name": "bundle", + "long": "bundle", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "observer", + "long": "observer", + "required": true + }, + { + "name": "trusted_context_sha256", + "long": "trusted-context-sha256", + "required": true + } + ] + }, + { + "command": "bound-extension", + "arguments": [ + { + "name": "argument", + "long": "argument", + "required": true + }, + { + "name": "ceiling", + "long": "ceiling", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "max_count", + "long": "max-count", + "required": true + }, + { + "name": "partition", + "long": "partition", + "required": false + }, + { + "name": "scope", + "long": "scope", + "required": false + }, + { + "name": "sum_limit", + "long": "sum-limit", + "required": false + }, + { + "name": "window_seconds", + "long": "window-seconds", + "required": true + } + ] + }, + { + "command": "candidate-acquire", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "candidate", + "long": "candidate", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "candidate-publish", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "candidate", + "long": "candidate", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "candidate-stage-installation", + "arguments": [ + { + "name": "credential_stdin", + "long": "credential-stdin", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proposal_out", + "long": "proposal-out", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "candidate-stage-rotation", + "arguments": [ + { + "name": "credential_stdin", + "long": "credential-stdin", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proposal_out", + "long": "proposal-out", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "commissioning-init", + "arguments": [ + { + "name": "from", + "long": "from", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "protected_run", + "long": "protected-run", + "required": true + }, + { + "name": "resource_binding", + "long": "resource-binding", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "commissioning-submit", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "from", + "long": "from", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "protected_run", + "long": "protected-run", + "required": true + }, + { + "name": "resource_binding", + "long": "resource-binding", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "witness_file", + "long": "witness-file", + "required": false + } + ] + }, + { + "command": "content-acquire", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + } + ] + }, + { + "command": "content-history", + "arguments": [ + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation", + "long": "operation", + "required": true + } + ] + }, + { + "command": "credential-collect", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "disable", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "store_only", + "long": "store-only", + "required": false + } + ] + }, + { + "command": "disclosure-acknowledge", + "arguments": [ + { + "name": "acknowledgement", + "long": "acknowledgement", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation", + "long": "operation", + "required": true + } + ] + }, + { + "command": "disclosure-receive", + "arguments": [ + { + "name": "acknowledgement_out", + "long": "acknowledgement-out", + "required": true + }, + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "content_out", + "long": "content-out", + "required": true + }, + { + "name": "expected_binding", + "long": "expected-binding", + "required": true + }, + { + "name": "expected_bytes", + "long": "expected-bytes", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "recipient_seed_stdin", + "long": "recipient-seed-stdin", + "required": true + }, + { + "name": "target", + "long": "target", + "required": true + } + ] + }, + { + "command": "doctor", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "app_gid", + "long": "app-gid", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "app_uid", + "long": "app-uid", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "echo-verify", + "arguments": [ + { + "name": "action", + "long": "action", + "required": false + }, + { + "name": "bundle", + "long": "bundle", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "namespace", + "long": "namespace", + "required": false + }, + { + "name": "operation_id", + "long": "operation-id", + "required": true + }, + { + "name": "pointer", + "long": "pointer", + "required": true + }, + { + "name": "record", + "long": "record", + "required": true + } + ] + }, + { + "command": "effect-approval", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "request", + "long": "request", + "required": true + }, + { + "name": "signature_hex", + "long": "signature-hex", + "required": true + } + ] + }, + { + "command": "effect-candidate-call", + "arguments": [ + { + "name": "call_out", + "long": "call-out", + "required": true + }, + { + "name": "candidate", + "long": "candidate", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation", + "long": "operation", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "effect-configuration-activate", + "arguments": [ + { + "name": "expected_candidate", + "long": "expected-candidate", + "required": true + }, + { + "name": "expected_revision", + "long": "expected-revision", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "effect-configuration-review", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "effect-content-call", + "arguments": [ + { + "name": "call_out", + "long": "call-out", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation", + "long": "operation", + "required": true + }, + { + "name": "resource_arguments", + "long": "resource-arguments", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "effect-disclosure-call", + "arguments": [ + { + "name": "call_out", + "long": "call-out", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation", + "long": "operation", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "target", + "long": "target", + "required": true + } + ] + }, + { + "command": "effect-policy", + "arguments": [ + { + "name": "approver_public_key", + "long": "approver-public-key", + "required": true + }, + { + "name": "epoch", + "long": "epoch", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "partition", + "long": "partition", + "required": true + } + ] + }, + { + "command": "effect-recovery-call", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "recovery_operation", + "long": "recovery-operation", + "required": true + }, + { + "name": "source_operation", + "long": "source-operation", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "effect-review", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "binding_out", + "long": "binding-out", + "required": false + }, + { + "name": "candidate", + "long": "candidate", + "required": false + }, + { + "name": "content", + "long": "content", + "required": false + }, + { + "name": "disclosure", + "long": "disclosure", + "required": false + }, + { + "name": "expires_at", + "long": "expires-at", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "not_before", + "long": "not-before", + "required": true + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "recovery_of", + "long": "recovery-of", + "required": false + }, + { + "name": "request_out", + "long": "request-out", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "enable", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "execution-witness", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "help", + "arguments": [] + }, + { + "command": "install", + "arguments": [ + { + "name": "account_label", + "long": "account-label", + "required": false + }, + { + "name": "alias", + "long": "alias", + "required": true + }, + { + "name": "approve_digest", + "long": "approve-digest", + "required": true + }, + { + "name": "attempt_store", + "long": "attempt-store", + "required": false + }, + { + "name": "aws_identity", + "long": "aws-identity", + "required": false + }, + { + "name": "aws_kms_key", + "long": "aws-kms-key", + "required": false + }, + { + "name": "aws_region", + "long": "aws-region", + "required": false + }, + { + "name": "credential_header", + "long": "credential-header", + "required": false + }, + { + "name": "credential_namespace", + "long": "credential-namespace", + "required": false + }, + { + "name": "credential_stdin", + "long": "credential-stdin", + "required": false + }, + { + "name": "credential_store", + "long": "credential-store", + "required": false + }, + { + "name": "deployment", + "long": "deployment", + "required": false + }, + { + "name": "effect_policy", + "long": "effect-policy", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "join", + "long": "join", + "required": false + }, + { + "name": "operator_attestation", + "long": "operator-attestation", + "required": false + }, + { + "name": "profile_lock", + "long": "profile-lock", + "required": true + }, + { + "name": "provider", + "long": "provider", + "required": true + }, + { + "name": "provider_contract_id", + "long": "provider-contract-id", + "required": false + }, + { + "name": "qualification_policy", + "long": "qualification-policy", + "required": false + }, + { + "name": "qualification_trust_root", + "long": "qualification-trust-root", + "required": false + }, + { + "name": "recipe", + "long": "recipe", + "required": true + }, + { + "name": "recipe_family", + "long": "recipe-family", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "trusted_context", + "long": "trusted-context", + "required": true + } + ] + }, + { + "command": "observe", + "arguments": [ + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "outcome", + "long": "outcome", + "required": false + }, + { + "name": "pre_entry", + "long": "pre-entry", + "required": false + } + ] + }, + { + "command": "observer-init", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "observer-show", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "operator-attest", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operator_attestation", + "long": "operator-attestation", + "required": true + }, + { + "name": "replace", + "long": "replace", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "operator-request", + "arguments": [ + { + "name": "alias", + "long": "alias", + "required": true + }, + { + "name": "deployment", + "long": "deployment", + "required": true + }, + { + "name": "effect_policy", + "long": "effect-policy", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operator_principal", + "long": "operator-principal", + "required": true + }, + { + "name": "principal_method", + "long": "principal-method", + "required": true + }, + { + "name": "profile_lock", + "long": "profile-lock", + "required": true + }, + { + "name": "provider", + "long": "provider", + "required": true + }, + { + "name": "recipe", + "long": "recipe", + "required": true + }, + { + "name": "signature_suite", + "long": "signature-suite", + "required": true + }, + { + "name": "trusted_context", + "long": "trusted-context", + "required": true + }, + { + "name": "verification_method", + "long": "verification-method", + "required": true + } + ] + }, + { + "command": "probe", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "qualification-candidate", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "profile_lock", + "long": "profile-lock", + "required": true + }, + { + "name": "provider_contract_id", + "long": "provider-contract-id", + "required": true + }, + { + "name": "recipe", + "long": "recipe", + "required": true + }, + { + "name": "recipe_family", + "long": "recipe-family", + "required": true + } + ] + }, + { + "command": "qualification-import", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "from", + "long": "from", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "qualification-status", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "tuple", + "long": "tuple", + "required": false + } + ] + }, + { + "command": "readiness-probe", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "recover", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "source_operation", + "long": "source-operation", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "recovery-record", + "arguments": [ + { + "name": "acquisition_operation", + "long": "acquisition-operation", + "required": true + }, + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "source_operation", + "long": "source-operation", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "review", + "arguments": [ + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "profile_lock", + "long": "profile-lock", + "required": true + }, + { + "name": "recipe", + "long": "recipe", + "required": true + } + ] + }, + { + "command": "review-submission", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "evaluated_at", + "long": "evaluated-at", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "profile_lock", + "long": "profile-lock", + "required": true + }, + { + "name": "proof", + "long": "proof", + "required": true + }, + { + "name": "recipe", + "long": "recipe", + "required": true + }, + { + "name": "trusted_context", + "long": "trusted-context", + "required": true + } + ] + }, + { + "command": "revoke", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + }, + { + "name": "store_only", + "long": "store-only", + "required": false + } + ] + }, + { + "command": "rotate", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "credential_stdin", + "long": "credential-stdin", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operator_process", + "long": "operator-process", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "rotate-commit", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "commitment", + "long": "commitment", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operator_process", + "long": "operator-process", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "rotate-prepare", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "credential_stdin", + "long": "credential-stdin", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operator_process", + "long": "operator-process", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "serve", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "app_capacity", + "long": "app-capacity", + "required": false + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "status", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, + { + "command": "submit", + "arguments": [ + { + "name": "action", + "long": "action", + "required": true + }, + { + "name": "app_socket", + "long": "app-socket", + "required": true + }, + { + "name": "approval", + "long": "approval", + "required": true + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "proof", + "long": "proof", + "required": true + } + ] + }, + { + "command": "support-bundle", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "out", + "long": "out", + "required": false + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/managed-interface-unix.json b/bindings/fixtures/gateway/managed-interface-unix.json new file mode 100644 index 000000000..9a0e50017 --- /dev/null +++ b/bindings/fixtures/gateway/managed-interface-unix.json @@ -0,0 +1,593 @@ +{ + "schema": "auths.managed-interface-probe/1", + "distinct_uid": false, + "scope": "real native daemon, fresh runtime credential, actual local HTTP, all native application schemas, all operator commands injected on the application channel and every CLI help entry", + "excluded": [ + "hostile OS or root", + "provider or production custody qualification", + "all privileged CLI execution paths", + "positive signed mutation outcome privacy" + ], + "first": { + "distinct_uid": false, + "cases": [ + { + "case": "submit-with-read-authority", + "response": { + "outcome": "not-entered", + "code": "gateway.recipe.action-mismatch" + }, + "post_ready_control_frames": 0 + }, + { + "case": "content-replay", + "response": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 32, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 32 + } + } + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "content-history", + "response": { + "outcome": "history", + "history": { + "kind": "acquisition", + "snapshot": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 32, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 32 + } + } + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "disclose-without-recipient-authentication", + "response": { + "outcome": "ready" + }, + "post_ready_control_frames": 1 + }, + { + "case": "recover-with-acquisition-source", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.recovery.not-observable" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "observe-outcome", + "response": { + "outcome": "refused", + "code": "gateway.observer.not-provisioned" + }, + "post_ready_control_frames": 0 + }, + { + "case": "observe-pre-entry", + "response": { + "outcome": "refused", + "code": "gateway.observer.store-unavailable" + }, + "post_ready_control_frames": 0 + }, + { + "case": "forged-ack", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.disclosure.acknowledgement" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:disable", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:enable", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:revoke", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:rotate", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:rotate-prepare", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:rotate-commit", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:status", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:execution-witness", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:qualification-reload", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:recover", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "admin-on-app:recovery-record", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "auths.gateway-submit/1", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "auths.gateway-observe/2", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "auths.gateway-recover/0", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "auths.gateway-content/0", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "auths.gateway-disclose/0", + "response": { + "outcome": "refused", + "result": { + "outcome": "not-entered", + "code": "gateway.submit.invalid-frame" + } + }, + "post_ready_control_frames": 0 + }, + { + "case": "reobserve", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "raw-http", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "credential-export", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "retry", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "refund", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "resolve-as-not-entered", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "oversized-advertised-frame", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, + { + "case": "http-on-app-socket", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + } + ], + "admin_commands_closed": [], + "cli": [ + { + "command": "app-recover", + "help_accessible": true + }, + { + "command": "audit", + "help_accessible": true + }, + { + "command": "bound-extension", + "help_accessible": true + }, + { + "command": "candidate-acquire", + "help_accessible": true + }, + { + "command": "candidate-publish", + "help_accessible": true + }, + { + "command": "candidate-stage-installation", + "help_accessible": true + }, + { + "command": "candidate-stage-rotation", + "help_accessible": true + }, + { + "command": "commissioning-init", + "help_accessible": true + }, + { + "command": "commissioning-submit", + "help_accessible": true + }, + { + "command": "content-acquire", + "help_accessible": true + }, + { + "command": "content-history", + "help_accessible": true + }, + { + "command": "credential-collect", + "help_accessible": true + }, + { + "command": "disable", + "help_accessible": true + }, + { + "command": "disclosure-acknowledge", + "help_accessible": true + }, + { + "command": "disclosure-receive", + "help_accessible": true + }, + { + "command": "doctor", + "help_accessible": true + }, + { + "command": "echo-verify", + "help_accessible": true + }, + { + "command": "effect-approval", + "help_accessible": true + }, + { + "command": "effect-candidate-call", + "help_accessible": true + }, + { + "command": "effect-configuration-activate", + "help_accessible": true + }, + { + "command": "effect-configuration-review", + "help_accessible": true + }, + { + "command": "effect-content-call", + "help_accessible": true + }, + { + "command": "effect-disclosure-call", + "help_accessible": true + }, + { + "command": "effect-policy", + "help_accessible": true + }, + { + "command": "effect-recovery-call", + "help_accessible": true + }, + { + "command": "effect-review", + "help_accessible": true + }, + { + "command": "enable", + "help_accessible": true + }, + { + "command": "execution-witness", + "help_accessible": true + }, + { + "command": "help", + "help_accessible": true + }, + { + "command": "install", + "help_accessible": true + }, + { + "command": "observe", + "help_accessible": true + }, + { + "command": "observer-init", + "help_accessible": true + }, + { + "command": "observer-show", + "help_accessible": true + }, + { + "command": "operator-attest", + "help_accessible": true + }, + { + "command": "operator-request", + "help_accessible": true + }, + { + "command": "probe", + "help_accessible": true + }, + { + "command": "qualification-candidate", + "help_accessible": true + }, + { + "command": "qualification-import", + "help_accessible": true + }, + { + "command": "qualification-status", + "help_accessible": true + }, + { + "command": "readiness-probe", + "help_accessible": true + }, + { + "command": "recover", + "help_accessible": true + }, + { + "command": "recovery-record", + "help_accessible": true + }, + { + "command": "review", + "help_accessible": true + }, + { + "command": "review-submission", + "help_accessible": true + }, + { + "command": "revoke", + "help_accessible": true + }, + { + "command": "rotate", + "help_accessible": true + }, + { + "command": "rotate-commit", + "help_accessible": true + }, + { + "command": "rotate-prepare", + "help_accessible": true + }, + { + "command": "serve", + "help_accessible": true + }, + { + "command": "status", + "help_accessible": true + }, + { + "command": "submit", + "help_accessible": true + }, + { + "command": "support-bundle", + "help_accessible": true + } + ], + "private_cli": [], + "direct_provider": [ + { + "credential": "absent", + "status": 401 + }, + { + "credential": "public-fixture-guess", + "status": 401 + } + ], + "private_files_inaccessible": null + }, + "replay": { + "distinct_uid": false, + "cases": [ + { + "case": "disclosure-replay-after-owner-ack", + "response": { + "outcome": "history", + "history": { + "kind": "disclosure", + "snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 32, + "policy_count_counters": 0, + "policy_byte_counters": 0 + } + } + }, + "post_ready_control_frames": 0 + } + ], + "admin_commands_closed": [], + "cli": [], + "private_cli": [], + "direct_provider": [ + { + "credential": "absent", + "status": 401 + }, + { + "credential": "public-fixture-guess", + "status": 401 + } + ], + "private_files_inaccessible": null + }, + "private_source_journal_unchanged": true, + "provider_authorized_calls": 1, + "direct_provider_refusals": 4, + "no_new_custody_or_provider_entries": true, + "recipient_key_and_uid_guard_precede_content": true, + "trusted_recipient_positive_control": true, + "public_channels_exclude_plaintext_encodings_and_raw_digests": true +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index c8cb6fd5e..7ca67ae29 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1829,6 +1829,10 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#postgres_native_recovery_limits_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#native_file_recovery_history_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#postgres_native_recovery_history_fixture_is_current", + "product/runtime/auths-gateway/src/admin_boundary_tests.rs#admin_request_boundary_fixture_is_current", + "product/runtime/auths-gateway/src/bin/auths-gateway.rs#managed_cli_inventory_fixture_is_current", + "product/runtime/auths-gateway/tests/content_interface_tests.rs#native_managed_interface_fixture_is_current", + "product/runtime/auths-gateway/tests/content_interface_tests.rs#distinct_uid_managed_interface_evidence", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#native_file_mutation_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 58ef9d7aa..63896f2ea 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3600,3 +3600,65 @@ or deployment claim is made by AP074 source work. 423 updates identity 166, public SDK 163 and public surface 423, the only changed subjects reported by the generator. The runtime orchestration change adds no reducer transition, permit constructor or accounting authority. + +## Bounded admin decoder and managed interface checkpoint + +- Fixed native admin decoding that first collected JSON into a map and thereby + accepted last-key-wins duplicates. A bounded visitor now rejects duplicate + schema, command and argument members, including escaped aliases, unknown + members and non-string values. The existing command enum still owns valid + argument combinations and every refusal keeps `gateway.admin.invalid-frame`. + `MAX_ADMIN_REQUEST_BYTES` is 4,096. The admin socket checks the advertised + first-frame length before reading/allocating its body; separately bounded + secret/native-submission second frames retain their current protocol. +- The native application enum and admin enum now generate their own catalogs, + with seven application schemas and eleven operator commands. One native + Clap metadata constructor inventories every command and argument, including + generated help (52 entries). Catalogs grant no authority and add no dispatcher. + A new native boundary corpus checks every operator command, identical/changed + duplicate members, escaped duplicates, unknown/nested members, trailing data, + 4,096 accepted / 4,097 refused and an oversized advertised length with no body. +- New actual installed-daemon Unix constructor uses a fresh random credential, + real counting HTTP and retained private content. Its untrusted client exercises + all seven application schemas in 32 frame cases, all eleven operator commands + injected on the app channel, obsolete schemas/routes, raw HTTP and oversized + advertised frames. It reaches help for all 52 CLI entries. There is one + authorized acquisition only; four direct provider attempts without the fresh + credential return 401. Native custody/read/write counters do not advance. +- Disclosure with actual signed authority/approval but no recipient authentication + stays reserved without content. The trusted native recipient then authenticates, + receives exact bytes and records its ACK. A later hostile replay gets history + without redelivery or new source I/O/charges. The source journal remains + byte-identical. Captured public results, CLI errors, daemon logs, post-ready + frames and decoded base64 fields are checked for content/credential plaintext, + hex/base64 encodings and raw/encoded SHA-256 digests. Ordinary provider fixtures + still require the exact credential; intentional unauthorized HTTP is enabled + only for this fresh-credential fixture and never mutates provider state. +- Linux-only distinct-UID execution is authored in the existing isolation workflow, + preserving its two existing deployment tests. It drops capabilities/groups and + privileges, retains only the gateway's primary group for app-socket access, + probes every private fixture file, recipient outputs and gateway process + environ/memory, and verifies it cannot acquire the gateway UID or chmod state. + It intentionally makes the relocated admin inode traversable/writable to + exercise the accept-time UID gate for every operator command. Four privileged + CLI examples are refused. The workflow publishes an exact-source actual report. + This Linux execution is pending hosted evidence; the local Unix run uses the + same UID and does not claim OS containment. CLI help coverage is not a claim + that all privileged CLI execution paths were exercised. +- Required artifact construction passed: native admin boundary 1 passed / + 0 ignored (0.01 s), native CLI inventory 1 passed / 0 ignored (0.01 s), + managed Unix interface constructor 1 passed / 0 ignored (2.31 s). The original + complete CLI/daemon content journey passed unchanged (2.86 s). The generated + help entry is included in the final count; the earlier unbuilt catalog had 51. +- A17 remains open: positive configured signed mutation observations and legacy + public mutation evidence still require the raw body-derived commitment audit + and projection hardening. Private audit/evidence binding must be preserved. + No exit criterion was relaxed, no AP070/AP073 file was touched, and the main + agent did not inspect CI. Broader A18 binding parity, A20 formal/concurrent + evidence, A21 rollback schedules and final exact-head gates remain required. +- Final gateway semantic closure is + `87d516a91c79770a0db7ce4e066e304b2358274bc5af99248ce21b1abef48efb`; + the exact constructor and rebuilt non-update check passed. Semantic freeze + 424 updates identity 167, public SDK 164 and public surface 424, the only + changed subjects required by the generator. No complete acceptance row or + new hosted/Linux result is claimed from these construction checks. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 6e4d39f7b..f93af4db2 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -1169,6 +1169,15 @@ Cover: effect metadata; payload/proof/context bytes; header/path sizes; resource Errors distinguish malformed/noncanonical input, unsupported schema/protocol, unauthorized effect, expired/stale evidence, changed binding, replay, conflicting operation, exhausted capacity, invalid transition, unavailable/corrupt store and unresolved outcome. Map them consistently across Rust and bindings without exposing proof bodies, provider content or credentials. Preserve existing codes where semantics are unchanged; version intentional changes. +Operator command objects use `MAX_ADMIN_REQUEST_BYTES = 4,096`, enforced on the +advertised frame length before allocation and again before decoding. Native proof, +approval and rotation-secret second frames keep their separate existing limits. +Operator control members must be unique string fields; escaped aliases, duplicate +schema/command/argument members and arguments for another command are invalid. +The command enum and application-frame enum each generate their own native +interface catalog. The CLI inventory is generated from the built Clap command +metadata, including generated help, rather than a second runtime dispatcher. + ## 9. Required invariants | ID | Invariant | diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 8d09a1496..8a3cda777 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"810b0cb3b6575d23f98c5fd46a9bd8d16de5fab07282cb1088483463c6d20319"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"fd5a2cc879ca11645a3cb0b279186b7dbed40d9cafd03f2cca5b1013c3fa631f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"0672c33876608de4d3deda3598d06b2ff234abcd280f4a7aa72ed73e3b522035"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"00fe8b9cbabfee5e18333dc2012d669b7456c20fee59d4914a8ccb4e73526606"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"606f6ffe0bcea6ae7dc81f420938fc65943fb1a44b5e5e67b0e9a31493cb833a"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"36eac58922ab82bd2700f401ece251c234ee825077e61544840e86cbceee0613"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"00fe8b9cbabfee5e18333dc2012d669b7456c20fee59d4914a8ccb4e73526606"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"606f6ffe0bcea6ae7dc81f420938fc65943fb1a44b5e5e67b0e9a31493cb833a"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/admin.rs b/product/runtime/auths-gateway/src/admin.rs index cbffa4efb..753bf2673 100644 --- a/product/runtime/auths-gateway/src/admin.rs +++ b/product/runtime/auths-gateway/src/admin.rs @@ -4,48 +4,71 @@ use serde::Deserialize; +#[cfg(all(test, unix))] +#[path = "admin_boundary_tests.rs"] +mod boundary_tests; + /// Schema of an admin request frame. pub const ADMIN_REQUEST_SCHEMA: &str = "auths.gateway-admin-request/2"; /// Schema of an admin response frame. pub const ADMIN_RESPONSE_SCHEMA: &str = "auths.gateway-admin-response/2"; -/// One admin command and its arguments. -#[derive(Clone, Debug, Deserialize, Eq, PartialEq)] -#[serde(tag = "command", rename_all = "kebab-case", deny_unknown_fields)] -pub enum AdminRequestCommand { +/// Largest operator command object; secrets and native submissions use their +/// own second frames. Five bounded string fields need substantially less space. +pub const MAX_ADMIN_REQUEST_BYTES: usize = 4096; + +macro_rules! admin_commands { + ($( $(#[$variant_doc:meta])* $variant:ident($name:literal) { + $( $(#[$field_doc:meta])* $field:ident: $field_type:ty ),* $(,)? + } ),* $(,)?) => { + /// One closed operator command and its arguments. + #[derive(Clone, Debug, Deserialize, Eq, PartialEq)] + #[serde(tag = "command", deny_unknown_fields)] + pub enum AdminRequestCommand { + $( $(#[$variant_doc])* #[serde(rename = $name)] $variant { + $( $(#[$field_doc])* $field: $field_type ),* + } ),* + } + /// Complete operator command catalog, generated with the native enum. + pub const ADMIN_REQUEST_COMMANDS: &[&str] = &[$($name),*]; + const ARGUMENT_NAMES: &[&str] = &[$($(stringify!($field),)*)*]; + }; +} + +admin_commands! { // Struct variants, so an argument the command does not take is // refused: an internally tagged unit variant ignores extra members. /// Stop new entries in every process sharing the store. - Disable {}, + Disable("disable") {}, /// Re-enable a disabled connection. - Enable {}, + Enable("enable") {}, /// Revoke the connection permanently. - Revoke {}, + Revoke("revoke") {}, /// Rotate the credential; the secret follows in a second frame. - Rotate {}, + Rotate("rotate") {}, /// Store a successor credential without publishing it; the secret /// follows in a second frame. Answers with its reference commitment. - RotatePrepare {}, + RotatePrepare("rotate-prepare") {}, /// Publish the prepared successor the commitment names. - RotateCommit { + RotateCommit("rotate-commit") { /// The reference commitment `rotate-prepare` answered with, as 64 /// lowercase hexadecimal characters. commitment: String, }, /// Report connection state. - Status {}, + Status("status") {}, /// Read process-local custody and transport measurements; grants no authority. - ExecutionWitness {}, + ExecutionWitness("execution-witness") {}, /// Read the qualification inputs the operator placed on this host again /// and report the resulting state. - QualificationReload {}, + QualificationReload("qualification-reload") {}, /// Acquire/refine one recovery read; a native submission follows in frame 2. - Recover { + Recover("recover") { /// Retained source mutation whose contract the read must bind. source_operation: String, }, /// Record evidence from an existing acquisition without provider/custody I/O. - RecoveryRecord { + RecoveryRecord("recovery-record") { /// Retained source mutation. source_operation: String, /// Separately authorized read whose response is already retained. @@ -53,15 +76,51 @@ pub enum AdminRequestCommand { }, } +struct AdminFields(serde_json::Map); + +impl<'de> Deserialize<'de> for AdminFields { + fn deserialize>(deserializer: D) -> Result { + struct Fields; + impl<'de> serde::de::Visitor<'de> for Fields { + type Value = AdminFields; + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("unique operator command string fields") + } + fn visit_map>( + self, + mut map: M, + ) -> Result { + let mut fields = serde_json::Map::new(); + while let Some(key) = map.next_key::()? { + if fields.contains_key(&key) + || (key != "schema" + && key != "command" + && !ARGUMENT_NAMES.contains(&key.as_str())) + { + return Err(serde::de::Error::custom("invalid operator command field")); + } + let value = map.next_value::()?; + fields.insert(key, serde_json::Value::String(value)); + } + Ok(AdminFields(fields)) + } + } + deserializer.deserialize_map(Fields) + } +} + /// Parses one `auths.gateway-admin-request/2` frame. /// /// # Errors /// Returns `gateway.admin.invalid-frame` for anything but a JSON object with -/// exactly the schema, a known command, and that command's arguments. +/// exactly the schema, a known command, and that command's arguments. Duplicate +/// members, non-string values and objects over `MAX_ADMIN_REQUEST_BYTES` are refused. pub fn parse_admin_request(bytes: &[u8]) -> Result { let invalid = "gateway.admin.invalid-frame"; - let mut request: serde_json::Map = - serde_json::from_slice(bytes).map_err(|_| invalid)?; + if bytes.len() > MAX_ADMIN_REQUEST_BYTES { + return Err(invalid); + } + let AdminFields(mut request) = serde_json::from_slice(bytes).map_err(|_| invalid)?; if request.remove("schema") != Some(serde_json::Value::String(ADMIN_REQUEST_SCHEMA.into())) { return Err(invalid); } diff --git a/product/runtime/auths-gateway/src/admin_boundary_tests.rs b/product/runtime/auths-gateway/src/admin_boundary_tests.rs new file mode 100644 index 000000000..1a9523de0 --- /dev/null +++ b/product/runtime/auths-gateway/src/admin_boundary_tests.rs @@ -0,0 +1,151 @@ +//! Native operator frame boundary and generated interface catalog artifact. +use super::*; +use serde_json::{Value, json}; +use std::{collections::BTreeSet, path::PathBuf}; + +fn request(command: &str) -> Value { + let mut value = json!({"schema":ADMIN_REQUEST_SCHEMA,"command":command}); + match command { + "disable" + | "enable" + | "revoke" + | "rotate" + | "rotate-prepare" + | "status" + | "execution-witness" + | "qualification-reload" => {} + "rotate-commit" => value["commitment"] = json!("00".repeat(32)), + "recover" => value["source_operation"] = json!("original"), + "recovery-record" => { + value["source_operation"] = json!("original"); + value["acquisition_operation"] = json!("independent-read"); + } + _ => panic!("new native command requires a boundary example"), + } + value +} + +fn record(cases: &mut Vec, name: String, bytes: Vec, accepted: bool) { + let result = parse_admin_request(&bytes); + assert_eq!(result.is_ok(), accepted, "{name}"); + if !accepted { + assert_eq!(result, Err("gateway.admin.invalid-frame")); + } + cases.push(json!({"case":name,"input":String::from_utf8(bytes).expect("JSON fixture"), + "accepted":accepted,"refusal":if accepted {None} else {Some("gateway.admin.invalid-frame")}})); +} + +#[test] +#[allow( + clippy::too_many_lines, + reason = "one finite native parser corpus constructs its boundary artifact" +)] +fn admin_request_boundary_fixture_is_current() { + let commands: BTreeSet<_> = ADMIN_REQUEST_COMMANDS.iter().copied().collect(); + assert_eq!(commands.len(), ADMIN_REQUEST_COMMANDS.len()); + let mut cases = Vec::new(); + for command in ADMIN_REQUEST_COMMANDS { + let value = request(command); + record( + &mut cases, + format!("{command}:valid"), + serde_json::to_vec(&value).expect("JSON"), + true, + ); + for (key, field) in value.as_object().expect("request") { + for replacement in [field.clone(), json!("altered-public-fixture")] { + let mut bytes = serde_json::to_vec(&value).expect("JSON"); + bytes.pop(); + bytes.extend_from_slice( + format!( + ",{}:{replacement}}}", + serde_json::to_string(key).expect("key") + ) + .as_bytes(), + ); + record( + &mut cases, + format!( + "{command}:duplicate-{key}-{}", + if &replacement == field { + "same" + } else { + "different" + } + ), + bytes, + false, + ); + } + } + let mut unknown = value.clone(); + unknown["administrative_resolution"] = json!("not-entered-and-refunded"); + record( + &mut cases, + format!("{command}:unknown-argument"), + serde_json::to_vec(&unknown).expect("JSON"), + false, + ); + let mut wrong_type = value; + wrong_type["command"] = json!({"name":command}); + record( + &mut cases, + format!("{command}:non-string-command"), + serde_json::to_vec(&wrong_type).expect("JSON"), + false, + ); + } + for (name, bytes) in [ + ("escaped-duplicate-schema", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","\u0073chema":"{ADMIN_REQUEST_SCHEMA}","command":"status"}}"#).into_bytes()), + ("duplicate-command-first-invalid", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"unsupported","command":"status"}}"#).into_bytes()), + ("argument-for-other-command", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"disable","commitment":"public"}}"#).into_bytes()), + ("nested-source", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"recover","source_operation":{{"id":"original"}}}}"#).into_bytes()), + ("obsolete-command", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"reobserve","operation_id":"original"}}"#).into_bytes()), + ("non-object", b"[]".to_vec()), + ("trailing-data", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"status"}} null"#).into_bytes()), + ] { + record(&mut cases, name.to_owned(), bytes, false); + } + let mut boundary = serde_json::to_vec(&request("status")).expect("JSON"); + boundary.resize(MAX_ADMIN_REQUEST_BYTES, b' '); + record(&mut cases, "byte-limit".to_owned(), boundary.clone(), true); + boundary.push(b' '); + record( + &mut cases, + "byte-limit-plus-one".to_owned(), + boundary, + false, + ); + tokio::runtime::Runtime::new() + .expect("runtime") + .block_on(async { + use tokio::io::AsyncWriteExt as _; + let (mut sender, mut receiver) = tokio::net::UnixStream::pair().expect("socket pair"); + sender + .write_all( + &u32::try_from(MAX_ADMIN_REQUEST_BYTES + 1) + .expect("length") + .to_be_bytes(), + ) + .await + .expect("advertise length without a body"); + let clock = crate::app::SessionClock::start(crate::app::APP_SESSION_LIMITS); + let result = tokio::time::timeout( + std::time::Duration::from_secs(2), + clock.read_frame_limited(&mut receiver, MAX_ADMIN_REQUEST_BYTES), + ) + .await + .expect("must refuse length before waiting for body bytes"); + assert_eq!(result, Err("gateway.ipc.invalid-size")); + }); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.admin-request-boundary/1", + "scope":"native closed decoder and enum-generated interface catalog; decoding grants no operator, provider or recovery authority", + "maximum_command_bytes":MAX_ADMIN_REQUEST_BYTES,"oversized_advertised_length_refused_before_body":true,"application_schemas":crate::app::APPLICATION_REQUEST_SCHEMAS, + "operator_commands":ADMIN_REQUEST_COMMANDS,"cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/admin-request-boundary.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("artifact"), artifact); +} diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index a59f70440..8c82605ea 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -87,10 +87,26 @@ impl SessionClock { /// Returns [`read_frame`]'s codes, or `gateway.ipc.read-timeout` when a /// deadline passes first. pub async fn read_frame(&self, stream: &mut UnixStream) -> Result, &'static str> { + self.read_frame_limited(stream, MAX_FRAME_BYTES).await + } + + /// Reads a frame under a tighter protocol limit, clamped to the global + /// frame bound. An oversized advertised length is refused before allocation. + /// + /// # Errors + /// Returns the bounded frame/read/deadline failures of [`Self::read_frame`]. + pub async fn read_frame_limited( + &self, + stream: &mut UnixStream, + maximum: usize, + ) -> Result, &'static str> { let until = self.deadline.min(Instant::now() + self.limits.frame_read); - timeout_at(until, read_frame(stream)) - .await - .unwrap_or(Err("gateway.ipc.read-timeout")) + timeout_at( + until, + read_frame_limited(stream, maximum.min(MAX_FRAME_BYTES)), + ) + .await + .unwrap_or(Err("gateway.ipc.read-timeout")) } /// Writes one frame within the response-write limit and the session @@ -256,21 +272,31 @@ pub enum AppRecoveryResult { }, } -/// Every application frame selects one closed native operation. -#[derive(Deserialize)] -#[serde(untagged)] -enum AppFrame { - Submit(AppSubmission), - Observe(AppObservation), - Recover(AppRecovery), - Content(AppContent), - Disclose(AppDisclosure), - ContentHistory(AppContentHistory), - DisclosureAck(AppDisclosureAcknowledgement), +// The enum and operator-visible catalog share this one declaration, so an +// application variant cannot be added without entering the interface inventory. +macro_rules! application_frames { + ($($variant:ident($frame:ty) => $schema:expr),* $(,)?) => { + /// Every application frame selects one closed native operation. + #[derive(Deserialize)] + #[serde(untagged)] + enum AppFrame { $($variant($frame)),* } + /// Complete application control-frame schemas, from the native dispatcher. + pub const APPLICATION_REQUEST_SCHEMAS: &[&str] = &[$($schema),*]; + }; +} +application_frames! { + Submit(AppSubmission) => APP_REQUEST_SCHEMA, + Observe(AppObservation) => APP_OBSERVE_SCHEMA, + Recover(AppRecovery) => APP_RECOVERY_SCHEMA, + Content(AppContent) => APP_CONTENT_SCHEMA, + Disclose(AppDisclosure) => APP_DISCLOSURE_SCHEMA, + ContentHistory(AppContentHistory) => APP_CONTENT_HISTORY_SCHEMA, + DisclosureAck(AppDisclosureAcknowledgement) => APP_DISCLOSURE_ACK_SCHEMA, } /// Which closed frame `bytes` parse as, schema included: `submit`, -/// `observe`, `recover`, or `None`. +/// `observe`, `recover`, `content`, `disclose`, `content-history`, +/// `disclosure-ack`, or `None`. #[cfg(feature = "fuzzing")] pub(crate) fn frame_kind(bytes: &[u8]) -> Option<&'static str> { match serde_json::from_slice::(bytes).ok()? { diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index fcb98146d..6c149394d 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -89,7 +89,8 @@ mod unix { const INSTALL_DRAFT_FILE: &str = "candidate-installation.cbor"; const INSTALL_PROPOSAL_FILE: &str = "candidate-installation.json"; use auths_gateway::admin::{ - ADMIN_REQUEST_SCHEMA, ADMIN_RESPONSE_SCHEMA, AdminRequestCommand, parse_admin_request, + ADMIN_REQUEST_SCHEMA, ADMIN_RESPONSE_SCHEMA, AdminRequestCommand, MAX_ADMIN_REQUEST_BYTES, + parse_admin_request, }; /// Descriptors `serve` keeps beyond its listeners' capacities and the /// store pool: standard streams, listeners, store and state files. @@ -2392,10 +2393,12 @@ mod unix { clock: &SessionClock, stream: &mut UnixStream, ) -> Result { - let bytes = clock - .read_frame(stream) - .await - .map_err(|_| "gateway.admin.invalid-frame")?; + let bytes = Zeroizing::new( + clock + .read_frame_limited(stream, MAX_ADMIN_REQUEST_BYTES) + .await + .map_err(|_| "gateway.admin.invalid-frame")?, + ); match parse_admin_request(&bytes)? { AdminRequestCommand::Disable {} => Ok(AdminCommand::Disable), AdminRequestCommand::Enable {} => Ok(AdminCommand::Enable), @@ -5112,6 +5115,49 @@ mod unix { mod tests { use super::*; + #[test] + fn managed_cli_inventory_fixture_is_current() { + use clap::CommandFactory as _; + let mut cli = Cli::command(); + cli.build(); + let mut commands: Vec<_> = cli.get_subcommands().map(|command| { + let mut arguments: Vec<_> = command.get_arguments() + .filter(|argument| argument.get_id().as_str() != "loopback_provider") + .map(|argument| serde_json::json!({"name":argument.get_id().as_str(), "long":argument.get_long(), "required":argument.is_required_set()})) + .collect(); + arguments.sort_by(|left, right| left["name"].as_str().cmp(&right["name"].as_str())); + serde_json::json!({"command":command.get_name(), "arguments":arguments}) + }).collect(); + commands + .sort_by(|left, right| left["command"].as_str().cmp(&right["command"].as_str())); + assert!(!commands.is_empty()); + for obsolete in [ + "reobserve", + "observe-read-back", + "raw-http", + "credential-export", + "retry", + "refund", + ] { + assert!( + !commands + .iter() + .any(|command| command["command"] == obsolete) + ); + } + let artifact = serde_json::to_vec_pretty(&serde_json::json!({ + "schema":"auths.managed-cli-inventory/1", "scope":"all native Clap command and argument declarations; catalog data grants no authority; loopback-provider is test-only and excluded", + "application_schemas":auths_gateway::app::APPLICATION_REQUEST_SCHEMAS, + "operator_commands":auths_gateway::admin::ADMIN_REQUEST_COMMANDS,"cli":commands + })).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/managed-cli-inventory.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(fs::read(path).expect("artifact"), artifact); + } + #[test] fn commissioning_witness_refuses_shared_existing_and_linked_outputs() { let directory = tempfile::tempdir().expect("private output"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index d4800ffe5..9e4284e8a 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "7371aee21694d1783a11ce8fc8977b8db6c921df83ca6407cfb01012136525fd"; + "87d516a91c79770a0db7ce4e066e304b2358274bc5af99248ce21b1abef48efb"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/tests/content_interface_tests.rs b/product/runtime/auths-gateway/tests/content_interface_tests.rs new file mode 100644 index 000000000..69d435cb3 --- /dev/null +++ b/product/runtime/auths-gateway/tests/content_interface_tests.rs @@ -0,0 +1,528 @@ +//! Actual application interfaces; distinct UID mode additionally tests Linux DAC. +use super::*; +use auths_gateway::{admin, app}; +use sha2::{Digest as _, Sha256}; +use std::collections::BTreeSet; + +fn no_canaries(bytes: &[u8], secret: &[u8]) { + for value in [CONTENT, secret] { + let digest = Sha256::digest(value); + let variants = [ + value.to_vec(), + base64ct::Base64::encode_string(value).into_bytes(), + Base64UrlUnpadded::encode_string(value).into_bytes(), + hex::encode(value).into_bytes(), + digest.to_vec(), + hex::encode(digest).into_bytes(), + base64ct::Base64::encode_string(&digest).into_bytes(), + Base64UrlUnpadded::encode_string(&digest).into_bytes(), + ]; + for variant in variants { + assert!( + !bytes.windows(variant.len()).any(|part| part == variant), + "sensitive value or guessable digest reached a public boundary" + ); + } + } +} +fn scan_value(value: &Value, secret: &[u8]) { + match value { + Value::String(value) => { + no_canaries(value.as_bytes(), secret); + for decoded in [ + base64ct::Base64::decode_vec(value), + Base64UrlUnpadded::decode_vec(value), + ] + .into_iter() + .flatten() + { + no_canaries(&decoded, secret); + } + } + Value::Array(values) => { + for value in values { + scan_value(value, secret); + } + } + Value::Object(values) => { + for value in values.values() { + scan_value(value, secret); + } + } + _ => {} + } +} +fn checked(output: Output, secret: &[u8]) -> Value { + no_canaries(&output.stdout, secret); + no_canaries(&output.stderr, secret); + assert!(output.status.success(), "native process failed"); + let value = serde_json::from_slice(&output.stdout).expect("native public JSON"); + scan_value(&value, secret); + value +} +fn envelope(input: &Approved) -> Value { + let encode = + |path: &Path| Base64UrlUnpadded::encode_string(&std::fs::read(path).expect("native input")); + json!({"schema":app::APP_REQUEST_SCHEMA, "proof_b64":encode(&input.proof), "action_b64":encode(&input.action), "approval_b64":encode(&input.approval)}) +} +fn case(name: &str, value: &Value) -> Value { + json!({"case":name,"frame":serde_json::to_string(value).expect("frame")}) +} +fn private_paths(root: &Path) -> Vec { + let mut paths = Vec::new(); + for entry in std::fs::read_dir(root).expect("owned fixture directory") { + let entry = entry.expect("entry"); + if entry.file_type().expect("type").is_dir() { + paths.extend(private_paths(&entry.path())); + } else if entry.file_type().expect("type").is_file() { + paths.push(entry.path()); + } + } + paths.sort(); + paths +} +fn witness(state: &Path, admin: &Path, secret: &[u8]) -> Value { + checked( + cli( + "execution-witness", + &[ + ("--state-dir", path(state)), + ("--admin-socket", path(admin)), + ], + &[], + None, + ), + secret, + )["execution_witness"] + .clone() +} + +fn probe(mut payload: Value, secret: &[u8]) -> Value { + let distinct = payload["distinct_uid"].as_bool().expect("mode"); + let mut child = if distinct { + let mut command = Command::new("sudo"); + command + .args(["-n", "setpriv", "--reuid=65534"]) + .arg(format!("--regid={}", rustix::process::getegid().as_raw())) + .args([ + "--clear-groups", + "--bounding-set=-all", + "--inh-caps=-all", + "--ambient-caps=-all", + "--no-new-privs", + "python3", + ]); + command + } else { + Command::new("python3") + }; + child + .arg("-c") + .arg(include_str!("managed_interface_probe.py")) + .env_clear() + .env("PATH", std::env::var_os("PATH").expect("PATH")) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + payload["binary"] = json!(env!("CARGO_BIN_EXE_auths-gateway")); + let mut child = child.spawn().expect("untrusted process"); + child + .stdin + .take() + .expect("stdin") + .write_all(&serde_json::to_vec(&payload).expect("probe data")) + .expect("probe input"); + let output = child.wait_with_output().expect("untrusted process output"); + no_canaries(&output.stdout, secret); + no_canaries(&output.stderr, secret); + assert!( + output.status.success(), + "untrusted process assertion failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + let mut result: Value = serde_json::from_slice(&output.stdout).expect("probe report"); + scan_value(&result, secret); + for value in result["cases"].as_array_mut().expect("cases") { + for frame in value["after_ready_b64"].as_array().expect("frames") { + let bytes = + base64ct::Base64::decode_vec(frame.as_str().expect("base64")).expect("frame bytes"); + no_canaries(&bytes, secret); + } + let count = value["after_ready_b64"].as_array().expect("frames").len(); + value + .as_object_mut() + .expect("case") + .remove("after_ready_b64"); + value["post_ready_control_frames"] = json!(count); + } + for value in result["private_cli"].as_array_mut().expect("private CLI") { + for field in ["stdout_b64", "stderr_b64"] { + let bytes = base64ct::Base64::decode_vec(value[field].as_str().expect("base64")) + .expect("output"); + no_canaries(&bytes, secret); + value.as_object_mut().expect("result").remove(field); + } + } + result +} + +#[allow( + clippy::too_many_lines, + reason = "one installed native fixture checks all application interfaces against a counting provider and owned private state" +)] +fn run(distinct: bool) -> Value { + if distinct { + assert!(cfg!(target_os = "linux")); + } + let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); + let bases: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("hostile-recipes-v2.json")).expect("recipes"), + ) + .expect("JSON"); + let mut source = bases["bases"]["airtable"]["recipe"].clone(); + source["content"] = json!({"schema":"auths.gateway-content-read/1","resource_field":"record_id", + "path":[{"kind":"fixed","value":"documents"},{"kind":"field","name":"record_id"}], + "query":[{"name":"format","value":"text/plain"}],"projection":{"kind":"utf8"},"maximum_response_bytes":1024,"maximum_content_bytes":64}); + let source = serde_json::to_vec(&source).expect("recipe"); + let lock = serde_json::to_vec(&bases["bases"]["airtable"]["lock"]).expect("lock"); + let recipe = CompiledRecipe::compile(&source, &lock).expect("native recipe"); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("clock") + .as_secs(); + let tools = [ + CONTENT_READ_TOOL, + DISCLOSURE_TOOL, + recipe.review().tool(), + "auths_gateway_recovery_read_v1", + ] + .map(|name| { + McpToolCall::new(recipe.review().service(), name, serde_json::Map::new()).expect("tool") + }); + let trust = tools_context(&tools, now).expect("native trust"); + let reviewer = SigningKey::from_bytes(&[29; 32]); + let recipient = SigningKey::from_bytes(&[31; 32]); + let policy = EffectPolicy::new( + "managed-interface-probe".to_owned(), + 1, + reviewer.verifying_key().to_bytes(), + ) + .expect("policy"); + let directory = tempfile::Builder::new() + .prefix("ap74-if-") + .tempdir_in("/tmp") + .expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical root"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o755)) + .expect("traversable socket parent"); + let state = root.join("state"); + let socket = root.join("app.sock"); + let admin_directory = root.join("operator"); + std::fs::create_dir(&admin_directory).expect("operator directory"); + std::fs::set_permissions(&admin_directory, std::fs::Permissions::from_mode(0o700)) + .expect("private operator directory"); + let admin_socket = admin_directory.join("admin.sock"); + for (name, bytes) in [ + ("recipe", source), + ("lock", lock), + ("trust", trust), + ( + "policy", + policy.to_private_bytes().expect("policy").to_vec(), + ), + ] { + private(&root.join(name), &bytes); + } + let mut entropy = [0_u8; 32]; + getrandom::fill(&mut entropy).expect("fresh credential entropy"); + let secret = zeroize::Zeroizing::new( + format!("pat_ap074_isolation_{}", hex::encode(entropy)).into_bytes(), + ); + let provider = Provider::configured(secret.to_vec(), true); + let installed = cli( + "install", + &[ + ("--state-dir", path(&state)), + ("--recipe", path(&root.join("recipe"))), + ("--profile-lock", path(&root.join("lock"))), + ("--trusted-context", path(&root.join("trust"))), + ("--effect-policy", path(&root.join("policy"))), + ("--approve-digest", &recipe.digest_hex()), + ("--provider", "airtable"), + ("--alias", "interfaces"), + ("--account-label", "public-fixture"), + ], + &["--credential-stdin"], + Some(&secret), + ); + no_canaries(&installed.stdout, &secret); + no_canaries(&installed.stderr, &secret); + assert!(installed.status.success(), "native install"); + let arguments = root.join("resource.json"); + private( + &arguments, + &serde_json::to_vec(&json!({"record_id":RECORD})).expect("resource"), + ); + let read_call = root.join("read.call"); + success(cli( + "effect-content-call", + &[ + ("--state-dir", path(&state)), + ("--resource-arguments", path(&arguments)), + ("--operation", "read"), + ("--call-out", path(&read_call)), + ], + &[], + None, + )); + let read = approve( + &state, + &call_file(&read_call), + "read", + now, + &reviewer, + &[], + &["--content"], + ); + let mut daemon = Daemon::start_at_admin(&state, &socket, &admin_socket, provider.port); + let acquired = checked( + read.execute("content-acquire", &socket, &[], &[], None), + &secret, + ); + assert_eq!( + acquired["history"]["snapshot"]["content_projection"]["kind"], + "ready" + ); + assert_eq!(provider.calls().len(), 1); + let uid = rustix::process::geteuid().as_raw(); + let target = root.join("target.json"); + private( + &target, + &serde_json::to_vec(&AppDisclosureTarget { + source_operation: "read".to_owned(), + recipient_key: recipient.verifying_key().to_bytes(), + channel: UnixDisclosurePolicy::new(uid, uid, [5; 32]), + delivery_instance: [6; 32], + }) + .expect("target"), + ); + let release_call = root.join("release.call"); + success(cli( + "effect-disclosure-call", + &[ + ("--state-dir", path(&state)), + ("--target", path(&target)), + ("--operation", "release"), + ("--call-out", path(&release_call)), + ], + &[], + None, + )); + let release = approve( + &state, + &call_file(&release_call), + "release", + now, + &reviewer, + &[("--disclosure", path(&target))], + &[], + ); + let disclose = json!({"schema":app::APP_DISCLOSURE_SCHEMA,"target":serde_json::from_slice::(&std::fs::read(&target).expect("target")).expect("JSON"),"submission":envelope(&release)}); + let mut calls = vec![ + case("submit-with-read-authority", &envelope(&read)), + case( + "content-replay", + &json!({"schema":app::APP_CONTENT_SCHEMA,"submission":envelope(&read)}), + ), + case( + "content-history", + &json!({"schema":app::APP_CONTENT_HISTORY_SCHEMA,"operation":"read"}), + ), + case("disclose-without-recipient-authentication", &disclose), + case( + "recover-with-acquisition-source", + &json!({"schema":app::APP_RECOVERY_SCHEMA,"source_operation":"read","submission":envelope(&read)}), + ), + case( + "observe-outcome", + &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"outcome","operation_id":"read"}}), + ), + case( + "observe-pre-entry", + &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"pre-entry","operation_id":"read"}}), + ), + case( + "forged-ack", + &json!({"schema":app::APP_DISCLOSURE_ACK_SCHEMA,"operation":"release","acknowledgement_b64":Base64UrlUnpadded::encode_string(b"{}")}), + ), + ]; + let covered: BTreeSet<_> = calls + .iter() + .map(|value| { + serde_json::from_str::(value["frame"].as_str().expect("frame")) + .expect("JSON")["schema"] + .as_str() + .expect("schema") + .to_owned() + }) + .collect(); + assert_eq!( + covered, + app::APPLICATION_REQUEST_SCHEMAS + .iter() + .map(|schema| (*schema).to_owned()) + .collect() + ); + let boundary: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("admin-request-boundary.json")).expect("admin corpus"), + ) + .expect("JSON"); + let admin_frames: Vec<_> = boundary["cases"] + .as_array() + .expect("cases") + .iter() + .filter(|case| case["case"].as_str().expect("name").ends_with(":valid")) + .map(|case| case["input"].clone()) + .collect(); + assert_eq!(admin_frames.len(), admin::ADMIN_REQUEST_COMMANDS.len()); + for value in &admin_frames { + let frame: Value = serde_json::from_str(value.as_str().expect("frame")).expect("JSON"); + calls.push(case( + &format!( + "admin-on-app:{}", + frame["command"].as_str().expect("command") + ), + &frame, + )); + } + for schema in [ + "auths.gateway-submit/1", + "auths.gateway-observe/2", + "auths.gateway-recover/0", + "auths.gateway-content/0", + "auths.gateway-disclose/0", + ] { + calls.push(case(schema, &json!({"schema":schema,"operation":"read"}))); + } + for command in [ + "reobserve", + "raw-http", + "credential-export", + "retry", + "refund", + "resolve-as-not-entered", + ] { + calls.push(case(command,&json!({"schema":app::APP_REQUEST_SCHEMA,"command":command,"url":"https://untrusted.invalid","body":"untrusted"}))); + } + calls.push( + json!({"case":"oversized-advertised-frame","advertised_length":app::MAX_FRAME_BYTES+1}), + ); + calls.push(json!({"case":"http-on-app-socket","raw_http":true})); + let inventory: Value = serde_json::from_slice( + &std::fs::read(fixtures.join("managed-cli-inventory.json")).expect("native CLI catalog"), + ) + .expect("JSON"); + let commands: Vec<_> = inventory["cli"] + .as_array() + .expect("CLI") + .iter() + .map(|value| value["command"].clone()) + .collect(); + let key = auths_gateway::GatewayAttemptKey::for_operation( + &policy, + recipe.namespace(), + &auths_gateway::LogicalOperationId::parse("read").expect("operation"), + ) + .expect("key"); + let source_path = state + .join("attempts") + .join(format!("claim-{}.json", hex::encode(key.as_bytes()))); + let source_before = std::fs::read(&source_path).expect("private source journal"); + let before = witness(&state, &admin_socket, &secret); + if distinct { + std::fs::set_permissions(&admin_directory, std::fs::Permissions::from_mode(0o755)) + .expect("exercise accept-time UID guard"); + std::fs::set_permissions(&admin_socket, std::fs::Permissions::from_mode(0o666)) + .expect("exercise peer guard beyond DAC"); + } + let payload = json!({"distinct_uid":distinct,"gateway_uid":uid,"gateway_pid":daemon.0.id(),"socket":socket,"state":state,"admin_socket":admin_socket,"provider_port":provider.port,"private_paths":private_paths(&root),"cases":calls,"admin_frames":admin_frames,"cli_commands":commands}); + let first = probe(payload.clone(), &secret); + assert_eq!(witness(&state, &admin_socket, &secret), before); + assert_eq!(provider.calls().len(), 1); + assert_eq!(provider.denied.load(Ordering::SeqCst), 2); + assert!( + source_before == std::fs::read(&source_path).expect("source"), + "source journal changed" + ); + let reserved = history(&socket, "release"); + assert_eq!(reserved["history"]["snapshot"]["stage"], "reserved"); + let content = root.join("received"); + let ack = root.join("ack"); + let expected_bytes = CONTENT.len().to_string(); + let received = checked( + release.execute( + "disclosure-receive", + &socket, + &[ + ("--target", path(&target)), + ("--expected-binding", path(&release.binding)), + ("--expected-bytes", &expected_bytes), + ("--content-out", path(&content)), + ("--acknowledgement-out", path(&ack)), + ], + &["--recipient-seed-stdin"], + Some(&[31; 32]), + ), + &secret, + ); + assert_eq!(received["outcome"], "recipient-ack-sent"); + assert!(std::fs::read(&content).expect("trusted recipient content") == CONTENT); + let acknowledged = history(&socket, "release"); + assert_eq!(acknowledged["history"]["snapshot"]["stage"], "acknowledged"); + let mut replay_payload = payload; + replay_payload["private_paths"] = json!(private_paths(&root)); + replay_payload["cases"] = json!([case("disclosure-replay-after-owner-ack", &disclose)]); + replay_payload["admin_frames"] = json!([]); + replay_payload["cli_commands"] = json!([]); + let replay = probe(replay_payload, &secret); + assert_eq!(provider.calls().len(), 1); + assert_eq!(provider.denied.load(Ordering::SeqCst), 4); + assert_eq!(witness(&state, &admin_socket, &secret), before); + assert_eq!(history(&socket, "release"), acknowledged); + no_canaries(&daemon.finish_logs(), &secret); + json!({"schema":"auths.managed-interface-probe/1","distinct_uid":distinct, + "scope":"real native daemon, fresh runtime credential, actual local HTTP, all native application schemas, all operator commands injected on the application channel and every CLI help entry", + "excluded":["hostile OS or root", "provider or production custody qualification", "all privileged CLI execution paths", "positive signed mutation outcome privacy"], + "first":first,"replay":replay,"private_source_journal_unchanged":true,"provider_authorized_calls":1, + "direct_provider_refusals":4,"no_new_custody_or_provider_entries":true, + "recipient_key_and_uid_guard_precede_content":true,"trusted_recipient_positive_control":true, + "public_channels_exclude_plaintext_encodings_and_raw_digests":true}) +} + +#[test] +fn native_managed_interface_fixture_is_current() { + let report = run(false); + let bytes = serde_json::to_vec_pretty(&report).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/managed-interface-unix.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("artifact"), bytes); +} + +#[cfg(target_os = "linux")] +#[test] +#[ignore = "requires hosted Linux sudo and a distinct UID"] +fn distinct_uid_managed_interface_evidence() { + let mut report = run(true); + report["source_commit"] = + json!(std::env::var("AUTHS_EVIDENCE_SOURCE_REVISION").expect("source revision")); + let target = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../target"); + std::fs::create_dir_all(&target).expect("artifact directory"); + std::fs::write( + target.join("ap074-managed-interface-isolation.json"), + serde_json::to_vec_pretty(&report).expect("artifact"), + ) + .expect("artifact"); +} diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index 2d2bc6a09..f2b451d1d 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -34,6 +34,9 @@ const SECRET: &[u8] = b"pat_public_content_journey_fixture"; const CONTENT: &[u8] = b"PRIVATE-CONTENT-PROCESS-SENTINEL"; const RECORD: &str = "recTEST0000000001"; +#[path = "content_interface_tests.rs"] +mod interface_tests; + fn private(path: &Path, bytes: &[u8]) { std::fs::write(path, bytes).expect("write"); std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).expect("mode"); @@ -102,15 +105,22 @@ struct Provider { calls: Arc>>, stop: Arc, join: Option>, + denied: Arc, } impl Provider { fn start() -> Self { + Self::configured(SECRET.to_vec(), false) + } + fn configured(secret: Vec, refuse_unauthorized: bool) -> Self { + let secret = zeroize::Zeroizing::new(secret); let listener = TcpListener::bind("127.0.0.1:0").expect("listener"); let port = listener.local_addr().expect("address").port(); listener.set_nonblocking(true).expect("nonblocking"); let calls = Arc::new(Mutex::new(Vec::new())); let stop = Arc::new(AtomicBool::new(false)); let captured = calls.clone(); + let denied = Arc::new(std::sync::atomic::AtomicUsize::new(0)); + let refused = denied.clone(); let finished = stop.clone(); let join = thread::spawn(move || { let mut record = json!({"fields":{"DemoStatus":"Pending"}}); @@ -140,10 +150,21 @@ impl Provider { request.push(byte[0]); } let header = String::from_utf8(request).expect("header"); - assert!(header.to_ascii_lowercase().contains(&format!( - "authorization: bearer {}\r\n", - String::from_utf8_lossy(SECRET) - ))); + let expected = format!("Bearer {}", String::from_utf8_lossy(&secret)); + let authenticated = header.lines().any(|line| { + line.split_once(':').is_some_and(|(name, value)| { + name.eq_ignore_ascii_case("authorization") && value.trim() == expected + }) + }); + if !authenticated && refuse_unauthorized { + refused.fetch_add(1, Ordering::SeqCst); + stream.write_all(b"HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 0\r\n\r\n").expect("unauthorized response"); + continue; + } + assert!( + authenticated, + "native gateway must send the exact fixture credential" + ); let line = header.lines().next().expect("request").to_owned(); let length = header .lines() @@ -192,6 +213,7 @@ impl Provider { calls, stop, join: Some(join), + denied, } } fn calls(&self) -> Vec { @@ -239,6 +261,18 @@ impl Daemon { } daemon } + fn finish_logs(&mut self) -> Vec { + self.0.kill().expect("stop owned daemon"); + self.0.wait().expect("reap owned daemon"); + let mut bytes = Vec::new(); + if let Some(mut output) = self.0.stdout.take() { + output.read_to_end(&mut bytes).expect("stdout"); + } + if let Some(mut output) = self.0.stderr.take() { + output.read_to_end(&mut bytes).expect("stderr"); + } + bytes + } } impl Drop for Daemon { fn drop(&mut self) { diff --git a/product/runtime/auths-gateway/tests/managed_interface_probe.py b/product/runtime/auths-gateway/tests/managed_interface_probe.py new file mode 100644 index 000000000..4e5ec4998 --- /dev/null +++ b/product/runtime/auths-gateway/tests/managed_interface_probe.py @@ -0,0 +1,141 @@ +"""Untrusted client test: framing and OS probes only, no authorization evaluator.""" +import base64 +import json +import os +import socket +import struct +import subprocess +import sys + + +def exact(stream, count): + value = bytearray() + while len(value) < count: + chunk = stream.recv(count - len(value)) + if not chunk: + raise EOFError("closed native channel") + value.extend(chunk) + return bytes(value) + + +def receive(stream): + length = struct.unpack('!I', exact(stream, 4))[0] + assert 0 < length <= 8 * 1024 * 1024, 'unbounded native reply' + return exact(stream, length) + + +def send(stream, value): + stream.sendall(struct.pack('!I', len(value)) + value) + + +data = json.load(sys.stdin) +distinct = data['distinct_uid'] +assert (os.geteuid() != data['gateway_uid']) == distinct, 'wrong test UID' +if distinct: + assert os.geteuid() == 65534, 'wrong untrusted UID' + for filename in data['private_paths']: + try: + with open(filename, 'rb') as private: + private.read(1) + except PermissionError: + pass + else: + raise AssertionError('managed private file was readable') + for filename in ('environ', 'mem'): + try: + with open(f"/proc/{data['gateway_pid']}/{filename}", 'rb') as private: + private.read(1) + except PermissionError: + pass + else: + raise AssertionError('gateway process memory was readable') + try: + os.chmod(data['state'], 0o777) + except PermissionError: + pass + else: + raise AssertionError('application changed private state permissions') + try: + os.setuid(data['gateway_uid']) + except PermissionError: + pass + else: + raise AssertionError('application acquired gateway UID') + +cases = [] +for case in data['cases']: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as stream: + stream.settimeout(5) + stream.connect(data['socket']) + if case.get('advertised_length'): + stream.sendall(struct.pack('!I', case['advertised_length'])) + elif case.get('raw_http'): + stream.sendall(b'GET /credentials HTTP/1.1\r\n\r\n') + else: + send(stream, case['frame'].encode('utf-8')) + reply = receive(stream) + result = json.loads(reply) + after = [] + if result.get('outcome') == 'ready': + try: + challenge = receive(stream) + after.append(base64.b64encode(challenge).decode('ascii')) + send(stream, b'{}') # deliberately no recipient key possession + try: + after.append(base64.b64encode(receive(stream)).decode('ascii')) + except (EOFError, ConnectionResetError): + pass + except (EOFError, ConnectionResetError): + pass + assert len(after) <= (0 if distinct else 1), 'unexpected bytes after failed recipient authentication' + cases.append({'case': case['case'], 'response': result, 'after_ready_b64': after}) + +admin = [] +if distinct: + for frame in data['admin_frames']: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as stream: + stream.settimeout(5) + stream.connect(data['admin_socket']) # intentionally permissive inode + try: + send(stream, frame.encode('utf-8')) + assert not stream.recv(1), 'operator bytes reached the wrong UID' + except (BrokenPipeError, ConnectionResetError): + pass + admin.append(json.loads(frame)['command']) + +cli = [] +for name in data['cli_commands']: + arguments = [data['binary'], 'help'] if name == 'help' else [data['binary'], name, '--help'] + result = subprocess.run(arguments, capture_output=True, timeout=10) + assert result.returncode == 0, 'native help entry inaccessible' + cli.append({'command': name, 'help_accessible': True}) + +private_cli = [] +if distinct: + for arguments in ( + ['serve', '--state-dir', data['state'], '--app-socket', data['socket'] + '.alternate'], + ['status', '--state-dir', data['state'], '--admin-socket', data['admin_socket']], + ['execution-witness', '--state-dir', data['state'], '--admin-socket', data['admin_socket']], + ['readiness-probe', '--state-dir', data['state']], + ): + result = subprocess.run([data['binary']] + arguments, capture_output=True, timeout=10) + assert result.returncode != 0, 'application used a private native CLI route' + private_cli.append({'command': arguments[0], 'refused': True, + 'stdout_b64': base64.b64encode(result.stdout).decode('ascii'), + 'stderr_b64': base64.b64encode(result.stderr).decode('ascii')}) + +direct = [] +for credential in (None, 'pat_public_content_journey_fixture'): + with socket.create_connection(('127.0.0.1', data['provider_port']), timeout=5) as stream: + headers = '' if credential is None else f'Authorization: Bearer {credential}\r\n' + stream.sendall(('PATCH /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1\r\n' + 'Host: localhost\r\n' + headers + 'Content-Length: 0\r\nConnection: close\r\n\r\n').encode('ascii')) + response = bytearray() + while chunk := stream.recv(4096): + response.extend(chunk) + assert bytes(response).startswith(b'HTTP/1.1 401 '), 'direct provider call acquired managed credentials' + direct.append({'credential': 'absent' if credential is None else 'public-fixture-guess', 'status': 401}) + +json.dump({'distinct_uid': distinct, 'cases': cases, 'admin_commands_closed': admin, + 'cli': cli, 'private_cli': private_cli, 'direct_provider': direct, + 'private_files_inaccessible': len(data['private_paths']) if distinct else None}, sys.stdout) diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index b25220583..ec8a68e76 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 423 +freeze_version = 424 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 423 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 166 +"auths.identity.protocol" = 167 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 126 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 423 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 163 +"auths.product.public-sdk-contract" = 164 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 28 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 423 +"auths.release.public-surface" = 424 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index f70f146ce..31617e117 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 423, + "freezeVersion": 424, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 166, + "version": 167, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "713817d4ea3bd8bc14879c5bb6de774bb898d7d07aacacf9506018c8bc749510" + "sha256": "17d5aabaa33bb511d80f7b8a2256259913a2b1dc953b9bc5777b2c4edab413f5" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 163, + "version": 164, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "6c3ed223092a2d7835c6a9a6969c5f25b46700e605cb2ff7ca2d751a311e3dbe" + "sha256": "8afbe7aba45cd868eb1b51e4db6722e4f4be2ab3c819651a0e29d06b34588ee0" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 423, + "version": 424, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "56d3d7496df23701cb7fa8af2b1a9879f77136ec19d086f8030bc8c0321d8085" + "sha256": "f4edc6505292747b4d3d691dd321a7ee7d102cd3144aa47e28b040249325f6ce" } ] } From 09838a195b3f87e936d374803f9d5c865c4582b2 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 03:40:32 +0000 Subject: [PATCH 115/136] fix(ci): preserve managed interface isolation controls --- .../auths-gateway/src/admin_boundary_tests.rs | 16 +++--- .../auths-gateway/tests/content_journey.rs | 17 +++--- .../interface_tests.rs} | 55 +++++++++++++------ 3 files changed, 56 insertions(+), 32 deletions(-) rename product/runtime/auths-gateway/tests/{content_interface_tests.rs => content_journey/interface_tests.rs} (92%) diff --git a/product/runtime/auths-gateway/src/admin_boundary_tests.rs b/product/runtime/auths-gateway/src/admin_boundary_tests.rs index 1a9523de0..465ddcf91 100644 --- a/product/runtime/auths-gateway/src/admin_boundary_tests.rs +++ b/product/runtime/auths-gateway/src/admin_boundary_tests.rs @@ -25,7 +25,7 @@ fn request(command: &str) -> Value { value } -fn record(cases: &mut Vec, name: String, bytes: Vec, accepted: bool) { +fn record(cases: &mut Vec, name: &str, bytes: Vec, accepted: bool) { let result = parse_admin_request(&bytes); assert_eq!(result.is_ok(), accepted, "{name}"); if !accepted { @@ -48,7 +48,7 @@ fn admin_request_boundary_fixture_is_current() { let value = request(command); record( &mut cases, - format!("{command}:valid"), + &format!("{command}:valid"), serde_json::to_vec(&value).expect("JSON"), true, ); @@ -65,7 +65,7 @@ fn admin_request_boundary_fixture_is_current() { ); record( &mut cases, - format!( + &format!( "{command}:duplicate-{key}-{}", if &replacement == field { "same" @@ -82,7 +82,7 @@ fn admin_request_boundary_fixture_is_current() { unknown["administrative_resolution"] = json!("not-entered-and-refunded"); record( &mut cases, - format!("{command}:unknown-argument"), + &format!("{command}:unknown-argument"), serde_json::to_vec(&unknown).expect("JSON"), false, ); @@ -90,7 +90,7 @@ fn admin_request_boundary_fixture_is_current() { wrong_type["command"] = json!({"name":command}); record( &mut cases, - format!("{command}:non-string-command"), + &format!("{command}:non-string-command"), serde_json::to_vec(&wrong_type).expect("JSON"), false, ); @@ -104,15 +104,15 @@ fn admin_request_boundary_fixture_is_current() { ("non-object", b"[]".to_vec()), ("trailing-data", format!(r#"{{"schema":"{ADMIN_REQUEST_SCHEMA}","command":"status"}} null"#).into_bytes()), ] { - record(&mut cases, name.to_owned(), bytes, false); + record(&mut cases, name, bytes, false); } let mut boundary = serde_json::to_vec(&request("status")).expect("JSON"); boundary.resize(MAX_ADMIN_REQUEST_BYTES, b' '); - record(&mut cases, "byte-limit".to_owned(), boundary.clone(), true); + record(&mut cases, "byte-limit", boundary.clone(), true); boundary.push(b' '); record( &mut cases, - "byte-limit-plus-one".to_owned(), + "byte-limit-plus-one", boundary, false, ); diff --git a/product/runtime/auths-gateway/tests/content_journey.rs b/product/runtime/auths-gateway/tests/content_journey.rs index f2b451d1d..e42d2eecb 100644 --- a/product/runtime/auths-gateway/tests/content_journey.rs +++ b/product/runtime/auths-gateway/tests/content_journey.rs @@ -34,7 +34,7 @@ const SECRET: &[u8] = b"pat_public_content_journey_fixture"; const CONTENT: &[u8] = b"PRIVATE-CONTENT-PROCESS-SENTINEL"; const RECORD: &str = "recTEST0000000001"; -#[path = "content_interface_tests.rs"] +#[path = "content_journey/interface_tests.rs"] mod interface_tests; fn private(path: &Path, bytes: &[u8]) { @@ -150,12 +150,7 @@ impl Provider { request.push(byte[0]); } let header = String::from_utf8(request).expect("header"); - let expected = format!("Bearer {}", String::from_utf8_lossy(&secret)); - let authenticated = header.lines().any(|line| { - line.split_once(':').is_some_and(|(name, value)| { - name.eq_ignore_ascii_case("authorization") && value.trim() == expected - }) - }); + let authenticated = Self::authenticated(&header, &secret); if !authenticated && refuse_unauthorized { refused.fetch_add(1, Ordering::SeqCst); stream.write_all(b"HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 0\r\n\r\n").expect("unauthorized response"); @@ -216,6 +211,14 @@ impl Provider { denied, } } + fn authenticated(header: &str, secret: &[u8]) -> bool { + let expected = format!("Bearer {}", String::from_utf8_lossy(secret)); + header.lines().any(|line| { + line.split_once(':').is_some_and(|(name, value)| { + name.eq_ignore_ascii_case("authorization") && value.trim() == expected + }) + }) + } fn calls(&self) -> Vec { self.calls.lock().expect("calls").clone() } diff --git a/product/runtime/auths-gateway/tests/content_interface_tests.rs b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs similarity index 92% rename from product/runtime/auths-gateway/tests/content_interface_tests.rs rename to product/runtime/auths-gateway/tests/content_journey/interface_tests.rs index 69d435cb3..e4fded622 100644 --- a/product/runtime/auths-gateway/tests/content_interface_tests.rs +++ b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs @@ -52,7 +52,7 @@ fn scan_value(value: &Value, secret: &[u8]) { _ => {} } } -fn checked(output: Output, secret: &[u8]) -> Value { +fn checked(output: &Output, secret: &[u8]) -> Value { no_canaries(&output.stdout, secret); no_canaries(&output.stderr, secret); assert!(output.status.success(), "native process failed"); @@ -83,7 +83,7 @@ fn private_paths(root: &Path) -> Vec { } fn witness(state: &Path, admin: &Path, secret: &[u8]) -> Value { checked( - cli( + &cli( "execution-witness", &[ ("--state-dir", path(state)), @@ -99,6 +99,14 @@ fn witness(state: &Path, admin: &Path, secret: &[u8]) -> Value { fn probe(mut payload: Value, secret: &[u8]) -> Value { let distinct = payload["distinct_uid"].as_bool().expect("mode"); + let admin_socket = PathBuf::from(payload["admin_socket"].as_str().expect("admin socket")); + let admin_directory = admin_socket.parent().expect("admin directory"); + if distinct { + std::fs::set_permissions(admin_directory, std::fs::Permissions::from_mode(0o755)) + .expect("exercise accept-time UID guard"); + std::fs::set_permissions(&admin_socket, std::fs::Permissions::from_mode(0o666)) + .expect("exercise peer guard beyond DAC"); + } let mut child = if distinct { let mut command = Command::new("sudo"); command @@ -118,7 +126,7 @@ fn probe(mut payload: Value, secret: &[u8]) -> Value { }; child .arg("-c") - .arg(include_str!("managed_interface_probe.py")) + .arg(include_str!("../managed_interface_probe.py")) .env_clear() .env("PATH", std::env::var_os("PATH").expect("PATH")) .stdin(Stdio::piped()) @@ -133,6 +141,14 @@ fn probe(mut payload: Value, secret: &[u8]) -> Value { .write_all(&serde_json::to_vec(&payload).expect("probe data")) .expect("probe input"); let output = child.wait_with_output().expect("untrusted process output"); + if distinct { + // The permissive inode is scoped to the untrusted peer probe. Trusted + // admin clients must still enforce a private directory and socket. + std::fs::set_permissions(&admin_socket, std::fs::Permissions::from_mode(0o600)) + .expect("restore private admin socket"); + std::fs::set_permissions(admin_directory, std::fs::Permissions::from_mode(0o700)) + .expect("restore private admin directory"); + } no_canaries(&output.stdout, secret); no_canaries(&output.stderr, secret); assert!( @@ -171,9 +187,8 @@ fn probe(mut payload: Value, secret: &[u8]) -> Value { reason = "one installed native fixture checks all application interfaces against a counting provider and owned private state" )] fn run(distinct: bool) -> Value { - if distinct { - assert!(cfg!(target_os = "linux")); - } + #[cfg(not(target_os = "linux"))] + assert!(!distinct, "distinct-UID evidence requires Linux"); let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../bindings/fixtures/gateway"); let bases: Value = serde_json::from_slice( &std::fs::read(fixtures.join("hostile-recipes-v2.json")).expect("recipes"), @@ -286,7 +301,7 @@ fn run(distinct: bool) -> Value { ); let mut daemon = Daemon::start_at_admin(&state, &socket, &admin_socket, provider.port); let acquired = checked( - read.execute("content-acquire", &socket, &[], &[], None), + &read.execute("content-acquire", &socket, &[], &[], None), &secret, ); assert_eq!( @@ -439,12 +454,6 @@ fn run(distinct: bool) -> Value { .join(format!("claim-{}.json", hex::encode(key.as_bytes()))); let source_before = std::fs::read(&source_path).expect("private source journal"); let before = witness(&state, &admin_socket, &secret); - if distinct { - std::fs::set_permissions(&admin_directory, std::fs::Permissions::from_mode(0o755)) - .expect("exercise accept-time UID guard"); - std::fs::set_permissions(&admin_socket, std::fs::Permissions::from_mode(0o666)) - .expect("exercise peer guard beyond DAC"); - } let payload = json!({"distinct_uid":distinct,"gateway_uid":uid,"gateway_pid":daemon.0.id(),"socket":socket,"state":state,"admin_socket":admin_socket,"provider_port":provider.port,"private_paths":private_paths(&root),"cases":calls,"admin_frames":admin_frames,"cli_commands":commands}); let first = probe(payload.clone(), &secret); assert_eq!(witness(&state, &admin_socket, &secret), before); @@ -460,7 +469,7 @@ fn run(distinct: bool) -> Value { let ack = root.join("ack"); let expected_bytes = CONTENT.len().to_string(); let received = checked( - release.execute( + &release.execute( "disclosure-receive", &socket, &[ @@ -476,9 +485,21 @@ fn run(distinct: bool) -> Value { &secret, ); assert_eq!(received["outcome"], "recipient-ack-sent"); - assert!(std::fs::read(&content).expect("trusted recipient content") == CONTENT); - let acknowledged = history(&socket, "release"); - assert_eq!(acknowledged["history"]["snapshot"]["stage"], "acknowledged"); + // Keep protected bytes out of assertion diagnostics. + assert!( + std::fs::read(&content).expect("trusted recipient content") == CONTENT, + "trusted recipient content differs" + ); + let deadline = Instant::now() + Duration::from_secs(5); + let acknowledged = loop { + let value = history(&socket, "release"); + scan_value(&value, &secret); + if value["history"]["snapshot"]["stage"] == "acknowledged" { + break value; + } + assert!(Instant::now() < deadline, "ACK was not durably recorded"); + thread::sleep(Duration::from_millis(10)); + }; let mut replay_payload = payload; replay_payload["private_paths"] = json!(private_paths(&root)); replay_payload["cases"] = json!([case("disclosure-replay-after-owner-ack", &disclose)]); From 1769057a61c81a649ed322c5ebe3af9f37e44d2d Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 04:04:09 +0000 Subject: [PATCH 116/136] feat(gateway)!: hide public mutation evidence commitments --- .github/workflows/postgres-lifecycle.yml | 2 + .../native-public-mutation-evidence-file.json | 100 +++++++ ...ive-public-mutation-evidence-postgres.json | 100 +++++++ bindings/python/README.md | 5 + bindings/python/python/auths/gateway.py | 72 +++-- bindings/python/tests/test_gateway_client.py | 27 +- bindings/typescript/README.md | 5 + bindings/typescript/src/gateway.ts | 64 ++++- .../test/unit/gateway-client.test.js | 24 +- compliance.toml | 8 +- docs/plans/0074-implementation-status.md | 58 +++++ ...ound-effects-and-recovery-state-machine.md | 13 + .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/admin_boundary_tests.rs | 7 +- product/runtime/auths-gateway/src/engine.rs | 81 ++++-- product/runtime/auths-gateway/src/lib.rs | 3 +- .../src/native_public_evidence_tests.rs | 245 ++++++++++++++++++ .../src/native_recovery_actor_tests.rs | 2 + .../auths-gateway/src/scenario_tests.rs | 28 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 67 ++++- release/semantic-freeze-versions.toml | 12 +- release/semantic-freeze.json | 22 +- 23 files changed, 847 insertions(+), 102 deletions(-) create mode 100644 bindings/fixtures/gateway/native-public-mutation-evidence-file.json create mode 100644 bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json create mode 100644 product/runtime/auths-gateway/src/native_public_evidence_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 4a2df91a7..b393ab507 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -96,6 +96,8 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::limits_tests::postgres_native_recovery_limits_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::history_tests::native_file_recovery_history_fixture_is_current cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::history_tests::postgres_native_recovery_history_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::privacy_tests::native_file_public_mutation_evidence_fixture_is_current + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::privacy_tests::postgres_native_public_mutation_evidence_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres } 2>&1 | tee target/ap074-native-adapter-evidence.log - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-file.json b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json new file mode 100644 index 000000000..f8177fb97 --- /dev/null +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json @@ -0,0 +1,100 @@ +{ + "schema": "auths.native-public-mutation-evidence/1", + "adapter": "file", + "scope": "native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", + "excluded": [ + "signed outcome/pre-entry observation projection hardening", + "live provider and hostile OS qualification" + ], + "public_result": { + "outcome": "observed-by-provider", + "status": null, + "evidence": { + "schema": "auths.gateway-public-evidence/1", + "channel": "read-back", + "evidence_commitment": "native-scoped-hiding-value-checked", + "observed_at": 1790000001 + } + }, + "wire_cases": [ + { + "case": "valid", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "obsolete-schema", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/0\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "short-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"00\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "uppercase-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "newline-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\\n\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "numeric-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":42,\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "private-echo", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000,\"echo\":\"auths-e1-private-canary\"}}", + "accepted": false + }, + { + "case": "raw-digest", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000,\"evidence_digest\":\"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd\"}}", + "accepted": false + }, + { + "case": "unsafe-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":9007199254740992}}", + "accepted": false + }, + { + "case": "boolean-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":true}}", + "accepted": false + }, + { + "case": "negative-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":-1}}", + "accepted": false + }, + { + "case": "duplicate-schema", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "fractional-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1.0}}", + "accepted": false + }, + { + "case": "exponent-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1e0}}", + "accepted": false + }, + { + "case": "bom", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + } + ], + "same_private_bytes_have_distinct_record_scoped_commitments": true, + "reopen_and_replay_preserve_commitment_without_io": true, + "private_complete_evidence_and_original_binding_preserved": true, + "public_and_debug_exclude_raw_body_digest_echo_and_action_digest": true +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json new file mode 100644 index 000000000..5b0646405 --- /dev/null +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json @@ -0,0 +1,100 @@ +{ + "schema": "auths.native-public-mutation-evidence/1", + "adapter": "postgres", + "scope": "native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", + "excluded": [ + "signed outcome/pre-entry observation projection hardening", + "live provider and hostile OS qualification" + ], + "public_result": { + "outcome": "observed-by-provider", + "status": null, + "evidence": { + "schema": "auths.gateway-public-evidence/1", + "channel": "read-back", + "evidence_commitment": "native-scoped-hiding-value-checked", + "observed_at": 1790000001 + } + }, + "wire_cases": [ + { + "case": "valid", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "obsolete-schema", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/0\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "short-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"00\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "uppercase-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "newline-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\\n\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "numeric-commitment", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":42,\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "private-echo", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000,\"echo\":\"auths-e1-private-canary\"}}", + "accepted": false + }, + { + "case": "raw-digest", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000,\"evidence_digest\":\"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd\"}}", + "accepted": false + }, + { + "case": "unsafe-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":9007199254740992}}", + "accepted": false + }, + { + "case": "boolean-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":true}}", + "accepted": false + }, + { + "case": "negative-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":-1}}", + "accepted": false + }, + { + "case": "duplicate-schema", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "fractional-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1.0}}", + "accepted": false + }, + { + "case": "exponent-time", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1e0}}", + "accepted": false + }, + { + "case": "bom", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + } + ], + "same_private_bytes_have_distinct_record_scoped_commitments": true, + "reopen_and_replay_preserve_commitment_without_io": true, + "private_complete_evidence_and_original_binding_preserved": true, + "public_and_debug_exclude_raw_body_digest_echo_and_action_digest": true +} \ No newline at end of file diff --git a/bindings/python/README.md b/bindings/python/README.md index 6a4eac8a1..a83a1c590 100644 --- a/bindings/python/README.md +++ b/bindings/python/README.md @@ -53,6 +53,11 @@ selected response receipt time, escalation and proposed next actions. Requesting another observation requires fresh independent authorization and exact approval. The report grants no retry, redelivery or refund authority. +Mutation `observed-by-provider` results use `auths.gateway-public-evidence/1`. +They expose a native record-scoped hiding commitment and receipt time; raw +response digests and echo tokens stay in the protected journal. Older evidence +shapes are rejected. Bindings validate the shape and never compute the commitment. + The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, approvals from any two of three managers, gateway submission, and an offline audit. diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index 1a9d2b38f..893366a89 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -32,7 +32,6 @@ _MAX_ACTION_BYTES = 64 * 1024 # Room for four maximal pre-entry observations in one base64url response. _MAX_RESPONSE_BYTES = 32 * 1024 -_ECHO = re.compile(r"auths-e1-[0-9a-f]{64}") _DIGEST = re.compile(r"[0-9a-f]{64}") _OPERATION_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}") _BASE64URL = re.compile(r"[A-Za-z0-9_-]*") @@ -134,14 +133,14 @@ class GatewayObserved: class GatewayProviderEvidence: """Secret-free summary of provider-held read-back evidence. - The response bytes and observation locator stay in the operator's attempt - store. ``observed_at`` is gateway wall-clock seconds and is not - authenticated. + The response bytes, raw digest and echo stay in the protected journal. + ``evidence_commitment`` is a native scoped hiding commitment, not a body + hash. ``observed_at`` is gateway wall-clock seconds and is not authenticated. """ channel: Literal["read-back"] - echo: str - evidence_digest: str + schema: Literal["auths.gateway-public-evidence/1"] + evidence_commitment: str observed_at: int @@ -185,28 +184,59 @@ def _parse_evidence(value: object) -> GatewayProviderEvidence: raise GatewayProtocolError("gateway returned invalid evidence") evidence = cast(Mapping[str, object], value) channel = evidence.get("channel") - echo = evidence.get("echo") - digest = evidence.get("evidence_digest") + schema = evidence.get("schema") + commitment = evidence.get("evidence_commitment") observed_at = evidence.get("observed_at") if ( - set(evidence) != {"channel", "echo", "evidence_digest", "observed_at"} + set(evidence) != {"schema", "channel", "evidence_commitment", "observed_at"} or channel != "read-back" - or not isinstance(echo, str) - or _ECHO.fullmatch(echo) is None - or not isinstance(digest, str) - or _DIGEST.fullmatch(digest) is None + or schema != "auths.gateway-public-evidence/1" + or not isinstance(commitment, str) + or _DIGEST.fullmatch(commitment) is None or not isinstance(observed_at, int) or isinstance(observed_at, bool) - or not 0 <= observed_at <= _MAX_U64 + or not 0 <= observed_at <= (1 << 53) - 1 ): raise GatewayProtocolError("gateway returned invalid evidence") - return GatewayProviderEvidence("read-back", echo, digest, observed_at) + return GatewayProviderEvidence("read-back", "auths.gateway-public-evidence/1", commitment, observed_at) + + +def _result_integer(value: str) -> int: + if value.startswith("-") or len(value) > 20: + raise ValueError("negative gateway result integer") + return int(value) + + +def _result_float(_value: str) -> object: + raise ValueError("gateway result number is not an integer") + + +def _gateway_json(raw: bytes) -> object: + if raw.startswith(b"\xef\xbb\xbf"): + raise ValueError("gateway JSON BOM") + return cast(object, json.loads(raw.decode("utf-8"), + object_pairs_hook=_unique_result_object, + parse_int=_result_integer, parse_float=_result_float)) + + +def _unique_result_object(pairs: list[tuple[str, object]]) -> dict[str, object]: + if len(pairs) > 16: + raise ValueError("oversized gateway result object") + result: dict[str, object] = {} + for key, value in pairs: + if key in result: + raise ValueError("duplicate gateway result member") + key.encode("utf-8") + if isinstance(value, str): + value.encode("utf-8") + result[key] = value + return result def _parse_result(raw: bytes) -> GatewayResult: try: - decoded: object = json.loads(raw) - except (UnicodeDecodeError, ValueError) as error: + decoded: object = _gateway_json(raw) + except (UnicodeError, ValueError, RecursionError) as error: raise GatewayProtocolError("gateway returned invalid JSON") from error if not isinstance(decoded, dict): raise GatewayProtocolError("gateway returned invalid result") @@ -334,8 +364,8 @@ def _parse_observe_result( raw: bytes, schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/2"] ) -> GatewayObserveResult: try: - decoded: object = json.loads(raw) - except (UnicodeDecodeError, ValueError) as error: + decoded: object = _gateway_json(raw) + except (UnicodeError, ValueError, RecursionError) as error: raise GatewayProtocolError("gateway returned invalid JSON") from error if not isinstance(decoded, dict): raise GatewayProtocolError("gateway returned invalid observation result") @@ -390,8 +420,8 @@ def _parse_refusal(value: Mapping[str, object]) -> GatewayObservationRefused: def _parse_pre_entry_result(raw: bytes, operation_id: str) -> GatewayPreEntryResult: try: - decoded: object = json.loads(raw) - except (UnicodeDecodeError, ValueError) as error: + decoded: object = _gateway_json(raw) + except (UnicodeError, ValueError, RecursionError) as error: raise GatewayProtocolError("gateway returned invalid JSON") from error if not isinstance(decoded, dict): raise GatewayProtocolError("gateway returned invalid pre-entry result") diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index ea0285ba2..dad22ba80 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -55,8 +55,8 @@ def socket_dir() -> Iterator[Path]: def _provider_result(status: object = 200, **evidence: object) -> bytes: body = { "channel": "read-back", - "echo": _ECHO, - "evidence_digest": _DIGEST, + "schema": "auths.gateway-public-evidence/1", + "evidence_commitment": _DIGEST, "observed_at": 1_790_000_000, } body.update(evidence) @@ -145,10 +145,25 @@ def test_result_parser_does_not_infer_effect() -> None: _parse_result(hostile) +def test_result_parser_matches_native_public_evidence_corpus() -> None: + from auths.gateway import _parse_result + + fixture = Path(__file__).resolve().parents[2] / "fixtures/gateway/native-public-mutation-evidence-file.json" + corpus = json.loads(fixture.read_text()) + for case in corpus["wire_cases"]: + if case["accepted"]: + result = _parse_result(case["response"].encode()) + assert isinstance(result, GatewayObservedByProvider) + assert result.evidence.schema == "auths.gateway-public-evidence/1" + else: + with pytest.raises(GatewayProtocolError): + _parse_result(case["response"].encode()) + + def test_result_parser_exposes_observed_by_provider_without_evidence_bytes() -> None: from auths.gateway import _parse_result - evidence = GatewayProviderEvidence("read-back", _ECHO, _DIGEST, 1_790_000_000) + evidence = GatewayProviderEvidence("read-back", "auths.gateway-public-evidence/1", _DIGEST, 1_790_000_000) assert _parse_result(_provider_result()) == GatewayObservedByProvider(200, evidence) assert _parse_result(_provider_result(None)) == GatewayObservedByProvider( None, evidence @@ -159,7 +174,11 @@ def test_result_parser_exposes_observed_by_provider_without_evidence_bytes() -> _provider_result(channel="webhook"), _provider_result(echo="auths-e1-app-supplied"), _provider_result(echo=_ECHO.upper()), - _provider_result(evidence_digest="00"), + _provider_result(evidence_commitment="00"), + _provider_result(evidence_commitment=_DIGEST + "\n"), + _provider_result(observed_at=1 << 53), + _provider_result(schema="auths.gateway-public-evidence/0"), + _provider_result(evidence_digest=_DIGEST), _provider_result(observed_at=-1), _provider_result(observed_at=True), _provider_result(evidence_b64="e30"), diff --git a/bindings/typescript/README.md b/bindings/typescript/README.md index c1dc268ae..69665021b 100644 --- a/bindings/typescript/README.md +++ b/bindings/typescript/README.md @@ -54,6 +54,11 @@ selected response receipt time, escalation and proposed next actions. Requesting another observation requires fresh independent authorization and exact approval. The report grants no retry, redelivery or refund authority. +Mutation `observed-by-provider` results use `auths.gateway-public-evidence/1`. +They expose a native record-scoped hiding commitment and receipt time; raw +response digests and echo tokens stay in the protected journal. Older evidence +shapes are rejected. Bindings validate the shape and never compute the commitment. + The [Stripe refund example](../../examples/stripe-refund-approval/README.md) runs the whole journey: a grant with limits, a 2-of-3 approval quorum, gateway submission, and an offline audit. diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index a0208f404..a7ab9bfe2 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -25,7 +25,6 @@ const MAX_FRAME_BYTES = 8 * 1024 * 1024; const SUN_PATH_BYTES = platform() === "linux" ? 108 : 104; const MAX_SOCKET_PATH_BYTES = SUN_PATH_BYTES - 1; const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; -const ECHO = /^auths-e1-[0-9a-f]{64}$/; const DIGEST = /^[0-9a-f]{64}$/; const OPERATION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/; const BASE64URL = /^[A-Za-z0-9_-]*$/; @@ -65,14 +64,15 @@ export class GatewayEndpoint { } /** - * Secret-free summary of provider-held read-back evidence. The response bytes and - * observation locator stay in the operator's attempt store; `observedAt` is gateway + * Public hiding summary of provider-held read-back evidence. Raw response bytes, + * digest and echo stay in the protected journal; `evidenceCommitment` is a native + * scoped HMAC, never a raw body hash; `observedAt` is gateway * wall-clock seconds and is not authenticated. */ export type GatewayProviderEvidence = Readonly<{ channel: "read-back"; - echo: string; - evidenceDigest: string; + schema: "auths.gateway-public-evidence/1"; + evidenceCommitment: string; observedAt: number; }>; @@ -194,23 +194,61 @@ function parseEvidence(value: unknown): GatewayProviderEvidence { throw new GatewayProtocolError("gateway returned invalid evidence"); } const evidence = value as Record; - const { channel, echo, evidence_digest: digest, observed_at: observedAt } = evidence; + const { schema, channel, evidence_commitment: commitment, observed_at: observedAt } = evidence; if ( - !exactKeys(evidence, ["channel", "echo", "evidence_digest", "observed_at"]) + !exactKeys(evidence, ["schema", "channel", "evidence_commitment", "observed_at"]) || channel !== "read-back" - || typeof echo !== "string" || !ECHO.test(echo) - || typeof digest !== "string" || !DIGEST.test(digest) + || schema !== "auths.gateway-public-evidence/1" + || typeof commitment !== "string" || commitment.length !== 64 || !DIGEST.test(commitment) || typeof observedAt !== "number" || !Number.isSafeInteger(observedAt) || observedAt < 0 ) { throw new GatewayProtocolError("gateway returned invalid evidence"); } - return { channel, echo, evidenceDigest: digest, observedAt }; + return { schema, channel, evidenceCommitment: commitment, observedAt }; +} + +// Wire validation only: native owners still decide every authorization and stage. +function parseGatewayJson(bytes: Uint8Array): unknown { + if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) throw new TypeError("gateway JSON BOM"); + const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes); + const stack: Array<{ keys: Set; key: boolean } | null> = []; + for (const match of text.matchAll(/"(?:\\[\s\S]|[^"\\])*"|-?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?|[{}\[\],:]/gu)) { + const token = match[0]; + if (token === "{" || token === "[") { + if (stack.length >= 128) throw new TypeError("gateway JSON depth"); + stack.push(token === "{" ? { keys: new Set(), key: true } : null); + } else if (token === "}" || token === "]") { + stack.pop(); + } else if (token === ":" || token === ",") { + const object = stack[stack.length - 1]; + if (object) object.key = token === ","; + } else if (!token.startsWith('"')) { + if (!/^(?:0|[1-9][0-9]*)$/u.test(token)) throw new TypeError("gateway JSON integer"); + } else { + const value = JSON.parse(token) as string; + for (let index = 0; index < value.length; index++) { + const code = value.charCodeAt(index); + if (code >= 0xd800 && code <= 0xdbff) { + const next = value.charCodeAt(++index); + if (!(next >= 0xdc00 && next <= 0xdfff)) throw new TypeError("gateway JSON Unicode"); + } else if (code >= 0xdc00 && code <= 0xdfff) { + throw new TypeError("gateway JSON Unicode"); + } + } + const object = stack[stack.length - 1]; + if (object?.key) { + if (object.keys.size >= 16 || object.keys.has(value)) throw new TypeError("gateway JSON duplicate or oversized object"); + object.keys.add(value); + } + } + } + return JSON.parse(text) as unknown; } function parseResult(bytes: Uint8Array): GatewayResult { let decoded: unknown; try { - decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)); + decoded = parseGatewayJson(bytes); } catch { throw new GatewayProtocolError("gateway returned invalid JSON"); } @@ -259,7 +297,7 @@ function parseResult(bytes: Uint8Array): GatewayResult { function parseObserveResult(bytes: Uint8Array, schema: ObservationSchema): GatewayObserveResult { let decoded: unknown; try { - decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)); + decoded = parseGatewayJson(bytes); } catch { throw new GatewayProtocolError("gateway returned invalid JSON"); } @@ -304,7 +342,7 @@ function parseRefusal(value: Record): Readonly<{ outcome: "refu function parsePreEntryResult(bytes: Uint8Array, operationId: string): GatewayPreEntryResult { let decoded: unknown; try { - decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)); + decoded = parseGatewayJson(bytes); } catch { throw new GatewayProtocolError("gateway returned invalid JSON"); } diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index be080d27b..d4d3de877 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -119,12 +119,26 @@ function providerResult(status = 200, evidence = {}) { return JSON.stringify({ outcome: "observed-by-provider", status, - evidence: { channel: "read-back", echo: ECHO, evidence_digest: DIGEST, observed_at: 1790000000, ...evidence }, + evidence: { schema: "auths.gateway-public-evidence/1", channel: "read-back", evidence_commitment: DIGEST, observed_at: 1790000000, ...evidence }, }); } +test("gateway public evidence matches the native corpus", { skip: process.platform === "win32" }, async () => { + const path = new URL("../../../fixtures/gateway/native-public-mutation-evidence-file.json", import.meta.url); + const corpus = JSON.parse(await readFile(path, "utf8")); + for (const item of corpus.wire_cases) { + if (item.accepted) { + const result = await replyOnce(item.response); + assert.equal(result.outcome, "observed-by-provider"); + assert.equal(result.evidence.schema, "auths.gateway-public-evidence/1"); + } else { + await assert.rejects(replyOnce(item.response), GatewayProtocolError, item.case); + } + } +}); + test("gateway client exposes observed-by-provider without evidence bytes", { skip: process.platform === "win32" }, async () => { - const evidence = { channel: "read-back", echo: ECHO, evidenceDigest: DIGEST, observedAt: 1790000000 }; + const evidence = { schema: "auths.gateway-public-evidence/1", channel: "read-back", evidenceCommitment: DIGEST, observedAt: 1790000000 }; assert.deepEqual(await replyOnce(providerResult()), { outcome: "observed-by-provider", status: 200, evidence }); assert.deepEqual(await replyOnce(providerResult(null)), { outcome: "observed-by-provider", status: null, evidence }); for (const hostile of [ @@ -133,7 +147,11 @@ test("gateway client exposes observed-by-provider without evidence bytes", { ski providerResult(200, { channel: "webhook" }), providerResult(200, { echo: "auths-e1-app-supplied" }), providerResult(200, { echo: ECHO.toUpperCase() }), - providerResult(200, { evidence_digest: "00" }), + providerResult(200, { evidence_commitment: "00" }), + providerResult(200, { evidence_commitment: DIGEST + "\n" }), + providerResult(200, { observed_at: 2 ** 53 }), + providerResult(200, { schema: "auths.gateway-public-evidence/0" }), + providerResult(200, { evidence_digest: DIGEST }), providerResult(200, { observed_at: -1 }), providerResult(200, { evidence_b64: "e30" }), '{"outcome":"observed-by-provider","status":200}', diff --git a/compliance.toml b/compliance.toml index 7ca67ae29..f7ba2e8fe 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1641,7 +1641,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/2", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/2", "auths.gateway-public-evidence/1", "auths.gateway-public-commitment/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1829,10 +1829,12 @@ stateful-replay-budget-component = [ "product/runtime/auths-gateway/src/native_recovery_limits_tests.rs#postgres_native_recovery_limits_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#native_file_recovery_history_fixture_is_current", "product/runtime/auths-gateway/src/native_recovery_history_tests.rs#postgres_native_recovery_history_fixture_is_current", + "product/runtime/auths-gateway/src/native_public_evidence_tests.rs#native_file_public_mutation_evidence_fixture_is_current", + "product/runtime/auths-gateway/src/native_public_evidence_tests.rs#postgres_native_public_mutation_evidence_fixture_is_current", "product/runtime/auths-gateway/src/admin_boundary_tests.rs#admin_request_boundary_fixture_is_current", "product/runtime/auths-gateway/src/bin/auths-gateway.rs#managed_cli_inventory_fixture_is_current", - "product/runtime/auths-gateway/tests/content_interface_tests.rs#native_managed_interface_fixture_is_current", - "product/runtime/auths-gateway/tests/content_interface_tests.rs#distinct_uid_managed_interface_evidence", + "product/runtime/auths-gateway/tests/content_journey/interface_tests.rs#native_managed_interface_fixture_is_current", + "product/runtime/auths-gateway/tests/content_journey/interface_tests.rs#distinct_uid_managed_interface_evidence", "product/runtime/auths-gateway/src/native_budget_tests.rs#native_file_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_budget_tests.rs#postgres_native_window_capacity_fixture_is_current", "product/runtime/auths-gateway/src/native_mutation_budget_tests.rs#native_file_mutation_window_capacity_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 63896f2ea..2720fb3de 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3662,3 +3662,61 @@ or deployment claim is made by AP074 source work. 424 updates identity 167, public SDK 164 and public surface 424, the only changed subjects required by the generator. No complete acceptance row or new hosted/Linux result is claimed from these construction checks. + +## Public mutation evidence hiding checkpoint + +- `GatewayEvidenceSummary` now uses `auths.gateway-public-evidence/1`, exposing + channel, a native record-scoped hiding commitment and the original receipt + time. The result no longer exposes the action-derived echo or raw response + digest. The protected journal retains full evidence, digest, attribution, + immutable binding, grant and all charges. No record schema or reducer edge + changed, and persisted facts still cannot construct an entry permit. +- The sole journal owner computes HMAC-SHA256 using the existing private immutable + 128-bit attempt nonce, a versioned domain, length-framed exact canonical + binding, a closed field label and the raw digest. Temporary decoded key bytes + are zeroized. Bindings receive this value and never compute it. Snapshot and + provider-evidence Debug now redact private locators, echoes and commitments. +- Native file/TLS PostgreSQL constructors perform real native writes and separately + approved reads whose responses contain a private sentinel. Original-writer + replay after withdrawal returns the public hiding summary; reopening preserves + it without I/O. Two records with identical private response bytes have distinct + public commitments. Raw evidence remains complete, original source fields stay + fixed, and public/debug output excludes plaintext, encoded values and raw + evidence/action digests. Final constructors passed, each 1 passed / 0 ignored: + file 0.70 s, TLS PostgreSQL 0.90 s. +- Python and TypeScript cut over directly to the new schema. Both reject old + evidence members, unsupported schemas, malformed commitments, unsafe times, + duplicate object members, non-integer number spellings and non-UTF8/BOM JSON. + Data parsing grants no authority. Fifteen native wire vectors are consumed by + both binding suites; those suites await hosted execution. The explicit native + adapter inventory increases from 46 to 48 selectors. +- Integrated the CI subagent repair as `09838a19` from `1f731115`: scope the + permissive admin inode to untrusted probes, restore owner-only modes before + trusted controls, require acknowledged within the existing bounded wait, move + the included module below tests/content_journey to prevent Cargo auto-discovery, + and fix related strict lints without allowances. Compliance paths follow the + module move. The subagent reports actual Linux UID65534 execution passed with + all 32 app cases, 11 admin refusals, 52 help routes, 4 private CLI refusals and + 36/40 private-file probes; main did not inspect CI. Combined-head hosted + verification remains required. + +- Gateway source closure is `9f470c3eed04ddaf76e41bfb9a3565fc73ef75db51578c9b14a2bd9e04744824`; construction and rebuilt check passed. Semantic freeze 425 updates identity 168, portable ABI 127, public SDK 165, vocabulary 29 and public surface 425. The required metadata constructor completed successfully. Hosted checks remain the CI agent’s responsibility. + +### Next mandatory privacy cutover + +- Signed outcomes and public pre-entry observations still expose private facts; + this checkpoint does not close A17 or the entire specification. +- Replace the public signed outcome with a new schema containing a stable hiding + effect reference, stage/status/time/recipe facts and a hiding commitment to the + exact complete journal record. The seal must cover entry/fence/authority and + accounting metadata, not just the legacy OutcomeRecord fields. Exclude the + private nonce from the sealed message while using it as the MAC key. +- Private audit must use an operator-only atomic signed-outcome plus canonical + journal-record opening. Its decoder must be the existing journal owner, check + exact proof/action commitments and scope, and compare the public seal; retain + every existing private outcome presence, counter, pre-entry and basis check. + Do not weaken audit binding or expose the opening on the application socket. +- Public pre-entry results must contain redacted count/hiding metadata rather + than raw signed observations. Private audit obtains those bytes from the + protected journal opening. Cut over native vectors, bindings, demos/templates + and private audit schema directly; no legacy or dual-schema runtime readers. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index f93af4db2..30fe444e2 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -876,6 +876,19 @@ hostile OS/provider qualification remain separate requirements. A provider-derived locator is not authority. If a later action depends on a response-derived resource, establish its provenance under the declared observation contract and compile a new bound effect linked to that evidence. Do not mutate an already approved effect. This requirement does not expand scope into a full create/populate product workflow. +Public mutation replay evidence now uses `auths.gateway-public-evidence/1`: +channel, a hiding `evidence_commitment`, and the original bounded receipt time. +This result projection contains neither raw provider evidence SHA-256 nor the +action-derived echo. +The journal owner computes HMAC-SHA256 under its existing private immutable +128-bit attempt nonce, with domain `auths.gateway-public-commitment/1`, a NUL, +u32 big-endian length plus canonical binding bytes, u32 big-endian label length +plus the `provider-evidence` label, and the private 32-byte evidence digest. +This scopes the hiding commitment to every immutable binding dimension and the +private record. Replay/reopen retain the same value; different records hide +equality of identical private response bytes. Raw evidence and its digest remain +protected journal/audit facts. This projection grants no execution authority. + ### 4.4 Stage types and serialization The intended progression is: diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 8a3cda777..afe2cdd52 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"36eac58922ab82bd2700f401ece251c234ee825077e61544840e86cbceee0613"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"00fe8b9cbabfee5e18333dc2012d669b7456c20fee59d4914a8ccb4e73526606"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"ef028c2f3a3b3e730be51b52b9e252a8426162ffc540658afd54dbfb25a3dfb8"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"606f6ffe0bcea6ae7dc81f420938fc65943fb1a44b5e5e67b0e9a31493cb833a"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"fccaeb205f3c31934de966f6d03a9046cef6512205c200ba4db93b1e284a16c3"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"ed30817d35d73e23e6701c5360c3c0e03751fc6e9d6a8f5ae8b7779b2f84b540"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"c2b043471d425aff45375540e631d136b81bc18784f4224ca968b63e1d359b81"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"82ce208eb11f6195047c4ba05448816b877dab8a791ee1b8142ca68f830fb0bf"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"92056fb13bc2ff9096defc0a94306ff8b7b275f8eee4cb4b1feca0d90dda6fa9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"19bc24e7c311db2290cfaee514baf0974ca7af66582b1b7734666cdea13aa6a4"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"e28be7ff0dd86e80e0072c4ea08c893bc5b02a257ad39b0e4f4c5a21bdedc5ec"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/admin_boundary_tests.rs b/product/runtime/auths-gateway/src/admin_boundary_tests.rs index 465ddcf91..25a8c585f 100644 --- a/product/runtime/auths-gateway/src/admin_boundary_tests.rs +++ b/product/runtime/auths-gateway/src/admin_boundary_tests.rs @@ -110,12 +110,7 @@ fn admin_request_boundary_fixture_is_current() { boundary.resize(MAX_ADMIN_REQUEST_BYTES, b' '); record(&mut cases, "byte-limit", boundary.clone(), true); boundary.push(b' '); - record( - &mut cases, - "byte-limit-plus-one", - boundary, - false, - ); + record(&mut cases, "byte-limit-plus-one", boundary, false); tokio::runtime::Runtime::new() .expect("runtime") .block_on(async { diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index d98515698..6041b7139 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -27,7 +27,7 @@ use crate::{ }; use crate::{ ClosedProviderRequest, CompiledRecipe, GatewayAttempts, GatewayConnectionDescriptor, - GatewayEvidenceChannel, GatewayProviderEvidence, + GatewayEvidenceChannel, }; use auths_connections::{ ConnectionAlias, ConnectionCredentialStore, ConnectionProfile, ConnectionRecord, @@ -128,21 +128,62 @@ fn decode_journal_revision<'de, D: serde::Deserializer<'de>>( Ok(revision) } -/// Secret-free summary of stored provider evidence. The response bytes and -/// the observation locator stay in the operator's attempt store. +/// Schema of the public hiding evidence projection; never a private body hash. +pub const PUBLIC_EVIDENCE_SCHEMA: &str = "auths.gateway-public-evidence/1"; + +/// Public hiding summary of stored provider evidence. Response bytes, raw +/// digests, echo and locator stay in the protected attempt journal. #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct GatewayEvidenceSummary { + /// Exactly `auths.gateway-public-evidence/1`. + #[serde(deserialize_with = "decode_evidence_schema")] + pub schema: String, /// Evidence channel; `read-back` in this version. pub channel: GatewayEvidenceChannel, - /// The echo token found in the provider record. - pub echo: String, - /// Lowercase hexadecimal SHA-256 of the exact observation response bytes. - pub evidence_digest: String, + /// Lowercase HMAC-SHA256 under the private immutable attempt nonce and + /// canonical binding. Stable on replay, never a raw content digest. + #[serde(deserialize_with = "decode_evidence_commitment")] + pub evidence_commitment: String, /// Gateway wall-clock seconds; not authenticated. + #[serde(deserialize_with = "decode_evidence_time")] pub observed_at: u64, } +fn decode_evidence_time<'de, D: serde::Deserializer<'de>>(decoder: D) -> Result { + let value = u64::deserialize(decoder)?; + if value > (1_u64 << 53) - 1 { + return Err(serde::de::Error::custom("invalid public evidence time")); + } + Ok(value) +} + +fn decode_evidence_schema<'de, D: serde::Deserializer<'de>>( + decoder: D, +) -> Result { + let value = String::deserialize(decoder)?; + if value != PUBLIC_EVIDENCE_SCHEMA { + return Err(serde::de::Error::custom("invalid public evidence schema")); + } + Ok(value) +} + +fn decode_evidence_commitment<'de, D: serde::Deserializer<'de>>( + decoder: D, +) -> Result { + let value = String::deserialize(decoder)?; + if value.len() != 64 + || !value + .bytes() + .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) + { + return Err(serde::de::Error::custom( + "invalid public evidence commitment", + )); + } + Ok(value) +} + /// A verified submission's bounded, credential-free request projection for /// offline operator review and differential qualification. It grants no /// execution authority and records no claim, lease, provider entry or receipt. @@ -233,14 +274,15 @@ pub(crate) fn review_command( }) } -impl From<&GatewayProviderEvidence> for GatewayEvidenceSummary { - fn from(evidence: &GatewayProviderEvidence) -> Self { - Self { +impl GatewayEvidenceSummary { + pub(crate) fn from_snapshot(snapshot: &crate::GatewayAttemptSnapshot) -> Option { + let evidence = snapshot.provider_evidence()?; + Some(Self { + schema: PUBLIC_EVIDENCE_SCHEMA.to_owned(), channel: evidence.channel(), - echo: evidence.echo().to_owned(), - evidence_digest: hex::encode(evidence.evidence_digest()), + evidence_commitment: hex::encode(snapshot.public_evidence_commitment()?), observed_at: evidence.observed_at(), - } + }) } } @@ -2471,13 +2513,12 @@ pub(crate) fn stored_result(snapshot: &crate::GatewayAttemptSnapshot) -> Gateway status, matched: snapshot.observation_match().unwrap_or(false), }, - (Stage::ObservedByProvider, status) => match snapshot.provider_evidence() { - Some(evidence) => GatewaySubmitResult::ObservedByProvider { - status, - evidence: evidence.into(), - }, - None => GatewaySubmitResult::Unknown, - }, + (Stage::ObservedByProvider, status) => { + match GatewayEvidenceSummary::from_snapshot(snapshot) { + Some(evidence) => GatewaySubmitResult::ObservedByProvider { status, evidence }, + None => GatewaySubmitResult::Unknown, + } + } _ => GatewaySubmitResult::Unknown, } } diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 46664f6ba..fe34dbee6 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -97,7 +97,8 @@ pub use echo_verify::{ pub use engine::{ GatewayAdminOutcome, GatewayAdminStatus, GatewayEngine, GatewayEngineConfigurationError, GatewayEvidenceSummary, GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult, - SLOT_SWEEP_INTERVAL_SECONDS, SLOT_SWEEP_LIMIT, gateway_verifier_configuration, + PUBLIC_EVIDENCE_SCHEMA, SLOT_SWEEP_INTERVAL_SECONDS, SLOT_SWEEP_LIMIT, + gateway_verifier_configuration, }; pub use generation_floor::GenerationFloor; pub use observer::{ diff --git a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs new file mode 100644 index 000000000..95b80d7f7 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs @@ -0,0 +1,245 @@ +//! Native public mutation projection; protected evidence stays in the journal. +use super::*; +use sha2::{Digest as _, Sha256}; + +const CONTENT: &[u8] = b"private-mutation-evidence-canary"; + +fn private_values_absent(bytes: &[u8], values: &[&[u8]]) { + use base64ct::{Base64, Base64UrlUnpadded, Encoding as _}; + for value in values { + for encoded in [ + value.to_vec(), + hex::encode(value).into_bytes(), + Base64::encode_string(value).into_bytes(), + Base64UrlUnpadded::encode_string(value).into_bytes(), + ] { + assert!( + !bytes.windows(encoded.len()).any(|window| window == encoded), + "private evidence reached a public projection" + ); + } + } +} + +#[allow( + clippy::too_many_lines, + reason = "one native read/replay history proves the protected/public evidence boundary" +)] +fn history(backend: Backend) -> (Value, Vec, String) { + let case = Case::start(backend, Outcome::LostEcho); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "privacy-reader", + case.store.reopen(), + controls(true), + )); + engine + .activate_effect_configuration( + engine + .effect_configuration_revision() + .expect("operator revision"), + ) + .expect("withdraw writer"); + let mut response: Value = + serde_json::from_slice(&case.provider.requests.lock().expect("request")[0].body) + .expect("actual write body"); + response["private_note"] = json!(std::str::from_utf8(CONTENT).expect("fixture")); + let echo = response["fields"]["auths_echo"] + .as_str() + .expect("native echo") + .to_owned(); + let body = serde_json::to_vec(&response).expect("body"); + *case.provider.read_response.lock().expect("response") = Some(ReadResponse { + status: 200, + declared_length: body.len(), + body: body.clone(), + }); + let call = runtime + .block_on(engine.recovery_authorization_call(SOURCE, RECOVERY)) + .expect("read call"); + let signed = author::signed(&call, true); + let effect = runtime + .block_on(engine.compile_recovery_effect(SOURCE, &signed.proof, &signed.action)) + .expect("native read"); + let approval = author::approval(&effect, NOW + 1); + let recovered = runtime + .block_on(Box::pin(engine.recover( + SOURCE, + &signed.proof, + &signed.action, + approval, + ))) + .expect("record exact evidence"); + let evidence = recovered + .source + .provider_evidence() + .expect("protected evidence"); + assert!(evidence.evidence() == body); + let digest: [u8; 32] = Sha256::digest(&body).into(); + assert!(evidence.evidence_digest() == &digest); + let original: Value = serde_json::from_slice(&case.original).expect("source"); + let action = hex::decode( + original["action_commitment"] + .as_str() + .expect("action digest"), + ) + .expect("digest"); + let (proof, action_bytes, approval) = input(&case.setup.installation.root, SOURCE); + let first = runtime.block_on(engine.submit(&proof, &action_bytes, approval.clone())); + let public = serde_json::to_vec(&first).expect("public mutation result"); + private_values_absent( + &public, + &[CONTENT, &body, &digest, &action, echo.as_bytes()], + ); + private_values_absent( + format!("{:?}", recovered.source).as_bytes(), + &[CONTENT, &digest, &action, echo.as_bytes()], + ); + private_values_absent( + format!("{evidence:?}").as_bytes(), + &[CONTENT, &digest, echo.as_bytes()], + ); + let mut value: Value = serde_json::from_slice(&public).expect("public JSON"); + assert_eq!(value["outcome"], "observed-by-provider"); + assert_eq!( + value["evidence"]["schema"], + "auths.gateway-public-evidence/1" + ); + let commitment = value["evidence"]["evidence_commitment"] + .as_str() + .expect("commitment") + .to_owned(); + assert_eq!(commitment.len(), 64); + assert_ne!(commitment, hex::encode(digest)); + assert!(value["evidence"].get("echo").is_none()); + assert!(value["evidence"].get("evidence_digest").is_none()); + let witness = engine.execution_witness(); + let (reopened, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "privacy-reopened", + case.store.reopen(), + controls(true), + )); + assert_eq!( + runtime.block_on(reopened.submit(&proof, &action_bytes, approval)), + first + ); + assert_eq!(reopened.execution_witness().credential_lease_calls, 0); + assert_eq!(engine.execution_witness(), witness); + assert_eq!(case.provider.requests.lock().expect("requests").len(), 2); + assert_fixed_source(&case.original, &record(&case.store, SOURCE)); + for invalid in ["auths.gateway-public-evidence/0", "unsupported"] { + let mut bad = value.clone(); + bad["evidence"]["schema"] = json!(invalid); + assert!(serde_json::from_value::(bad).is_err()); + } + let mut legacy = value.clone(); + legacy["evidence"]["echo"] = json!(&echo); + assert!(serde_json::from_value::(legacy).is_err()); + value["evidence"]["evidence_commitment"] = json!("native-scoped-hiding-value-checked"); + (value, body, commitment) +} +fn wire_cases() -> Value { + let valid = json!({"outcome":"observed-by-provider","status":200, + "evidence":{"schema":crate::PUBLIC_EVIDENCE_SCHEMA,"channel":"read-back","evidence_commitment":"ab".repeat(32),"observed_at":NOW}}); + let mut cases = vec![("valid", valid.clone(), true)]; + for (name, field, value) in [ + ( + "obsolete-schema", + "schema", + json!("auths.gateway-public-evidence/0"), + ), + ("short-commitment", "evidence_commitment", json!("00")), + ( + "uppercase-commitment", + "evidence_commitment", + json!("AB".repeat(32)), + ), + ( + "newline-commitment", + "evidence_commitment", + json!(format!("{}\n", "ab".repeat(32))), + ), + ("numeric-commitment", "evidence_commitment", json!(42)), + ("private-echo", "echo", json!("auths-e1-private-canary")), + ("raw-digest", "evidence_digest", json!("cd".repeat(32))), + ("unsafe-time", "observed_at", json!(1_u64 << 53)), + ("boolean-time", "observed_at", json!(true)), + ("negative-time", "observed_at", json!(-1)), + ] { + let mut value_case = valid.clone(); + value_case["evidence"][field] = value; + cases.push((name, value_case, false)); + } + let mut output = Vec::new(); + for (name, value, accepted) in cases { + let bytes = serde_json::to_string(&value).expect("wire"); + assert_eq!( + serde_json::from_str::(&bytes).is_ok(), + accepted, + "{name}" + ); + output.push(json!({"case":name,"response":bytes,"accepted":accepted})); + } + let base = serde_json::to_string(&valid).expect("wire"); + let duplicate = base.replacen( + "\"schema\":", + &format!( + "\"schema\":\"{}\",\"schema\":", + crate::PUBLIC_EVIDENCE_SCHEMA + ), + 1, + ); + assert!(serde_json::from_str::(&duplicate).is_err()); + output.push(json!({"case":"duplicate-schema","response":duplicate,"accepted":false})); + for (name, bytes) in [ + ( + "fractional-time", + base.replace(&format!("\"observed_at\":{NOW}"), "\"observed_at\":1.0"), + ), + ( + "exponent-time", + base.replace(&format!("\"observed_at\":{NOW}"), "\"observed_at\":1e0"), + ), + ("bom", format!("\u{feff}{base}")), + ] { + assert!(serde_json::from_str::(&bytes).is_err()); + output.push(json!({"case":name,"response":bytes,"accepted":false})); + } + json!(output) +} + +fn matrix(backend: Backend) { + let (first, first_body, first_commitment) = history(backend); + let (second, second_body, second_commitment) = history(backend); + assert!( + first_body == second_body, + "same private bytes must exercise distinct private journal scopes" + ); + assert_ne!(first_commitment, second_commitment); + assert_eq!(first, second); + let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-public-mutation-evidence/1","adapter":backend.label(), + "scope":"native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", + "excluded":["signed outcome/pre-entry observation projection hardening", "live provider and hostile OS qualification"], + "public_result":first,"wire_cases":wire_cases(),"same_private_bytes_have_distinct_record_scoped_commitments":true,"reopen_and_replay_preserve_commitment_without_io":true, + "private_complete_evidence_and_original_binding_preserved":true,"public_and_debug_exclude_raw_body_digest_echo_and_action_digest":true})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-public-mutation-evidence-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &artifact).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), artifact); +} +#[test] +fn native_file_public_mutation_evidence_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires the TLS PostgreSQL fixture"] +fn postgres_native_public_mutation_evidence_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index 17d938fcd..74014ea88 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -35,6 +35,8 @@ const TARGET: &str = "/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001" mod history_tests; #[path = "native_recovery_limits_tests.rs"] mod limits_tests; +#[path = "native_public_evidence_tests.rs"] +mod privacy_tests; #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] diff --git a/product/runtime/auths-gateway/src/scenario_tests.rs b/product/runtime/auths-gateway/src/scenario_tests.rs index 37f72509e..d57da9787 100644 --- a/product/runtime/auths-gateway/src/scenario_tests.rs +++ b/product/runtime/auths-gateway/src/scenario_tests.rs @@ -525,7 +525,7 @@ async fn reobserve_operator( .ok()?; Some(GatewaySubmitResult::ObservedByProvider { status, - evidence: snapshot.provider_evidence()?.into(), + evidence: crate::GatewayEvidenceSummary::from_snapshot(&snapshot)?, }) } ReadBack::Value { matched } => { @@ -1022,7 +1022,8 @@ async fn response_requires_a_separate_reference_observation_for_evidence() { result, GatewaySubmitResult::ObservedByProvider { status: Some(200), - evidence: evidence.into(), + evidence: crate::GatewayEvidenceSummary::from_snapshot(&snapshot) + .expect("public evidence"), } ); assert_eq!((provider.writes(), provider.reads()), (1, 1)); @@ -1725,10 +1726,15 @@ async fn qualification_stages_use_gateway_replay_and_recovery_witnesses() { .await }; let (outcome, code, evidence_sha256, confirmed) = match result { - GatewaySubmitResult::ObservedByProvider { evidence, .. } => ( + GatewaySubmitResult::ObservedByProvider { .. } => ( RunOutcome::Observed, "observed-by-provider".to_owned(), - Some(Sha256Digest::try_from(evidence.evidence_digest).expect("evidence")), + Some( + Sha256Digest::try_from(hex::encode(Sha256::digest( + &*provider.last_read.lock().expect("provider evidence"), + ))) + .expect("evidence"), + ), u32::from(provider.reads() > reads_before), ), GatewaySubmitResult::ResponseRecorded { .. } => ( @@ -2048,8 +2054,18 @@ async fn conformance_unknown_and_reobserve(backend: Backend) { panic!("expected observed-by-provider"); }; assert_eq!(status, None); - assert_eq!(evidence.echo, original_token()); - assert_eq!(Some(evidence.echo.as_str()), original.request.echo_token()); + let protected = record.snapshot(&original).await; + let private_evidence = protected.provider_evidence().expect("protected evidence"); + assert_eq!(private_evidence.echo(), original_token()); + assert_eq!(Some(private_evidence.echo()), original.request.echo_token()); + assert_eq!( + evidence.evidence_commitment, + hex::encode( + protected + .public_evidence_commitment() + .expect("hiding commitment") + ) + ); assert_eq!( record.submit(&original, &provider).await, resolved, diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 9e4284e8a..ed7cca795 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "87d516a91c79770a0db7ce4e066e304b2358274bc5af99248ce21b1abef48efb"; + "9f470c3eed04ddaf76e41bfb9a3565fc73ef75db51578c9b14a2bd9e04744824"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 34b7059f6..8bb744cb5 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -121,7 +121,7 @@ pub enum GatewayEvidenceChannel { /// Secret-free provider evidence kept for every `observed-by-provider` stage. /// The bytes inherit the provider data's sensitivity and must not be logged; -/// `Debug` reports only their length. +/// `Debug` reports only bounded non-content metadata. #[derive(Clone, Eq, PartialEq)] pub struct GatewayProviderEvidence { channel: GatewayEvidenceChannel, @@ -170,9 +170,7 @@ impl std::fmt::Debug for GatewayProviderEvidence { formatter .debug_struct("GatewayProviderEvidence") .field("channel", &self.channel) - .field("locator", &self.locator) - .field("echo", &self.echo) - .field("evidence_digest", &hex::encode(self.evidence_digest)) + .field("private", &"[redacted]") .field("evidence_bytes", &self.evidence.len()) .field("observed_at", &self.observed_at) .finish() @@ -273,8 +271,9 @@ pub fn pre_entry_digest(observations: &[Vec]) -> Option<[u8; 32]> { Some(hash.finalize().into()) } -/// Secret-free persisted evidence for one logical operation. -#[derive(Clone, Debug, Eq, PartialEq)] +/// Protected persisted evidence for one logical operation. Public callers must +/// use the native redacted projections rather than serializing these facts. +#[derive(Clone, Eq, PartialEq)] pub struct GatewayAttemptSnapshot { revision: u64, namespace: OperatorNamespace, @@ -291,11 +290,26 @@ pub struct GatewayAttemptSnapshot { observation_match: Option, observation_fact: Option, provider_evidence: Option, + public_evidence_commitment: Option<[u8; 32]>, pre_entry: Option, recovery_evidence: Option, } +impl std::fmt::Debug for GatewayAttemptSnapshot { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter + .debug_struct("GatewayAttemptSnapshot") + .field("revision", &self.revision) + .field("stage", &self.stage) + .field("private", &"[redacted]") + .finish() + } +} + impl GatewayAttemptSnapshot { + pub(crate) const fn public_evidence_commitment(&self) -> Option<&[u8; 32]> { + self.public_evidence_commitment.as_ref() + } /// Whether this history was refined by an independently authorized read. #[must_use] pub const fn has_recovery_evidence(&self) -> bool { @@ -847,6 +861,40 @@ fn canonical(value: &T) -> Result, GatewayAttemptError> { } impl Record { + /// One hiding projection under the existing private, immutable 128-bit + /// attempt nonce. Scope includes every canonical binding dimension; the + /// nonce and raw evidence digest never enter the public projection. + fn public_commitment( + &self, + label: &[u8], + digest: &[u8; 32], + ) -> Result<[u8; 32], GatewayAttemptError> { + use hmac::Mac as _; + let key = zeroize::Zeroizing::new( + hex::decode(&self.nonce).map_err(|_| GatewayAttemptError::Corrupt)?, + ); + if key.len() != 16 { + return Err(GatewayAttemptError::Corrupt); + } + let mut mac = + hmac::Hmac::::new_from_slice(&key).map_err(|_| GatewayAttemptError::Corrupt)?; + mac.update(b"auths.gateway-public-commitment/1\0"); + let binding = self.binding_canonical.as_bytes(); + mac.update( + &u32::try_from(binding.len()) + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_be_bytes(), + ); + mac.update(binding); + mac.update( + &u32::try_from(label.len()) + .map_err(|_| GatewayAttemptError::Corrupt)? + .to_be_bytes(), + ); + mac.update(label); + mac.update(digest); + Ok(mac.finalize().into_bytes().into()) + } fn counters(&self) -> Result, GatewayAttemptError> { capacity::decode_counters(&self.state.counters) } @@ -1070,6 +1118,12 @@ impl Record { }) .map(PreEntryWire::decode) .transpose()?; + let public_evidence_commitment = provider_evidence + .as_ref() + .map(|evidence| { + self.public_commitment(b"provider-evidence", evidence.evidence_digest()) + }) + .transpose()?; Ok(GatewayAttemptSnapshot { revision: self.revision, namespace, @@ -1090,6 +1144,7 @@ impl Record { observation_match: self.state.observation_match, observation_fact: self.state.observation_fact, provider_evidence, + public_evidence_commitment, pre_entry, recovery_evidence: self.state.recovery_evidence.clone(), }) diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index ec8a68e76..3a5fc2e40 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 424 +freeze_version = 425 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,9 +45,9 @@ freeze_version = 424 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 167 +"auths.identity.protocol" = 168 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 126 +"auths.portable-abi-bindings" = 127 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -60,11 +60,11 @@ freeze_version = 424 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 164 +"auths.product.public-sdk-contract" = 165 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 -"auths.product.vocabulary" = 28 +"auths.product.vocabulary" = 29 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 424 +"auths.release.public-surface" = 425 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 31617e117..4b081e455 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 424, + "freezeVersion": 425, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 167, + "version": 168, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "17d5aabaa33bb511d80f7b8a2256259913a2b1dc953b9bc5777b2c4edab413f5" + "sha256": "7935fc8a2956729ae4259c2406390c5059b195f2092d15d89b38719481cec60d" }, { "id": "auths.modular-components", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 126, + "version": 127, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "2ff3683341e747635d0e4c0a9d806ed1cd9c5d73fccbbe58fe40ce66dd1a9cbb" + "sha256": "4a990d5571644c10c3aeaf4de8c4cc6e2aaa0fe4104feec58cbe066c3151c4e8" }, { "id": "auths.product.bounded-domains", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 164, + "version": 165, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "8afbe7aba45cd868eb1b51e4db6722e4f4be2ab3c819651a0e29d06b34588ee0" + "sha256": "e486c1f9120125227647dc750715c9203a7db3610ad2b193099a70eec0eaefdb" }, { "id": "auths.product.receipts", @@ -947,7 +947,7 @@ }, { "id": "auths.product.vocabulary", - "version": 28, + "version": 29, "classification": "frozen-meaning", "categories": [ "customer-vocabulary", @@ -965,7 +965,7 @@ "product/sdk/auths-sdk/Cargo.toml", "xtask/src/sdk_vocabulary.rs" ], - "sha256": "4162f24053837ece3e947e0f9d9085a24b5e18709bee1745f0c6e0b22e4f1478" + "sha256": "29800f15631e40abde0ca107543eec3be23d40f693e36ec388fe9e109d40325c" }, { "id": "auths.release.benchmark-contract", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 424, + "version": 425, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "f4edc6505292747b4d3d691dd321a7ee7d102cd3144aa47e28b040249325f6ce" + "sha256": "918eac977776deb0019d1e4829e2feb89f0a65ed4ad3e1154dd1dacd41afc7fa" } ] } From 6c48f0da277f55bf26fe2cfddf58d3393cb013f5 Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 04:18:23 +0000 Subject: [PATCH 117/136] fix(ci): align demo evidence checks with private commitments --- bindings/typescript/api/public-api.txt | 2 +- demos/airtable-gateway/selftest.py | 34 +++++++++++++++++++++++++- demos/stripe-gateway/operate.py | 1 + demos/stripe-gateway/selftest.py | 34 +++++++++++++++++++++++++- 4 files changed, 68 insertions(+), 3 deletions(-) diff --git a/bindings/typescript/api/public-api.txt b/bindings/typescript/api/public-api.txt index 36b991cf0..f423ebfb6 100644 --- a/bindings/typescript/api/public-api.txt +++ b/bindings/typescript/api/public-api.txt @@ -1,5 +1,5 @@ # Installed @auths-dev/sdk public API v1 -# declaration-sha256 bf0244c80c841728705313102efac0d9aa671e066729617e055b3348d59a68e5 +# declaration-sha256 c148be1e92ca3fd36566796f02d985ac8dfe646e5a0a79bfa96eecda2652c207 . AuthsError value+type . AuthsIssue type . EffectState type diff --git a/demos/airtable-gateway/selftest.py b/demos/airtable-gateway/selftest.py index b2264981a..08c24c725 100644 --- a/demos/airtable-gateway/selftest.py +++ b/demos/airtable-gateway/selftest.py @@ -12,6 +12,22 @@ from demo_common import canonical, decode, digest, read, require, write +def private_action_echo(label, action): + """Test-only expected link from the operator's exact native approval input.""" + from operate import PRIVATE + binding = decode(read(PRIVATE / ('effect-' + label) / 'binding')) + commitment = binding['action'] + require(binding['schema'] == 'auths.bound-effect/3' + and binding['namespace'] == action['operator_namespace'] + and binding['operation'] == action['operation_id'] + and type(commitment) is list and len(commitment) == 32 + and all(type(value) is int and 0 <= value <= 255 for value in commitment), + 'demo.selftest-private-action-binding') + return 'auths-e1-' + digest(b'auths.gateway-echo/1\0' + + action['operator_namespace'].encode() + b'\0' + + action['operation_id'].encode() + b'\0' + bytes(commitment)) + + def test_native_refusals_replay_race_and_loss(operator): from operate import HOME from double import PREFIX, record_ids @@ -85,7 +101,21 @@ def execute(label): require(len(writes) == 1 and cases[-2]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-write-count:' + label) action = result['action'] - echo = records[0]['evidence']['echo'] + evidence = records[0]['evidence'] + language = decode(inspected.stdout)['records'][0]['language'] + require(language in ('python', 'typescript'), 'demo.selftest-client-language') + commitment_field, time_field = (('evidenceCommitment', 'observedAt') + if language == 'typescript' else ('evidence_commitment', 'observed_at')) + require(set(evidence) == {'schema', 'channel', commitment_field, time_field} + and evidence['schema'] == 'auths.gateway-public-evidence/1' + and evidence['channel'] == 'read-back' + and type(evidence[commitment_field]) is str + and len(evidence[commitment_field]) == 64 + and all(value in '0123456789abcdef' for value in evidence[commitment_field]) + and type(evidence[time_field]) is int and 0 <= evidence[time_field] <= 2**53 - 1, + 'demo.selftest-public-hiding-evidence') + # Private test expectation never returns through the application result. + echo = private_action_echo(label, action) expected = canonical({'fields': {'DemoStatus': action['replacement'], 'auths_echo': echo}}).decode() require(writes[0]['body'] == expected and writes[0]['idempotency_key'] is None and writes[0]['path'] == PREFIX + action['record_id'], 'demo.selftest-independent-request-mapping') @@ -97,6 +127,8 @@ def execute(label): value = decode(raw) require(value['id'] == action['record_id'] and value['fields'] == { 'DemoStatus': action['replacement'], 'auths_echo': echo}, 'demo.selftest-independent-read-back') + require(evidence[commitment_field] != digest(raw), + 'demo.selftest-public-raw-evidence-digest') cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(raw)} for label in ['replay', 'typescript']: _, records, traffic = execute(label) diff --git a/demos/stripe-gateway/operate.py b/demos/stripe-gateway/operate.py index 566551e86..4698ea665 100644 --- a/demos/stripe-gateway/operate.py +++ b/demos/stripe-gateway/operate.py @@ -441,6 +441,7 @@ def exact_approval(self, state, name, proof, action, *mode): output = child([self.binary, 'effect-review', '--state-dir', state, '--proof', proof_path, '--action', action_path, '--not-before', str(now - 1), '--expires-at', str(now + ACTION_VALIDITY_SECONDS), '--request-out', request, + '--binding-out', directory / 'binding', *mode], check=False) if output.returncode != 0: return None diff --git a/demos/stripe-gateway/selftest.py b/demos/stripe-gateway/selftest.py index 88f64657b..5f51bb7ff 100644 --- a/demos/stripe-gateway/selftest.py +++ b/demos/stripe-gateway/selftest.py @@ -12,6 +12,22 @@ from demo_common import canonical, decode, digest, read, require, write +def private_action_echo(label, action): + """Test-only expected link from the operator's exact native approval input.""" + from operate import PRIVATE + binding = decode(read(PRIVATE / ('effect-' + label) / 'binding')) + commitment = binding['action'] + require(binding['schema'] == 'auths.bound-effect/3' + and binding['namespace'] == action['operator_namespace'] + and binding['operation'] == action['operation_id'] + and type(commitment) is list and len(commitment) == 32 + and all(type(value) is int and 0 <= value <= 255 for value in commitment), + 'demo.selftest-private-action-binding') + return 'auths-e1-' + digest(b'auths.gateway-echo/1\0' + + action['operator_namespace'].encode() + b'\0' + + action['operation_id'].encode() + b'\0' + bytes(commitment)) + + def test_native_refusals_replay_race_and_loss(operator): """No double replaces gateway verification, admission, persistence or observation.""" from operate import HOME @@ -87,7 +103,21 @@ def execute(label): require(len(writes) == 1 and cases[-2]['native_counters']['write_transport_entries'] == 1, 'demo.selftest-write-count:' + label) action = result['action'] - echo = records[0]['evidence']['echo'] + evidence = records[0]['evidence'] + language = decode(inspected.stdout)['records'][0]['language'] + require(language in ('python', 'typescript'), 'demo.selftest-client-language') + commitment_field, time_field = (('evidenceCommitment', 'observedAt') + if language == 'typescript' else ('evidence_commitment', 'observed_at')) + require(set(evidence) == {'schema', 'channel', commitment_field, time_field} + and evidence['schema'] == 'auths.gateway-public-evidence/1' + and evidence['channel'] == 'read-back' + and type(evidence[commitment_field]) is str + and len(evidence[commitment_field]) == 64 + and all(value in '0123456789abcdef' for value in evidence[commitment_field]) + and type(evidence[time_field]) is int and 0 <= evidence[time_field] <= 2**53 - 1, + 'demo.selftest-public-hiding-evidence') + # Private test expectation never returns through the application result. + echo = private_action_echo(label, action) key = 'auths-i1-' + digest(b'auths.gateway-idempotency-key/1\0' + action['operator_namespace'].encode() + b'\0' + action['operation_id'].encode()) expected = urlencode([('amount', str(action['amount'])), ('metadata[auths_echo]', echo), @@ -106,6 +136,8 @@ def execute(label): refund = decode(refund_bytes) require(refund['amount'] == action['amount'] and refund['payment_intent'] == action['payment_intent'] and refund['metadata']['auths_echo'] == echo, 'demo.selftest-independent-read-back') + require(evidence[commitment_field] != digest(refund_bytes), + 'demo.selftest-public-raw-evidence-digest') cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(refund_bytes)} for label in ['replay', 'typescript']: _, records, traffic = execute(label) From 3cb2caadb3737ef755c6089fc3da617374e0121a Mon Sep 17 00:00:00 2001 From: bordumb Date: Fri, 30 Oct 2026 04:23:07 +0000 Subject: [PATCH 118/136] fix(gateway): preserve redacted diagnostics at pause checkpoint --- docs/plans/0074-implementation-status.md | 80 ++++++++++++++----- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_public_evidence_tests.rs | 10 ++- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 4 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 ++-- 7 files changed, 85 insertions(+), 35 deletions(-) diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 2720fb3de..28a203bf1 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1,5 +1,21 @@ # AP-SPEC-074 implementation and evidence ledger +## User-requested pause — 30 October 2026 + +AP074 remains incomplete. The user requested a committed, pushed pause. +The completed public mutation-evidence cutover is `1769057a` on PR213. +All unfinished signed-output/private-audit work is separately committed and pushed +at `f55aa61a720a5885d68da30daf102689f75446a3` on +`codex/ap074-public-output-checkpoint`. Its +[`0074-public-output-checkpoint.md`](https://github.com/auths-dev/auths-proof/blob/f55aa61a720a5885d68da30daf102689f75446a3/docs/plans/0074-public-output-checkpoint.md) +records implemented changes, construction evidence and remaining integration work. +That checkpoint is unfinished and must not be mistaken for a qualified PR head. + +Resume only on a new user request. Preserve both branches and reconcile the +checkpoint with subsequent PR CI repairs before continuing. A17, the remaining +acceptance/evidence items below and final exact-head qualification remain open. +AP070 remains independent; AP073 remains paused and untouched. + ## Durable goal Implement all of [AP-SPEC-074](../specs/0074-bound-effects-and-recovery-state-machine.md) @@ -3702,21 +3718,49 @@ or deployment claim is made by AP074 source work. - Gateway source closure is `9f470c3eed04ddaf76e41bfb9a3565fc73ef75db51578c9b14a2bd9e04744824`; construction and rebuilt check passed. Semantic freeze 425 updates identity 168, portable ABI 127, public SDK 165, vocabulary 29 and public surface 425. The required metadata constructor completed successfully. Hosted checks remain the CI agent’s responsibility. -### Next mandatory privacy cutover - -- Signed outcomes and public pre-entry observations still expose private facts; - this checkpoint does not close A17 or the entire specification. -- Replace the public signed outcome with a new schema containing a stable hiding - effect reference, stage/status/time/recipe facts and a hiding commitment to the - exact complete journal record. The seal must cover entry/fence/authority and - accounting metadata, not just the legacy OutcomeRecord fields. Exclude the - private nonce from the sealed message while using it as the MAC key. -- Private audit must use an operator-only atomic signed-outcome plus canonical - journal-record opening. Its decoder must be the existing journal owner, check - exact proof/action commitments and scope, and compare the public seal; retain - every existing private outcome presence, counter, pre-entry and basis check. - Do not weaken audit binding or expose the opening on the application socket. -- Public pre-entry results must contain redacted count/hiding metadata rather - than raw signed observations. Private audit obtains those bytes from the - protected journal opening. Cut over native vectors, bindings, demos/templates - and private audit schema directly; no legacy or dual-schema runtime readers. +### Saved unfinished privacy cutover + +- Signed outcomes and public pre-entry observations in the PR still expose + private facts; this checkpoint does not close A17 or the specification. +- Branch `codex/ap074-public-output-checkpoint` preserves the in-progress direct + cutover to public signed outcome `/3`, redacted pre-entry history and app + observe `/4`, plus binding, corpus and operator export changes. Its resume note + distinguishes implemented source from incomplete consumers and stale metadata. +- Public facts use a stable hiding effect reference and a hiding commitment to + the complete canonical journal record, excluding its nonce from the message. + Entry/fence/authority and accounting fields are included in the record seal. +- The saved implementation improves the earlier proposed journal opening: the + operator exports the existing complete signed private outcome fact set and + protected pre-entry bytes from one loaded native snapshot. A separate closed + private outcome schema retains the existing audit decoder, presence predicate, + counter/pre-entry/basis checks and signature pin. No journal nonce is exported + and no second journal interpreter is introduced. This remains unfinished. +- Complete SDK/demo/example/template and operator-bundle consumers atomically; + private outcome or pre-entry bytes must never return through an application + socket, UI, binding or public artifact. Preserve all current audit checks, + including negative/tamper cases. Reject superseded public schemas directly. + +## Committed pause checkpoint: bounded CI repair + +- Integrated the CI subagent's final four-file batch `2e31c2d7`: TypeScript API + declaration snapshot, closed public hiding-summary assertions in both demos, + and Stripe retention of the existing operator-private native exact binding. + Expected echoes are derived only from the private authored native binding; + raw public echoes or digests were not restored and linkage checks remain. +- Fixed native redacted Debug builders with `finish_non_exhaustive`, and added + explicit redacted messages to private byte/digest equality assertions. No + sensitive values enter failure diagnostics. These address the CI subagent's + exact strict-lint findings without allowances or predicate changes. +- The subagent reports that both actual installed Docker reproductions passed: + Airtable 36 cases and Stripe 23 cases, with production qualification false. + It reports 48 native selectors, 15 parser vectors, hosted Linux UID isolation + and exact producer/artifact hashes verified. Main did not inspect CI. Its + report is `/tmp/ap074-ci-1769-report.md`. Final combined-head hosted + qualification remains pending; no complete acceptance row is inferred. +- Required source-closure construction and rebuilt non-update check each passed + (1 passed / 0 ignored). Only the semantic-freeze metadata constructor was run + afterward. No broad local suite or new CI-monitoring loop was started. +- Final checkpoint source closure is + `93ef3b915cc48f0c0d4c0d4de7e03d0ed394e83526fbdfdc2ad19443dec5ec20`. + Semantic freeze 426 updates only the generator-required identity 169, + evolution contract 83 and public surface 426; the metadata constructor passed. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index afe2cdd52..9b21b6968 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"c2b043471d425aff45375540e631d136b81bc18784f4224ca968b63e1d359b81"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"82ce208eb11f6195047c4ba05448816b877dab8a791ee1b8142ca68f830fb0bf"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"92056fb13bc2ff9096defc0a94306ff8b7b275f8eee4cb4b1feca0d90dda6fa9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"19bc24e7c311db2290cfaee514baf0974ca7af66582b1b7734666cdea13aa6a4"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"e28be7ff0dd86e80e0072c4ea08c893bc5b02a257ad39b0e4f4c5a21bdedc5ec"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"c2b043471d425aff45375540e631d136b81bc18784f4224ca968b63e1d359b81"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"82ce208eb11f6195047c4ba05448816b877dab8a791ee1b8142ca68f830fb0bf"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"92056fb13bc2ff9096defc0a94306ff8b7b275f8eee4cb4b1feca0d90dda6fa9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"c6ce27caee4e24091cd7c8c699ef3ccb1b1b050ed9cf9a0d4a2a611d6c3c38eb"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d97104cd48baed2de13fe5992526db77acd1c54e010d2fd1142f0226e7467fa2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs index 95b80d7f7..e1140d415 100644 --- a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs +++ b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs @@ -75,9 +75,15 @@ fn history(backend: Backend) -> (Value, Vec, String) { .source .provider_evidence() .expect("protected evidence"); - assert!(evidence.evidence() == body); + assert!( + evidence.evidence() == body, + "protected evidence bytes differ" + ); let digest: [u8; 32] = Sha256::digest(&body).into(); - assert!(evidence.evidence_digest() == &digest); + assert!( + evidence.evidence_digest() == &digest, + "protected evidence digest differs" + ); let original: Value = serde_json::from_slice(&case.original).expect("source"); let action = hex::decode( original["action_commitment"] diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index ed7cca795..04089049a 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "9f470c3eed04ddaf76e41bfb9a3565fc73ef75db51578c9b14a2bd9e04744824"; + "93ef3b915cc48f0c0d4c0d4de7e03d0ed394e83526fbdfdc2ad19443dec5ec20"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 8bb744cb5..30b7b62a3 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -173,7 +173,7 @@ impl std::fmt::Debug for GatewayProviderEvidence { .field("private", &"[redacted]") .field("evidence_bytes", &self.evidence.len()) .field("observed_at", &self.observed_at) - .finish() + .finish_non_exhaustive() } } @@ -302,7 +302,7 @@ impl std::fmt::Debug for GatewayAttemptSnapshot { .field("revision", &self.revision) .field("stage", &self.stage) .field("private", &"[redacted]") - .finish() + .finish_non_exhaustive() } } diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 3a5fc2e40..b4ceb8b5a 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 425 +freeze_version = 426 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 425 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 168 +"auths.identity.protocol" = 169 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 127 "auths.product.bounded-domains" = 19 @@ -66,5 +66,5 @@ freeze_version = 425 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 29 "auths.release.benchmark-contract" = 1 -"auths.release.evolution-contract" = 82 -"auths.release.public-surface" = 425 +"auths.release.evolution-contract" = 83 +"auths.release.public-surface" = 426 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 4b081e455..73b57b150 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 425, + "freezeVersion": 426, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 168, + "version": 169, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "7935fc8a2956729ae4259c2406390c5059b195f2092d15d89b38719481cec60d" + "sha256": "ff3d37b94be1b597d05269351d38541ac15f620e2e03160d04b8b7fa0d07d1d8" }, { "id": "auths.modular-components", @@ -986,7 +986,7 @@ }, { "id": "auths.release.evolution-contract", - "version": 82, + "version": 83, "classification": "frozen-meaning", "categories": [ "version-axes", @@ -1007,11 +1007,11 @@ "release/fixtures/evolution", "xtask/src/evolution_policy.rs" ], - "sha256": "331714ab88c45d0bf818fa3610503e6cc86d228cdbdcf57aa20d8faf0fc34948" + "sha256": "567cd42cc4ab9e7e392afff8480ccb08a5f37f99f80851401a1512b8b52dcbbf" }, { "id": "auths.release.public-surface", - "version": 425, + "version": 426, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "918eac977776deb0019d1e4829e2feb89f0a65ed4ad3e1154dd1dacd41afc7fa" + "sha256": "4880ecf3d1ab628844824ea9e532794d0e2915630017ee3cabf37f7b6bd10195" } ] } From 7807d04bfad2a2d2dba7b8f842e27fd742a9a8ad Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:18:48 +0900 Subject: [PATCH 119/136] feat(gateway)!: separate public history from private audit evidence --- bindings/customer-journey-matrix-v1.json | 4 +- .../gateway/admin-request-boundary.json | 57 +- .../gateway/application-recovery-frame.json | 2 +- bindings/fixtures/gateway/codes.json | 2 +- .../gateway/managed-cli-inventory.json | 38 +- .../gateway/managed-interface-unix.json | 32 +- .../native-public-mutation-evidence-file.json | 215 ++++- ...ive-public-mutation-evidence-postgres.json | 215 ++++- bindings/fixtures/gateway/outcome-v2.json | 894 ------------------ bindings/fixtures/gateway/outcome-v3.json | 695 ++++++++++++++ .../fixtures/gateway/private-outcome-v1.json | 894 ++++++++++++++++++ bindings/python/README.md | 7 + .../stripe-refund-approval/README.md.tmpl | 14 +- .../app/refund_client.py.tmpl | 2 +- .../lib/operate.py.tmpl | 2 +- .../lib/selftest.py.tmpl | 4 +- bindings/python/python/auths/gateway.py | 62 +- bindings/python/tests/test_gateway_client.py | 68 +- ...tcome_v2.py => test_gateway_outcome_v3.py} | 12 +- bindings/security-evidence-cutover-v1.json | 12 +- bindings/typescript/README.md | 7 + bindings/typescript/api/public-api.txt | 2 +- .../docs/customer-journey-matrix.md | 2 +- bindings/typescript/sdk-capability.json | 2 +- bindings/typescript/src/gateway.ts | 38 +- ...-v2.test.js => gateway-outcome-v3.test.js} | 16 +- .../test/unit/gateway-client.test.js | 62 +- compliance.toml | 19 +- demos/airtable-gateway/README.md | 20 +- demos/airtable-gateway/app.py | 7 +- demos/airtable-gateway/operate.py | 7 + demos/airtable-gateway/selftest.py | 47 +- demos/airtable-gateway/tests/browser.py | 2 +- demos/stripe-gateway/README.md | 20 +- demos/stripe-gateway/app.py | 7 +- demos/stripe-gateway/operate.py | 7 + demos/stripe-gateway/selftest.py | 47 +- demos/stripe-gateway/tests/browser.py | 2 +- ...0013-recipe-capabilities-and-sum-budget.md | 2 +- ...0014-stripe-refund-recipe-qualification.md | 2 +- .../GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md | 2 +- docs/plans/0074-implementation-status.md | 77 ++ docs/plans/0074-public-output-checkpoint.md | 54 ++ docs/product/SELF_HOSTED_CLAIM_LEDGER.md | 14 +- ...declarative-credential-isolated-request.md | 2 +- .../0060-evidence-conditioned-authority.md | 4 +- docs/specs/0063-generalized-gateway.md | 76 +- ...ound-effects-and-recovery-state-machine.md | 49 +- examples/stripe-refund-approval/README.md | 11 +- examples/stripe-refund-approval/journey.py | 4 + examples/stripe-refund-approval/refunds.py | 2 +- .../typescript/journey.ts | 6 +- .../typescript/refunds.ts | 2 +- .../qualification/aeneas/source-closure.json | 4 +- product/integrations/auths-custody/src/lib.rs | 2 +- .../obsolete-read-back | 2 +- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/admin.rs | 5 + .../auths-gateway/src/admin_boundary_tests.rs | 1 + product/runtime/auths-gateway/src/app.rs | 2 +- product/runtime/auths-gateway/src/audit.rs | 42 +- .../runtime/auths-gateway/src/audit_export.rs | 217 +++++ .../runtime/auths-gateway/src/audit_tests.rs | 96 +- .../auths-gateway/src/bin/auths-gateway.rs | 131 +++ .../runtime/auths-gateway/src/bounds_tests.rs | 36 +- product/runtime/auths-gateway/src/engine.rs | 204 +++- product/runtime/auths-gateway/src/fuzzing.rs | 14 +- product/runtime/auths-gateway/src/lib.rs | 8 +- .../src/native_public_evidence_tests.rs | 316 ++++++- .../auths-gateway/src/observed_tests.rs | 35 +- product/runtime/auths-gateway/src/observer.rs | 123 ++- .../src/pending_vectors/outcomes.rs | 183 +++- .../auths-gateway/src/property_tests.rs | 4 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 60 +- .../tests/content_journey/interface_tests.rs | 195 +++- .../tests/managed_interface_probe.py | 1 + release/semantic-freeze-versions.toml | 18 +- release/semantic-freeze.json | 34 +- xtask/src/fuzz.rs | 6 +- 80 files changed, 4295 insertions(+), 1300 deletions(-) delete mode 100644 bindings/fixtures/gateway/outcome-v2.json create mode 100644 bindings/fixtures/gateway/outcome-v3.json create mode 100644 bindings/fixtures/gateway/private-outcome-v1.json rename bindings/python/tests/{test_gateway_outcome_v2.py => test_gateway_outcome_v3.py} (93%) rename bindings/typescript/test/integration/{gateway-outcome-v2.test.js => gateway-outcome-v3.test.js} (89%) create mode 100644 docs/plans/0074-public-output-checkpoint.md create mode 100644 product/runtime/auths-gateway/src/audit_export.rs diff --git a/bindings/customer-journey-matrix-v1.json b/bindings/customer-journey-matrix-v1.json index 1d7d14213..060a5542f 100644 --- a/bindings/customer-journey-matrix-v1.json +++ b/bindings/customer-journey-matrix-v1.json @@ -212,8 +212,8 @@ { "id": "gateway-signed-outcome-verification", "rust": "product/runtime/auths-gateway/src/observer.rs", - "typescript": "bindings/typescript/test/integration/gateway-outcome-v2.test.js", - "python": "bindings/python/tests/test_gateway_outcome_v2.py", + "typescript": "bindings/typescript/test/integration/gateway-outcome-v3.test.js", + "python": "bindings/python/tests/test_gateway_outcome_v3.py", "experience": { "targetJourney": "recover-an-unknown-write-from-a-gateway-signed-outcome", "imports": [ diff --git a/bindings/fixtures/gateway/admin-request-boundary.json b/bindings/fixtures/gateway/admin-request-boundary.json index 4201ce22d..c5bcbf904 100644 --- a/bindings/fixtures/gateway/admin-request-boundary.json +++ b/bindings/fixtures/gateway/admin-request-boundary.json @@ -5,7 +5,7 @@ "oversized_advertised_length_refused_before_body": true, "application_schemas": [ "auths.gateway-submit/2", - "auths.gateway-observe/3", + "auths.gateway-observe/4", "auths.gateway-recover/1", "auths.gateway-content/1", "auths.gateway-disclose/1", @@ -22,6 +22,7 @@ "status", "execution-witness", "qualification-reload", + "audit-export", "recover", "recovery-record" ], @@ -416,6 +417,60 @@ "accepted": false, "refusal": "gateway.admin.invalid-frame" }, + { + "case": "audit-export:valid", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\"}", + "accepted": true, + "refusal": null + }, + { + "case": "audit-export:duplicate-schema-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"schema\":\"auths.gateway-admin-request/2\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:duplicate-schema-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"schema\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:duplicate-command-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"command\":\"audit-export\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:duplicate-command-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"command\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:duplicate-operation_id-same", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"operation_id\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:duplicate-operation_id-different", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"operation_id\":\"altered-public-fixture\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:unknown-argument", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"audit-export\",\"operation_id\":\"original\",\"administrative_resolution\":\"not-entered-and-refunded\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, + { + "case": "audit-export:non-string-command", + "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":{\"name\":\"audit-export\"},\"operation_id\":\"original\"}", + "accepted": false, + "refusal": "gateway.admin.invalid-frame" + }, { "case": "recover:valid", "input": "{\"schema\":\"auths.gateway-admin-request/2\",\"command\":\"recover\",\"source_operation\":\"original\"}", diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json index 521bf928b..885474352 100644 --- a/bindings/fixtures/gateway/application-recovery-frame.json +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -111,7 +111,7 @@ } }, { - "case": "auths.gateway-observe/3", + "case": "auths.gateway-observe/4", "recovery_dispatches": 0, "response": { "outcome": "indeterminate", diff --git a/bindings/fixtures/gateway/codes.json b/bindings/fixtures/gateway/codes.json index 0bcce173c..34ee7c567 100644 --- a/bindings/fixtures/gateway/codes.json +++ b/bindings/fixtures/gateway/codes.json @@ -27,7 +27,7 @@ "status": "existing", "epic": null, "case": { - "fixture": "outcome-v2.json", + "fixture": "private-outcome-v1.json", "id": "outcome-v1-schema" } }, diff --git a/bindings/fixtures/gateway/managed-cli-inventory.json b/bindings/fixtures/gateway/managed-cli-inventory.json index 6fa9ffb3d..c5ab9f09c 100644 --- a/bindings/fixtures/gateway/managed-cli-inventory.json +++ b/bindings/fixtures/gateway/managed-cli-inventory.json @@ -3,7 +3,7 @@ "scope": "all native Clap command and argument declarations; catalog data grants no authority; loopback-provider is test-only and excluded", "application_schemas": [ "auths.gateway-submit/2", - "auths.gateway-observe/3", + "auths.gateway-observe/4", "auths.gateway-recover/1", "auths.gateway-content/1", "auths.gateway-disclose/1", @@ -20,6 +20,7 @@ "status", "execution-witness", "qualification-reload", + "audit-export", "recover", "recovery-record" ], @@ -89,6 +90,41 @@ } ] }, + { + "command": "audit-export", + "arguments": [ + { + "name": "admin_socket", + "long": "admin-socket", + "required": false + }, + { + "name": "bundle", + "long": "bundle", + "required": false + }, + { + "name": "help", + "long": "help", + "required": false + }, + { + "name": "operation_id", + "long": "operation-id", + "required": false + }, + { + "name": "out", + "long": "out", + "required": true + }, + { + "name": "state_dir", + "long": "state-dir", + "required": true + } + ] + }, { "command": "bound-extension", "arguments": [ diff --git a/bindings/fixtures/gateway/managed-interface-unix.json b/bindings/fixtures/gateway/managed-interface-unix.json index 9a0e50017..5f123a766 100644 --- a/bindings/fixtures/gateway/managed-interface-unix.json +++ b/bindings/fixtures/gateway/managed-interface-unix.json @@ -6,7 +6,7 @@ "hostile OS or root", "provider or production custody qualification", "all privileged CLI execution paths", - "positive signed mutation outcome privacy" + "live-provider qualification" ], "first": { "distinct_uid": false, @@ -90,16 +90,19 @@ { "case": "observe-outcome", "response": { - "outcome": "refused", - "code": "gateway.observer.not-provisioned" + "outcome": "signed", + "schema": "auths.gateway-outcome/3", + "native_canonical_public_projection_checked": true }, "post_ready_control_frames": 0 }, { "case": "observe-pre-entry", "response": { - "outcome": "refused", - "code": "gateway.observer.store-unavailable" + "outcome": "pre-entry", + "operation_id": "write", + "observations": 0, + "record_commitment": "native-hiding-value-checked" }, "post_ready_control_frames": 0 }, @@ -186,6 +189,14 @@ }, "post_ready_control_frames": 0 }, + { + "case": "admin-on-app:audit-export", + "response": { + "outcome": "indeterminate", + "code": "gateway.submit.invalid-frame" + }, + "post_ready_control_frames": 0 + }, { "case": "admin-on-app:recover", "response": { @@ -332,6 +343,10 @@ "command": "audit", "help_accessible": true }, + { + "command": "audit-export", + "help_accessible": true + }, { "command": "bound-extension", "help_accessible": true @@ -584,10 +599,13 @@ "private_files_inaccessible": null }, "private_source_journal_unchanged": true, - "provider_authorized_calls": 1, + "provider_authorized_calls": 2, "direct_provider_refusals": 4, "no_new_custody_or_provider_entries": true, "recipient_key_and_uid_guard_precede_content": true, "trusted_recipient_positive_control": true, - "public_channels_exclude_plaintext_encodings_and_raw_digests": true + "public_channels_exclude_plaintext_encodings_and_raw_digests": true, + "operator_private_export_mode": 384, + "operator_private_audit_verified_entries": 1, + "private_export_refuses_overwrite": true } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-file.json b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json index f8177fb97..0f9674845 100644 --- a/bindings/fixtures/gateway/native-public-mutation-evidence-file.json +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json @@ -3,7 +3,6 @@ "adapter": "file", "scope": "native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", "excluded": [ - "signed outcome/pre-entry observation projection hardening", "live provider and hostile OS qualification" ], "public_result": { @@ -93,8 +92,222 @@ "accepted": false } ], + "history_wire_cases": [ + { + "kind": "pre-entry", + "case": "valid", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "valid", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "zero", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "limit", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":4,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "limit-plus-one", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":5,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "negative", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":-1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "boolean", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":true,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "short-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"00\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "uppercase-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "newline-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\\n\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "private-observations", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observations_b64\":[\"AQID\"]}", + "accepted": false + }, + { + "kind": "signed", + "case": "old-public-schema", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/2\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "private-schema", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-private-outcome/1\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "wrong-media", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "empty-subject", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "subject-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "subject-limit-plus-one", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "time-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":9007199254740991,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "unsafe-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":9007199254740992,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "negative-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":-1,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "boolean-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":true,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "empty-bytes", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "padded-bytes", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID=\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "noncanonical-pad-bits", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AB\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "bytes-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQ\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "bytes-limit-plus-one", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "private-facts", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\",\"pre_entry_b64\":[\"AQID\"]}", + "accepted": false + }, + { + "kind": "signed", + "case": "duplicate-member", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\",\"schema\":\"auths.gateway-outcome/3\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "bom", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "fractional-number", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1.0,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "exponent-number", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1e0,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "duplicate-member", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\",\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "bom", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "fractional-number", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1.0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "exponent-number", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1e0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + } + ], "same_private_bytes_have_distinct_record_scoped_commitments": true, "reopen_and_replay_preserve_commitment_without_io": true, + "configured_signed_public_history_excludes_private_facts": true, + "operator_private_signature_preserves_full_audit_facts": true, "private_complete_evidence_and_original_binding_preserved": true, "public_and_debug_exclude_raw_body_digest_echo_and_action_digest": true } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json index 5b0646405..597d94980 100644 --- a/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json @@ -3,7 +3,6 @@ "adapter": "postgres", "scope": "native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", "excluded": [ - "signed outcome/pre-entry observation projection hardening", "live provider and hostile OS qualification" ], "public_result": { @@ -93,8 +92,222 @@ "accepted": false } ], + "history_wire_cases": [ + { + "kind": "pre-entry", + "case": "valid", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "valid", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "zero", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "limit", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":4,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": true + }, + { + "kind": "pre-entry", + "case": "limit-plus-one", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":5,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "negative", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":-1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "boolean", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":true,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "short-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"00\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "uppercase-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "newline-commitment", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\\n\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "private-observations", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observations_b64\":[\"AQID\"]}", + "accepted": false + }, + { + "kind": "signed", + "case": "old-public-schema", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/2\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "private-schema", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-private-outcome/1\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "wrong-media", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "empty-subject", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "subject-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "subject-limit-plus-one", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "time-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":9007199254740991,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "unsafe-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":9007199254740992,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "negative-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":-1,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "boolean-time", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":true,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "empty-bytes", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "padded-bytes", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID=\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "noncanonical-pad-bits", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AB\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "bytes-limit", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQ\"}", + "accepted": true + }, + { + "kind": "signed", + "case": "bytes-limit-plus-one", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "private-facts", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\",\"pre_entry_b64\":[\"AQID\"]}", + "accepted": false + }, + { + "kind": "signed", + "case": "duplicate-member", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\",\"schema\":\"auths.gateway-outcome/3\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "bom", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1790000000,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "fractional-number", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1.0,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "signed", + "case": "exponent-number", + "response": "{\"outcome\":\"signed\",\"schema\":\"auths.gateway-outcome/3\",\"subject\":\"public-subject\",\"observed_at\":1e0,\"media_type\":\"application/vnd.auths.observation.v1+cbor\",\"observation_b64\":\"AQID\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "duplicate-member", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\",\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "bom", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "fractional-number", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1.0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + }, + { + "kind": "pre-entry", + "case": "exponent-number", + "response": "{\"outcome\":\"pre-entry\",\"operation_id\":\"step-1\",\"observations\":1e0,\"record_commitment\":\"abababababababababababababababababababababababababababababababab\"}", + "accepted": false + } + ], "same_private_bytes_have_distinct_record_scoped_commitments": true, "reopen_and_replay_preserve_commitment_without_io": true, + "configured_signed_public_history_excludes_private_facts": true, + "operator_private_signature_preserves_full_audit_facts": true, "private_complete_evidence_and_original_binding_preserved": true, "public_and_debug_exclude_raw_body_digest_echo_and_action_digest": true } \ No newline at end of file diff --git a/bindings/fixtures/gateway/outcome-v2.json b/bindings/fixtures/gateway/outcome-v2.json deleted file mode 100644 index cf05f7c3d..000000000 --- a/bindings/fixtures/gateway/outcome-v2.json +++ /dev/null @@ -1,894 +0,0 @@ -{ - "schema": "auths.gateway-outcome-vectors/1", - "outcome_schema": "auths.gateway-outcome/2", - "observer": { - "seed_byte": 90, - "principal": "key:sha256:WzB6O--wtA9LLP9FZ5qqA0S3Jhnzxy2P_mGmxcJce98" - }, - "observed_at": 1790000005, - "accepted": [ - { - "id": "not-entered-exhausted", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/not-entered-exhausted", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "not-entered" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "refusal": { - "text": "gateway.policy.window-exhausted" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g/YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtZXhoYXVzdGVkBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4H2dhdGV3YXkucG9saWN5LndpbmRvdy1leGhhdXN0ZWSiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA1X5q3FIuZ38arYEUmG7S0WO85OidKSO0Nx0g5MGCtmkDbq+ZfwCWBlCdG5588cxIMgo3aFgg8Qk2rncadsKxDgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" - }, - { - "id": "not-entered-after-claim", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/not-entered-after-claim", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "not-entered" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "refusal": { - "text": "gateway.credential.account-mismatch" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtYWZ0ZXItY2xhaW0EGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZ3JlZnVzYWwBeCNnYXRld2F5LmNyZWRlbnRpYWwuYWNjb3VudC1taXNtYXRjaKIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDmtJoVYYXQ2cDQ9QSKq7eC1MVOjUXj3RHLs7wVyQShM78RWPrWBYJJgw+s/tma9L3x6M/6qYhjCEMFADzjmCUJAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - }, - { - "id": "not-entered-relative-ceiling-above", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/not-entered-relative-ceiling-above", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "not-entered" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "refusal": { - "text": "gateway.relative-ceiling.above" - }, - "relative-basis": { - "uint": 1001 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t/0jB5erH+KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HmdhdGV3YXkucmVsYXRpdmUtY2VpbGluZy5hYm92ZaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQC02kdD33WDdoEG1vPLcNYppIwgNkFdZV/Ky4jI1lKBqqtnr43YUChJ/BQVhmBK2atQLgrHLC1qFZCXuCQGaigMCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" - }, - { - "id": "not-entered-pre-entry-condition-false", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/not-entered-pre-entry-condition-false", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "not-entered" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "pre-entry-digest": { - "bytes_hex": "8f357cf1700de8dbdea8512ceb40438748e972112517522a55e271b097f9cb5c" - }, - "refusal": { - "text": "gateway.pre-entry.condition-false" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl/nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECjcHwIJ7r68HeNR2izaG/fVA+hqzYr9hHZIpqJnMj1HO3p0H4Ldnj+dloBO7IKs0Crr8fcn8YIEybdNmv9ZJgLAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - }, - { - "id": "unknown", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/unknown", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "unknown" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "relative-basis": { - "uint": 1001 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t/0jB5erH+KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA+2Rrzwjdx658JuaScuhtqxp+XwSi5BJ8qACcB5iiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEASxOaof7EQccAHKCyzemrYTFZYggrjFwA24ZVn6Hes8fw4kgBIRGR2gmNaqBAMTyALwB3ivuKhouX6oK6PdPMBAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - }, - { - "id": "unknown-without-counters", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/unknown-without-counters", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "unknown" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hBYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy91bmtub3duLXdpdGhvdXQtY291bnRlcnMEGmqxO4UFhKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEAGKoFUN98qnQalSdZFVoynSIlGyYC060nUtHeXaoB6ktn3yiuuwlGjPtJErUAP00od6Ku571/P0WKuPqKYkNoGAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - }, - { - "id": "response-recorded", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/response-recorded", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "relative-basis": { - "uint": 1001 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQEGmqxO4UFiaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA+2Rrzwjdx658JuaScuhtqxp+XwSi5BJ8qACcB5iiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED8I/Lwh0x6Nuq1O5epKYyD3JkWxQX7l9YtaP92/9y49iTBNE34c26Z8lu7jbWt5i9z64m6c7ujtVFd4/sjRbgOAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - }, - { - "id": "response-recorded-provider-rejected", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/response-recorded-provider-rejected", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "http-status": { - "uint": 400 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "relative-basis": { - "uint": 1001 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQtcHJvdmlkZXItcmVqZWN0ZWQEGmqxO4UFiaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEZAZCiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA2V+y1+7xhZQeEUcdT3LemGfktcwI2jUy+FTLE1rwnDFN1IANy5n58sDP5Kk/J+zlAWGKBFBeyMT41w7R+QlAAQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" - }, - { - "id": "observed-match", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/observed-match", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "observation": { - "text": "match" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g3YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1tYXRjaAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAa29ic2VydmF0aW9uAWVtYXRjaKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAcBeY9L69SYPrgqrsLSrea8vEzx/bqUSzs+yAW1LmuRPoaA9vp6HCYDj2/oXrpvJiKIFgZDVFB4Xeh53P8hKJBAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" - }, - { - "id": "observed-mismatch", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/observed-mismatch", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "observation": { - "text": "mismatch" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g6YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1taXNtYXRjaAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAa29ic2VydmF0aW9uAWhtaXNtYXRjaKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAfHyn6HLMASqX7/vkRYJon+T2FyrX+jsRU9kL6QpDdgVQmJJbvcARldBRx9FAjlkIgeUt3sPZBiD6Q2yMxHAJDQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" - }, - { - "id": "observed-echo-mismatch", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/observed-echo-mismatch", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "observation": { - "text": "echo-mismatch" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g/YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYeiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBrb2JzZXJ2YXRpb24BbWVjaG8tbWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQDN/nfIKgDkcfD+LlGMPQaBRwelOnDUuqU06LBsoMdyDcZ0/h8baPWmvnNxcVtW38oCjC45uXUvvK0wIyFi9pAcCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" - }, - { - "id": "observed-by-provider-after-response", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/observed-by-provider-after-response", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed-by-provider" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "counters-digest": { - "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "evidence-digest": { - "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" - }, - "relative-basis": { - "uint": 1001 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItYWZ0ZXItcmVzcG9uc2UEGmqxO4UFiqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG9ldmlkZW5jZS1kaWdlc3QBWCC362qkNEbWDQoIkIpHQlFQUi6CklBN9iyjnvGrU/NwmqIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG5yZWxhdGl2ZS1iYXNpcwEZA+miAHVyZWxhdGl2ZS1iYXNpcy1kaWdlc3QBWCC6s0D7ZGvPCN3Hrnwm5pJy6G2rGn5fBKLkEnyoAJwHmKIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQK/HaALNKWRoPoWRvIE/eluGliIg/Qa+Gr0+FnrPEw7ELYi9w7t3dcEz9qK/fM2gl2lqD7up7Py9LTwQafdL+gECgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" - }, - { - "id": "observed-by-provider-after-unknown", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-after-unknown", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed-by-provider" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "evidence-digest": { - "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA4oejy1Q+CjIQ/FRLmrMe0QpdmZz5wNOdqZh4FsuWD6CGSmNlxvh1zI1V/GIrmVNnOvLFgtGsAlGOr2BwkmrtDgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" - }, - { - "id": "observed-by-provider-with-pre-entry", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-with-pre-entry", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed-by-provider" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "evidence-digest": { - "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" - }, - "pre-entry-digest": { - "bytes_hex": "8f357cf1700de8dbdea8512ceb40438748e972112517522a55e271b097f9cb5c" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hMYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG9ldmlkZW5jZS1kaWdlc3QBWCC362qkNEbWDQoIkIpHQlFQUi6CklBN9iyjnvGrU/NwmqIAa2h0dHAtc3RhdHVzARjIogBwcHJlLWVudHJ5LWRpZ2VzdAFYII81fPFwDejb3qhRLOtAQ4dI6XIRJRdSKlXicbCX+ctcogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED6ejDho/Gjd4luhFw/VJbT0S1bah9DImuAqv4PeAGJ5kEbrMuKI+UXhQWDMr0S6AkkG+i1TOB0aKUVIGZ1UcAMAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" - } - ], - "refused": [ - { - "id": "outcome-v1-schema", - "schema": "auths.gateway-outcome/1", - "subject": "auths-gateway://stripe-refunds/operations/outcome-v1-schema", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8xA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3V0Y29tZS12MS1zY2hlbWEEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQPj63BfEvSVSSSk9YtlKqWpb1bVkCDX4k9qBS0djtO8K+31798TSakACKEBZA2OgpY3YIQmZ/mLBeRLdFo0uRQkCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "http-status-without-response-digest", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/http-status-without-response-digest", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvaHR0cC1zdGF0dXMtd2l0aG91dC1yZXNwb25zZS1kaWdlc3QEGmqxO4UFhaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBD5j1c4+tXRHoPY2abDQXnCO6CePs8F6WKTLRuJdD8lILRWV8UQoxCFHxiHJTW5CB444yFqbidIgzkuT5TprUKAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "code": "audit.outcome-invalid" - }, - { - "id": "refusal-on-response-recorded", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/refusal-on-response-recorded", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "refusal": { - "text": "gateway.transport.not-entered" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hGYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVmdXNhbC1vbi1yZXNwb25zZS1yZWNvcmRlZAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HWdhdGV3YXkudHJhbnNwb3J0Lm5vdC1lbnRlcmVkogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAYz//mpr4sHhXSaT7YmUTr7E9ka5evn/PRlaGgAwIDXyft5LpiSIaYTDEBevOEnEELf1V4O6wQfF55WevYVSnAwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", - "code": "audit.outcome-invalid" - }, - { - "id": "not-entered-without-refusal", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/not-entered-without-refusal", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "not-entered" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hFYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtd2l0aG91dC1yZWZ1c2FsBBpqsTuFBYSiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQLKtmf8KV/JuXsPL2ccbAYzCdm3Qj9lkRy9ySZIn6DjdVBBzDeXvpfHv6zEz1cWKAEoIA4e8FypaMBfYgTpRmwMCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "observation-on-response-recorded", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/observation-on-response-recorded", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "observation": { - "text": "match" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hKYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2YXRpb24tb24tcmVzcG9uc2UtcmVjb3JkZWQEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQL6WFGTg9c3GmjGdCqP8bS5aFFylnHBohvaxC2Qt2Hw5VKfFb9Fg1b9qNEAa5g4oyzrNesdhbfSxW65LTiirugsCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "observed-without-observation", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/observed-without-observation", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hGYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2ZWQtd2l0aG91dC1vYnNlcnZhdGlvbgQaarE7hQWGogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAAOYDgyhCfEUnzGNcISLBBQ/ot76yD/sBtqEZeJ8U3/mmVvS+hS0AHSBgry7rH2c9IyLsdyLN/2sDug98h3JyDgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", - "code": "audit.outcome-invalid" - }, - { - "id": "evidence-digest-on-observed", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/evidence-digest-on-observed", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "observed" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "observation": { - "text": "match" - }, - "evidence-digest": { - "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hFYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvZXZpZGVuY2UtZGlnZXN0LW9uLW9ic2VydmVkBBpqsTuFBYiiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQHEITjOnpojZ/AWCJVI9HuTZjSDLUmWwvucYos54U4UFx9z5CeC+HEvzUN8FgAMKascPr5Lk6alme8MV7SCBngMCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "relative-basis-2-pow-53", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/relative-basis-2-pow-53", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "relative-basis": { - "uint": 9007199254740992 - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVsYXRpdmUtYmFzaXMtMi1wb3ctNTMEGmqxO4UFiKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARsAIAAAAAAAAKIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAnM6PAKMd4VZDjWqBNk53K1EBTI86lbYISkbXS/yt1RSHbKjaDSkfsHV5a9O31ywvDjddrA9V8+FUt21xrdg5AwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", - "code": "audit.outcome-invalid" - }, - { - "id": "relative-basis-digest-without-basis", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/relative-basis-digest-without-basis", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "relative-basis-digest": { - "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVsYXRpdmUtYmFzaXMtZGlnZXN0LXdpdGhvdXQtYmFzaXMEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAPv9zbIAnLzppiKCweG4nIuS84PninFwA5vmu68HcBedLwHdEF5pb3g1x1iuaPRsZ+tCBYbELh2WBpYnuu7aeBQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", - "code": "audit.outcome-invalid" - }, - { - "id": "http-status-99", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/http-status-99", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 99 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g4YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvaHR0cC1zdGF0dXMtOTkEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGGOiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCA32XcWaiDQGdtFqadpX/6cVTtoOkroKQU1LWgSwhjOmKPj3Q0m0AW+N7pjkFgcz+yW5Ov167rJAAV4rKuotQgCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "stage-attempting", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/stage-attempting", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "attempting" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g6YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvc3RhZ2UtYXR0ZW1wdGluZwQaarE7hQWEogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAWphdHRlbXB0aW5nAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCiCym93sUlLpkjTFtxoOmLVAxBfmaX/3oYw0TxkMkh5W5lMBinaB9heCh0/V7cERAUaJu+cceWeTqPipDr08A8CgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", - "code": "audit.outcome-invalid" - }, - { - "id": "unregistered-fact", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/unregistered-fact", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - }, - "provider-status": { - "text": "succeeded" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5yZWdpc3RlcmVkLWZhY3QEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG9wcm92aWRlci1zdGF0dXMBaXN1Y2NlZWRlZKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAlS9BshbbhdPu5h7DOEymvnE5RNwOX7H3W5nV4twRCzYuVR4oS1QQ4F41n8DTlc1uVE245emVaRQ0QcwgdXx0CgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", - "code": "audit.outcome-invalid" - }, - { - "id": "other-signer", - "schema": "auths.gateway-outcome/2", - "subject": "auths-gateway://stripe-refunds/operations/other-signer", - "facts": { - "commitment": { - "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" - }, - "stage": { - "text": "response-recorded" - }, - "evaluated-at": { - "uint": 1790000000 - }, - "recipe-digest": { - "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" - }, - "http-status": { - "uint": 200 - }, - "response-digest": { - "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" - } - }, - "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g2YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3RoZXItc2lnbmVyBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCamVkMjU1MTktdjEBWECDSSwPhSKXugDPuGxTkp5HCeUuqhC3YSWfqusqnm+K7iZ/JH/h2/k2M4dUkqVCeaT1d+xB7HZJ81oZ4SSoytMFAoGkAFggt2Sne23RdULqAGmzXBrGYeM8rpkxlDYCtAXXDSZLvwoBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIGtzSo7/JG/nNLONQEbBSO7l8E/oezoKQjlVp3lW3gZr", - "code": "audit.outcome-invalid" - } - ], - "verdict_trusted_context_b64": "sQC4HgAaAAQAAAEaACAAAAIaACAAAAMQBBAFEAYIBxAIGCAJGgABAAAKGCALGCAMGCANGCAOGgAQAAAPGEAQGQIAERhAEhggEwgUGUAAFRggFggXGgAQAAAYGBhAGBkYIBgaGcNQGBsYgBgcGCAYHQQBWCCViPeetRA4sC2CfCrJ0PBEc2YzgxrDsG_avl2BxSxOogKkAPYBAQIBAwEDga0AZHJvb3QBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCgWpyYXcta2V5LXYxA4GiAGlhdXRocy5tY3ABAgSBogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBYF4HG1jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC8GgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0Bxpqr-oACBpqso0ACfYKAQt4GGdhdGV3YXktb2JzZXJ2ZXItdGVzdC12MQyhAAAErgBYIDc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3AYFqcmF3LWtleS12MQKCamVkMjU1MTktdjFucDI1Ni1zaGEyNTYtdjEDgWpyYXcta2V5LXYxBIAFgAaCcm9mZmxpbmUtdmVyaWZpYWJsZXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXIHgAiBcHVyaS1uYW1lc3BhY2UtdjEJgXJudW1lcmljLWNlaWxpbmctdjEKgXgab2JzZXJ2YXRpb24tcmVxdWlyZW1lbnQtdjELgaIAaWF1dGhzLm1jcAECDIFoZXhhY3QtdjENgAV4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAZYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxpqsTuGCKIAeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEBhKgAAAFyb2ZmbGluZS12ZXJpZmlhYmxlAoAD9gT2BfYG9gcBqAAAAXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXICgAP2BPYF9gb2BwGoAAIBcm9mZmxpbmUtdmVyaWZpYWJsZQKAA_YE9gX2BvYHAagAAgF4GnNlbGYtY2VydGlmeWluZy1pZGVudGlmaWVyAoAD9gT2BfYG9gcBCaYAWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAhv__________wOABIAFgAqmAFggAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAIb__________8DgASABYALcHVyaS1uYW1lc3BhY2UtdjEMaGV4YWN0LXYxDWdub25lLXYxDoGnAHBnYXRld2F5LW9ic2VydmVyAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AoFqcmF3LWtleS12MQOBd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yBIJ4KWF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMveCphdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy8FGmqv6gAGGmqyjQAPgBCA", - "verdicts": [ - { - "id": "not-entered-exhausted", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYmoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhA3wO1iBO8c6Kf6XWmGBAHPS53deeZU5CZkJ_wnwE4KgaW2_Zpola4IGwHlMkYTfn6w0akhKbtX5mJuxHouXJyDwKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBcjFs99ePh4ty5K7E1FO689iABn44h_uZEduWxOB4YfgVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIKM8rEhXuMd1IaaBuxzjmzkUF3wPWVMHQjmgtoYEL3RiDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIJ1Z-KtILQn3DR6qPRK9cacRBKiWoDIcbYebevP2hz--AXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQK8A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAfcv_LoaFXUVFXAlabERtR2XW3AITfWW7zr7ayax8SagcI1FXHKVHQdukrWqQcUOyfGHO-TICup2wYCiVUR1QAgOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggozysSFe4x3UhpoG7HOObORQXfA9ZUwdCOaC2hgQvdGIBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIFakAULRBzhN-89tQzCs7vHcHSM0W3_ddlzu_m5lL9RBAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIJ1Z-KtILQn3DR6qPRK9cacRBKiWoDIcbYebevP2hz--AXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQK8A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCCdWfirSC0J9w0eqj0SvXGnEQSolqAyHG2Hm3rz9oc_vgFZAryjAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzIDeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQEGmqxO4UFhaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGdyZWZ1c2FsAXgfZ2F0ZXdheS5wb2xpY3kud2luZG93LWV4aGF1c3RlZKIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDVfmrcUi5nfxqtgRSYbtLRY7zk6J0pI7Q3HSDkwYK2aQNur5l_AJYGUJ0bnnzxzEgyCjdoWCDxCTaudxp2wrEOAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "not-entered-after-claim", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYnIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeEFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1hZnRlci1jbGFpbQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEAiTLwGZ5TtwKyG1nzz2TbKo6USr1NvnFi1f-cZzeJF0EsPf6WKDPiKjZs34XT9MNrTJhoAunqlyQ6YiAYTSO8LAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGWrz2bIRWF0w4vpJ99FtjqlneobxHdEL9rsQ0dNJhviBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggrjKtgntGfBt5i1zk6xh73ZPei_jbsCfae8otjSakyWgOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggh9P_0wnh95bdXk9UoGdrJpM5gtZYZgkEXWYCW0mTk1sBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAvcDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAfy0gMOORxtK-HOvgD0zp6mDOSxAjjqBdz8fnECqJG_fIlK54EfVF_IgS7_tctoqLZnVzY6j5vCQsDJ2VpO_UCA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCCuMq2Ce0Z8G3mLXOTrGHvdk96L-NuwJ9p7yi2NJqTJaAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggXd69q2VBHRVl3S9SEJbXVIRVq6cuxUYJsXEXaWe7gnEBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggh9P_0wnh95bdXk9UoGdrJpM5gtZYZgkEXWYCW0mTk1sBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAvcDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKN7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW5vdC1lbnRlcmVkLWFmdGVyLWNsYWltIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlijeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1hZnRlci1jbGFpbSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIIfT_9MJ4feW3V5PVKBnayaTOYLWWGYJBF1mAltJk5NbAVkC96MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4QWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL25vdC1lbnRlcmVkLWFmdGVyLWNsYWltBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGdyZWZ1c2FsAXgjZ2F0ZXdheS5jcmVkZW50aWFsLmFjY291bnQtbWlzbWF0Y2iiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA5rSaFWGF0NnA0PUEiqu3gtTFTo1F490Ry7O8FckEoTO_EVj61gWCSYMPrP7ZmvS98ejP-qmIYwhDBQA845glCQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "not-entered-relative-ceiling-above", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYp4GlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeExhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBZsMsX5m3KBx_1Uxd9QIGw7Rn21TpKNXOfgvuUEyw-odTTydM6Z7_Y82f-4gAWID-Z_oSJ8NHKXznVuW2I8PgYCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg5J8PzlzPaTdejmYaNHr1w8mM_qvpXlGip5vatthXk5UFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCDRmVVPblW8fjWyQ8Ib9wBCSsvqsISQ1Jl_2xsE0A3POA5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCDKKbZswwMlV1F-fCzXUSXogPPcG9vhoHKpicEt4oXmngF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDTQNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQMBeKGZ4ffodB_QJOOltdcHrzuHne-5VtqRgaMQR6irk3PWeXlTwwd4DEB7R-Q4Opg5VfkEsq3RVtNznc6YpVAkDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYINGZVU9uVbx-NbJDwhv3AEJKy-qwhJDUmX_bGwTQDc84AYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDcX19D0ubIIAG_6z3ck1JuFF5VM9D-gRyh7JNIyzNH9QGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCDKKbZswwMlV1F-fCzXUSXogPPcG9vhoHKpicEt4oXmngF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDTQNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYrnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggyim2bMMDJVdRfnws11El6IDz3Bvb4aByqYnBLeKF5p4BWQNNowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t_0jB5erH-KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HmdhdGV3YXkucmVsYXRpdmUtY2VpbGluZy5hYm92ZaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQC02kdD33WDdoEG1vPLcNYppIwgNkFdZV_Ky4jI1lKBqqtnr43YUChJ_BQVhmBK2atQLgrHLC1qFZCXuCQGaigMCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "not-entered-pre-entry-condition-false", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeE5hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL25vdC1lbnRlcmVkLXByZS1lbnRyeS1jb25kaXRpb24tZmFsc2UDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhA2VON0vtG1dm11ZGfBmXK1oeiHLDlga6AqqdafDXt_QLEbPkRKcCIHSOdxKdODDj_0bFLcSNjxbRU4fzFEzKNCwKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCCrdrvbmPobbL63o7nNMOnlxS5glrLDmFTJkrw5-hLQ8wVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIKaNUltduOVIn0PLIMRn6ifFNm45hvPIvLC2uIFebUwuDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIIy1ke25t0nUwwNcHwVkk93f3YJE6vNimGhckv02UViWAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMDA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAMy1U4FQMr9a2FxpTNOnFRkjuHkNGPVrudVs-kVw1LsXHXrd650cliGdOO4N4voPGWKA8OVMJ27Mnqtm-PuyZDQOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggpo1SW1245UifQ8sgxGfqJ8U2bjmG88i8sLa4gV5tTC4BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIADg_M0S_a9lfqazCGBChvkHSWaRcdw5kRdNjbH_bqH_AYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIIy1ke25t0nUwwNcHwVkk93f3YJE6vNimGhckv02UViWAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMDA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CVixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggjLWR7bm3SdTDA1wfBWST3d_dgkTq82KYaFyS_TZRWJYBWQMDowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl_nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECjcHwIJ7r68HeNR2izaG_fVA-hqzYr9hHZIpqJnMj1HO3p0H4Ldnj-dloBO7IKs0Crr8fcn8YIEybdNmv9ZJgLAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "unknown", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYjIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy91bmtub3duAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQCXOZTsjbAFrdDDEYctpp0J0wvJwzxRFRRvWYfEIcncTxbnNqD6yX-HffoWLCkCMYkKtST3qZ8fuMcEX358chgMCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggtscH4QeiKkrwlyU8LeHChhPlT3nEiPID0rs38Y7QS6QFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCCXkPnQvqD0PafR7n9I4pr-eEZpePMrCDWM4x6Q8p7erg5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCBtV-Q6XS7f6RHLgQbhQGXZRTHPciIJBZPJsnf4HQX0LwF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDAwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQGl5-F4_aXDX5nY4LMM2t0HDvyjdwlBN1G0xZ-0aCybOAXGFatQ_FI7zXKY9BJOsweeifLyZWlbXhXp1caxnaQYDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIJeQ-dC-oPQ9p9Huf0jimv54Rml48ysINYzjHpDynt6uAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDpctnDwihYmdKgCHeSYDPlsaSG-a5IV00juJ9BQ1cjWQGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCBtV-Q6XS7f6RHLgQbhQGXZRTHPciIJBZPJsnf4HQX0LwF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDAwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYk3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3QtdW5rbm93biJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliTeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggbVfkOl0u3-kRy4EG4UBl2UUxz3IiCQWTybJ3-B0F9C8BWQMDowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t_0jB5erH-KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA-2Rrzwjdx658JuaScuhtqxp-XwSi5BJ8qACcB5iiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEASxOaof7EQccAHKCyzemrYTFZYggrjFwA24ZVn6Hes8fw4kgBIRGR2gmNaqBAMTyALwB3ivuKhouX6oK6PdPMBAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "unknown-without-counters", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYnIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEDsc6guzqgjGCZF2hTLKNV-HsUTE8Dtavij83F80E97PZFjfjJJkqJgZ5VZ5FXKBCHgztyrx-xWv7LFucbrdY8GAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIM5R0dV9avPSfEM6_YdSBJ2pslzxfM1AGmeYY6OHlZL_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggjC_LhKa-3uEoZcNh1ib9RdLbYHMwWoyeFPp0UenxpKUOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggaLE2fboBj78D-4YCuDhdoNngIYAhzZIT6SjNZGLvPGYBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAo4Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWECfL9HKJXGfXiwsuYEejugof_V7oGB-FyGffZwR5mZylXHGmL9MZ9Ma9g6oYdOMqPlk7c9YfIODdiv_7bJmqsUCA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCCML8uEpr7e4Shlw2HWJv1F0ttgczBajJ4U-nRR6fGkpQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggEawiSujqq63f5T--nwOnLEoi7ZYyQrHw2E_vp_960jgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggaLE2fboBj78D-4YCuDhdoNngIYAhzZIT6SjNZGLvPGYBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAo4Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKR7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXVua25vd24td2l0aG91dC1jb3VudGVycyJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlikeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duLXdpdGhvdXQtY291bnRlcnMifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCBosTZ9ugGPvwP7hgK4OF2g2eAhgCHNkhPpKM1kYu88ZgFZAo6jAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzIDeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwQaarE7hQWEogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQAYqgVQ33yqdBqVJ1kVWjKdIiUbJgLTrSdS0d5dqgHqS2ffKK67CUaM-0kStQA_TSh3oq7nvX8_RYq4-opiQ2gYCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "response-recorded", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYloGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEB0ZXrd148H1z3EXfT8R1J0FFkCXlijARzMM_FQ65MgnylZ9bIkoeW1OXmIsBqhIIGOuzv6W3z8bq7VLWXiQ44BAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOpJ6uM9XKEQ0rGQ1-PktKUNkcLESpl4pKPoj2Lh4b_jBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVgg94V_SlSQ2lHVJ9xHyUA1BeJWzWU0uab9-CPqlmXs3jgOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggXj5bc5jnQCCjlIoAej0FyS7cqdqUYsFa_-fNncI4naQBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA10Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEA0w77C3rnmK1Qs85YcAhZAOUEqk44E3ymx68dLrltyNW3QWTpPUUGdHQmes1Y4K3SoUmXBUeX9EO0WCO5OeBYBA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCD3hX9KVJDaUdUn3EfJQDUF4lbNZTS5pv34I-qWZezeOAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggQCfKAOW9XulrexYw6D3p8eINeaZ9kvev-B8p6rcXzHwBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggXj5bc5jnQCCjlIoAej0FyS7cqdqUYsFa_-fNncI4naQBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA10Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIF4-W3OY50Ago5SKAHo9Bcku3KnalGLBWv_nzZ3COJ2kAVkDXaMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkBBpqsTuFBYmiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA_CPy8IdMejbqtTuXqSmMg9yZFsUF-5fWLWj_dv_cuPYkwTRN-HNumfJbu421reYvc-uJunO7o7VRXeP7I0W4DgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "response-recorded-provider-rejected", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEA56u2TPc_sQqjOWhYn-Tikg8P5t3FQjUKDKWhXICaAABAlHOHhzd3zwk_yvEZd-HuHkfq0iyYmRgMSonq7I3AHAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIC3vQYHiKV3io5vn2ugRYRR3k6Oo_6vYnl6MR3m69vT_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggUuw4QpTlVwDJXCdutrkORSC3f7r3dC0nCErBHfcixZUOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggZKQPTnKSNgKQt_tQsHyMEJTf3DAmWFuUvjAow7ubHlsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA3ADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEBp0bZWpvIoufnLzAwbxwYACCAIJ23Tu_ZK1IAMJ1T8no4U594y_c23C3gsbIOyvH63cYz4zhGaEGmsYtVRSuILA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCBS7DhClOVXAMlcJ262uQ5FILd_uvd0LScISsEd9yLFlQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggEqYyV43TDucj1xTyl_BwL3noDSmYDATdxO1p2O7bvq4BgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggZKQPTnKSNgKQt_tQsHyMEJTf3DAmWFuUvjAow7ubHlsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA3ADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIGSkD05ykjYCkLf7ULB8jBCU39wwJlhblL4wKMO7mx5bAVkDcKMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkBBpqsTuFBYmiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGQGQogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG5yZWxhdGl2ZS1iYXNpcwEZA-miAHVyZWxhdGl2ZS1iYXNpcy1kaWdlc3QBWCC6s0D7ZGvPCN3Hrnwm5pJy6G2rGn5fBKLkEnyoAJwHmKIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQNlfstfu8YWUHhFHHU9y3phn5LXMCNo1MvhUyxNa8JwxTdSADcuZ-fLAz-SpPyfs5QFhigRQXsjE-NcO0fkJQAECgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "observed-match", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYkoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDdhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQCLt7c7G3D6NPVEA-r-G8iaudzhhrB-2PjyGPlYUy_wApwByHwn9PrQwsMjFsKl3BT-1YhYg_07l6g5hCjOWpgsCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggAFrwEOQba0G_QEv5t4xDgVynreu24x_bB3QUcY0XBWIFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCDZ0al8ljUr4xnZftTAndOiarHP6w7tlczr3kl1Jq13rQ5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCBzhjqWcqOGQ70cJrl7CO2yYWBlBLlGqWom_MD5wK4IQgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC4ANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQMPoV_ozuYKDAOeskOwt8OrNvC3L9c_DK-Lqb3n4HuSXrZxUoJsLefuIf96KQg-CtCyDQpHotHGNoxfau0iXtAIDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYINnRqXyWNSvjGdl-1MCd06Jqsc_rDu2VzOveSXUmrXetAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDNhA_M95KIjhWTcl3sqesZyE5Y1BAj3KBWAN-hNa7NoAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCBzhjqWcqOGQ70cJrl7CO2yYWBlBLlGqWom_MD5wK4IQgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC4ANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYmnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliaeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1tYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIHOGOpZyo4ZDvRwmuXsI7bJhYGUEuUapaib8wPnArghCAVkC4KMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4N2F1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWF0Y2gEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQHAXmPS-vUmD64Kq7C0q3mvLxM8f26lEs7PsgFtS5rkT6GgPb6ehwmA49v6F66byYiiBYGQ1RQeF3oedz_ISiQQCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "observed-mismatch", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYlYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDphdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1pc21hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQIoOsqU8Hnb24E8_GoaEoEam_jUMXWuG2EpFQbPW3c7wRQVteQSDmKix-VRVmkZbfeipX39LGvuK1xgMw20ACAMCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggSnuqmDji7d-cmF-CpriNq8p-DfV4H1kbyeyehwwhn5EFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCBaPiRBGfGOonPXnEtMO54K9QnhvjwkLySOZxYEccC9mA5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCBqxoViiG1_RK6Mo06b9Mj-IIRvV3TLtrWYZfRALJNutQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC5gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQGEG2i0SOt-bJJX6X1rSND9mrlWw9OWAJgzeT3k8O3SUvkBK_7GMVrL9DpRwN8qRmoWEnZ0hac_6qpmK3L1VXQYDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIFo-JEEZ8Y6ic9ecS0w7ngr1CeG-PCQvJI5nFgRxwL2YAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCCyKwuzzzPw-552oXNn3jOOCYqdkx6U5ANThyNShc-npgGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCBqxoViiG1_RK6Mo06b9Mj-IIRvV3TLtrWYZfRALJNutQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC5gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYnXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWlzbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1taXNtYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIGrGhWKIbX9EroyjTpv0yP4ghG9XdMu2tZhl9EAsk261AVkC5qMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4OmF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWlzbWF0Y2gEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFobWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQHx8p-hyzAEql-_75EWCaJ_k9hcq1_o7EVPZC-kKQ3YFUJiSW73AEZXQUcfRQI5ZCIHlLd7D2QYg-kNsjMRwCQ0CgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "observed-echo-mismatch", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYmoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeD9hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWVjaG8tbWlzbWF0Y2gDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAnb1Rb8HKhRuqFX8u-yz9J3AvpX4qHC_luMA9SD3eXdZZfbjSD5_nM6RjYJHh93wacmhW5Ns13gArXFSdEbo7DQKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCARKAzYLEumQVVFAwyi-Z2IN_iePg0-j5RFH7v8or7RPQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIDaqReEFW_bCMps9eCQn_VwuB13jewikE8tnqIF2zhYrDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYILngDvRXLEyHBwZZJUryo3a2cRfTRrplmY3XiWtRudFEAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLwA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhASMVCm8QsKHinFd8G6DWW5dIHNyek_vdgocqIzUYI2MikdkbT14mfUwn4gkNvg8la7PdMlEmUU6NfmcB0nXlrBAOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggNqpF4QVb9sIymz14JCf9XC4HXeN7CKQTy2eogXbOFisBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIJgBZwtDewXC7R9FC00FnTMqUJCNXofgBrC9JdG004IJAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYILngDvRXLEyHBwZZJUryo3a2cRfTRrplmY3XiWtRudFEAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLwA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggueAO9FcsTIcHBlklSvKjdrZxF9NGumWZjdeJa1G50UQBWQLwowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g_YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYeiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBrb2JzZXJ2YXRpb24BbWVjaG8tbWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQDN_nfIKgDkcfD-LlGMPQaBRwelOnDUuqU06LBsoMdyDcZ0_h8baPWmvnNxcVtW38oCjC45uXUvvK0wIyFi9pAcCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", - "decision": "denied", - "code": "observation-condition-false" - }, - { - "id": "observed-by-provider-after-response", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBskJNk3wveLMR6_f-8S39CncMcg3a5nD5i83YY319VSXElK88YOpG0sQ8ik6kG_ohcApSocZo6053-0hqHqnEAAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIIiJfvNpIannQPrG3m9zkrZ-EoRswyDMUfRPOgBrKBZKBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggXTEeqppKeCxrQS2mxxxRT5xrez5iMgE0FhF60C-gCJ0OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggkjTTzwZ6KKNJZMNq-3N0GW6Wy0QN1IeZmV3OmZbQWTMBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA6cDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEDejj0ZcQDGkj1SBbtKp8MTogBx1v9XNWt71VU6n3fMM_l6TxxCPfweVpoOCsEsVNg_BQ2B0yDQMkfA4xiE_ZMDA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCBdMR6qmkp4LGtBLabHHFFPnGt7PmIyATQWEXrQL6AInQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggqPbCT-I-7RG3S7mRJhVA0FT2zqRr5J0RSQvJHJ50CP8BgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggkjTTzwZ6KKNJZMNq-3N0GW6Wy0QN1IeZmV3OmZbQWTMBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA6cDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW9ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIJI0088GeiijSWTDavtzdBlulstEDdSHmZldzpmW0FkzAVkDp6MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlBBpqsTuFBYqiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBvZXZpZGVuY2UtZGlnZXN0AVggt-tqpDRG1g0KCJCKR0JRUFIugpJQTfYso57xq1PzcJqiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA-2Rrzwjdx658JuaScuhtqxp-XwSi5BJ8qACcB5iiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK_rNkeBAFlgjwaBzJvp6e-9cyTPkB3RmqIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECvx2gCzSlkaD6FkbyBP3pbhpYiIP0Gvhq9PhZ6zxMOxC2IvcO7d3XBM_aiv3zNoJdpag-7qez8vS08EGn3S_oBAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "decision": "authorized", - "code": "authorized" - }, - { - "id": "observed-by-provider-after-unknown", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYpoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeEthdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXVua25vd24DGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAeT-kSuIc8KgN8pCLQNP_Ej69iIq-2u9u3NHnSo13h-PCRjTamkBNVi6PjBe-OQ3M2VI_sg9XNZ9fQqaEJ1SHCgKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAC-t1MYdGRbedBCzqRNOxPsavEPilfFznxXq_AGDuA3gVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YINMruykaUl1TYQkYejgvESOGOFnhgPICOIAseLoYiqzPDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIFCgrtjzu4xXkhmROQLgBw58Wl-0UeY-Ep6F4Ih6QKqrAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLaA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhA8goqMbqH0zTpWW1JeN_69rHV9dPFUC6vyqxyH0crMAebjwv8Wps4T_TcdUPI47i_hK2kbA5hGtqhHLULqWigAQOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVgg0yu7KRpSXVNhCRh6OC8RI4Y4WeGA8gI4gCx4uhiKrM8BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIDrSklnhg-28soHJqiJO4YmfYIYTufxLnHkiaRVnKKLFAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIFCgrtjzu4xXkhmROQLgBw58Wl-0UeY-Ep6F4Ih6QKqrAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLaA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggUKCu2PO7jFeSGZE5AuAHDnxaX7RR5j4SnoXgiHpAqqsBWQLaowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA4oejy1Q-CjIQ_FRLmrMe0QpdmZz5wNOdqZh4FsuWD6CGSmNlxvh1zI1V_GIrmVNnOvLFgtGsAlGOr2BwkmrtDgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", - "decision": "authorized", - "code": "authorized" - }, - { - "id": "observed-by-provider-with-pre-entry", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYp4GlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeExhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLXdpdGgtcHJlLWVudHJ5AxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQGde7MQ_MS_INz2QmVlDJyb4xSnWJIx0wvJpI3Oi3gIjrTWj1m8f8-0Q7PiEZxpRREUSG5LXxpsgdLtCwh6xagECgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggc6z1PutB43hXxnS5hMcHYgp_a0WHpkFq_JxOhyAcHPwFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCCaxMxYqcRFo8bna34KbP15fLBH4aI8piqUgGHIbOWnjw5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCALnD7NA9oUCPt1YK2n5RrjI6pnlT03-VitzzgS4F_RbAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDVwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQGVaLwnGs2-elNESKndDvE32VwOMbnEO1E8FRjeBkSW4M_ovtLHfVIM3AepUe_GI_WkuRLb_lQLxaj_l1lu5_AMDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIJrEzFipxEWjxudrfgps_Xl8sEfhojymKpSAYchs5aePAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCAI04PMQRUQVR53swru3ADlrVikz3DLx-6SaGUhutsvzwGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCALnD7NA9oUCPt1YK2n5RrjI6pnlT03-VitzzgS4F_RbAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDVwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYr3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIAucPs0D2hQI-3VgraflGuMjqmeVPTf5WK3POBLgX9FsAVkDV6MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4TGF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkEGmqxO4UFiKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBvZXZpZGVuY2UtZGlnZXN0AVggt-tqpDRG1g0KCJCKR0JRUFIugpJQTfYso57xq1PzcJqiAGtodHRwLXN0YXR1cwEYyKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl_nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA-now4aPxo3eJboRcP1SW09EtW2ofQyJrgKr-D3gBieZBG6zLiiPlF4UFgzK9EugJJBvotUzgdGilFSBmdVHADAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", - "decision": "authorized", - "code": "authorized" - }, - { - "id": "outcome-v1-schema", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYloGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdXRjb21lLXYxLXNjaGVtYQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBybOVkt_NDODmY1uYI7qnlNxKD6FiUXNi_nI0lAydr0Jr6I-w87WaN4Shs-grk1lbz1YDz4KwONJGKMzQWt9gBAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIK2D_NcDap8GMsStVfvYpsNiJnVkcjPOWtT2pnWlqj90BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggc2CzInLarhDFvSAXgwfZBRqGOZdYo13mCrsVBs-jnogOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg_BLeDa33pQBj0X9qJEhV2CQ3tOcDe4fQjsxmavyeAygBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAtgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAZQFBpMLvreFq3_KVO0CI2L5Tb_3JYLec6yn8wHjV3EukfKu_vBmT_rOyBlhfmLI2CLtQkSnPxDd2kFtoTcI0MA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCBzYLMictquEMW9IBeDB9kFGoY5l1ijXeYKuxUGz6OeiAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggl62NeUmXOSgkXTSM7NJcDl4T2fGCMpqoB3_EQqxYvwgBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg_BLeDa33pQBj0X9qJEhV2CQ3tOcDe4fQjsxmavyeAygBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAtgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW91dGNvbWUtdjEtc2NoZW1hIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdXRjb21lLXYxLXNjaGVtYSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIPwS3g2t96UAY9F_aiRIVdgkN7TnA3uH0I7MZmr8ngMoAVkC2KMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMQN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL291dGNvbWUtdjEtc2NoZW1hBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK_rNkeBAFlgjwaBzJvp6e-9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED4-twXxL0lUkkpPWLZSqlqW9W1ZAg1-JPagUtHY7TvCvt9e_fE0mpAAihAWQNjoKWN2CEJmf5iwXkS3RaNLkUJAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", - "decision": "indeterminate", - "code": "observation-missing" - }, - { - "id": "other-signer", - "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYkYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMgKiAAABeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAh24_T8VOa6d0cNxyJlHT-yoWY6UTPKiDhcV-Ws87e6Na_oSkFC8vUnbJMFbtISTNNP8ZxW0YY3WtxP84WaoHAAKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBmfo5x-8k3xj75dzubWSwsRfJ-BN7eXOUy2N3VWuzgyQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIGWdJu98m3Il22zaIHjSff2TyBxYr87g0DSfrkl4CWwhDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIBOwO9CXVKLhb-Fn6RwZtVh6Fz-wMMvfa_3DofjORRPnAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLTA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAO5A2UGqzj9ZU_9YcTZy2YFMRsGNoAiT004HV3ZW9SaEr8FpRdtFnuOYZjUkVLG0vneacPxS7N8ltuBIRE8IpBwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggZZ0m73ybciXbbNogeNJ9_ZPIHFivzuDQNJ-uSXgJbCEBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIKX5UiTOYROuOnofpXr8n3WJwIkzDARSXdX2YX1yvKQXAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIBOwO9CXVKLhb-Fn6RwZtVh6Fz-wMMvfa_3DofjORRPnAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLTA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", - "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCATsDvQl1Si4W_hZ-kcGbVYehc_sDDL32v9w6H4zkUT5wFZAtOjAKYAAQF4NmtleTpzaGEyNTY6UXgzSkdLb05EaVNUd1pVR0djUGhzU1RZMmpFelQ0aklEOG5RbF9XejZUcwJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzIDeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6UXgzSkdLb05EaVNUd1pVR0djUGhzU1RZMmpFelQ0aklEOG5RbF9XejZUcwJqZWQyNTUxOS12MQFYQINJLA-FIpe6AM-4bFOSnkcJ5S6qELdhJZ-q6yqeb4ruJn8kf-Hb-TYzh1SSpUJ5pPV37EHsdknzWhnhJKjK0wUCgaQAWCC3ZKd7bdF1QuoAabNcGsZh4zyumTGUNgK0BdcNJku_CgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAga3NKjv8kb-c0s41ARsFI7uXwT-h7OgpCOVWneVbeBms", - "decision": "indeterminate", - "code": "observation-missing" - } - ] -} diff --git a/bindings/fixtures/gateway/outcome-v3.json b/bindings/fixtures/gateway/outcome-v3.json new file mode 100644 index 000000000..6bac71148 --- /dev/null +++ b/bindings/fixtures/gateway/outcome-v3.json @@ -0,0 +1,695 @@ +{ + "schema": "auths.gateway-outcome-vectors/1", + "outcome_schema": "auths.gateway-outcome/3", + "observer": { + "seed_byte": 90, + "principal": "key:sha256:WzB6O--wtA9LLP9FZ5qqA0S3Jhnzxy2P_mGmxcJce98" + }, + "observed_at": 1790000005, + "accepted": [ + { + "id": "not-entered-exhausted", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-exhausted", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "refusal": { + "text": "gateway.policy.window-exhausted" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g/YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtZXhoYXVzdGVkBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBncmVmdXNhbAF4H2dhdGV3YXkucG9saWN5LndpbmRvdy1leGhhdXN0ZWSiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA6IsrKoO+6dkvWWlDdPG9ArbjTNETH5ib+0fw8XmzD373hHCxvlI8R7gYAM5pm1BuIRAy6Alhf2BN8JKvZdguCQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "not-entered-after-claim", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-after-claim", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "refusal": { + "text": "gateway.credential.account-mismatch" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtYWZ0ZXItY2xhaW0EGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGdyZWZ1c2FsAXgjZ2F0ZXdheS5jcmVkZW50aWFsLmFjY291bnQtbWlzbWF0Y2iiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhArDl7ZdeBSelRnFBc5zsmcasPTdaFN9Euoa9V7JYac4fAqQowwaFDSuIl4eL90ck1Wx28F390HfiGDb0MRRJ0CQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "not-entered-relative-ceiling-above", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-relative-ceiling-above", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "refusal": { + "text": "gateway.relative-ceiling.above" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZ3JlZnVzYWwBeB5nYXRld2F5LnJlbGF0aXZlLWNlaWxpbmcuYWJvdmWiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAlRLS3vldgkUq8hBPYW0KIf14jXGAeU3rJiXUgxUop02UavJc1JgKHiy1MPXc6nzYtxqTId+J2dl70U1e7infAwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "not-entered-pre-entry-condition-false", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/not-entered-pre-entry-condition-false", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "refusal": { + "text": "gateway.pre-entry.condition-false" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEARobezzfYs89qkgoxd5KgCf+IqTakW+TB8GVOZBCLDmIZklSCIZTWbS1wNDX9Q2kKUXx1bB0uxTO/xmRtOl4YJAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "unknown", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/unknown", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWFogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQBSoZY3nibtVJGOULmmE5x6lzr3naKPars/Hqq47bTaoZDW5q9hV5eaepe+qbkAgkJcfxeZOyimZ18KB+cN4CQQCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "unknown-without-counters", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/unknown-without-counters", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hBYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy91bmtub3duLXdpdGhvdXQtY291bnRlcnMEGmqxO4UFhaIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBlxxD0XMEIQc/d8dtQW9cwM33aGt3lLQbx6NCUzg7XwaS/NBoff9shnvN0sSmh89UhIY3cc8tANPS1YlwOXo8CAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "response-recorded", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/response-recorded", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDHpexzS8MaaCxzxi25N0/wvrv+tFQdbri3yRwy0HLcL2eLS2ym3BQE0vscUsz6zF+wGthqp7G+aYvUcnxSgNUMAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "response-recorded-provider-rejected", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/response-recorded-provider-rejected", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 400 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQtcHJvdmlkZXItcmVqZWN0ZWQEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGQGQogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhARIvF4+s6arpyz1rqmYiAYhVCfQFjNLHDmgkKokayNFY4OWPD8G9LE3rk0FRRJ8rY1CUj7JX+XZGXAz24SGXnBQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-match", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/observed-match", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g3YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1tYXRjaAQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQP/FYdcEWKKP0BlL7BP4lRJnqyNtJ+RFdj21XF3B6KB5ZqhLsPjmnuabh3n8yflPdn9YUDZN6vlGWjNy57iCyAcCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "observed-mismatch", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/observed-mismatch", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g6YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1taXNtYXRjaAQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCWYpwB0wOqnzec1BOwGl0aNzZ6vh+U8c+xNFTK6dEV2IiOokIy6ddmbFrc5mg0lAdOUQ91kJzF9YPkkNMwfLQECgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "observed-echo-mismatch", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/observed-echo-mismatch", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g/YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAM1L1wBubPKBVUojJ0wWG2dIdatUaa9/3H6GtG5VhlurYH6vpJattPjiDdA6WU4ht2mfFfCyt/gIMptnS/EZODgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-by-provider-after-response", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/observed-by-provider-after-response", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItYWZ0ZXItcmVzcG9uc2UEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDCXqxAOXV92LxyYKoni3UAwS/Czoh5TciQ6UwgQlj2zTrqklUkCSsUtUKCNjURSzcnnUr6h10LQ3QAokRZXWwEAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "observed-by-provider-after-unknown", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-after-unknown", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQLgUScs1XcYUgG0vHDGYeoyi0d9L6Ojild0m/2FJkwdgeYaceMkfz5nzRRf34Rb/QtzyDceDTHVokVC46Zem2AECgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "observed-by-provider-with-pre-entry", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-with-pre-entry", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hMYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeQQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQPtatAhCEWKCju8hCmYVPdYjCKSM9oA2d7QdoB7PvQKO5c0jcPLSQF0SGgzkoOOykPSKJC9gZmtzkNGVQILJoAUCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + } + ], + "refused": [ + { + "id": "outcome-v1-schema", + "schema": "auths.gateway-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/outcome-v1-schema", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8xA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3V0Y29tZS12MS1zY2hlbWEEGmqxO4UFhaIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBNnkbi+OK5dg4vtY38858XUshcyrCc9FGgaKhPFFh5ysxb96FLbhdAnKx44noRQax59u7m1RorO8AaLXsUB5cFAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "code": "audit.outcome-invalid" + }, + { + "id": "outcome-v2-schema", + "schema": "auths.gateway-outcome/2", + "subject": "auths-gateway://stripe-refunds/operations/outcome-v2-schema", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8yA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3V0Y29tZS12Mi1zY2hlbWEEGmqxO4UFhaIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDew9Tib2baSrRqvHI+g2Y2bXnlNmXPhn7NGwuLnZLUpepWxtdcvnkpWUB36GKLOW8VK441JR8o2PWC96zgdGIMAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "code": "audit.outcome-invalid" + }, + { + "id": "private-outcome-schema", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/private-outcome-schema", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hAYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcHJpdmF0ZS1vdXRjb21lLXNjaGVtYQQaarE7hQWFogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCJ+mv0YZirI7e0TYc5AvvbMyPWLJGl2iIR9hLWSFoWJRsK+3h15eQkv2flFexz4B/VjsoJxFklwMgdcgmtzhQICgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "other-signer", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/other-signer", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g2YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3RoZXItc2lnbmVyBBpqsTuFBYWiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBZ3Vua25vd24BogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpReDNKR0tvTkRpU1R3WlVHR2NQaHNTVFkyakV6VDRqSUQ4blFsX1d6NlRzAmplZDI1NTE5LXYxAVhAsTzSKBKCcu/4WY0Kvhkw23gF9HZ9v+TmBtN/VCe2CIqysi4+f+cnivclJSunLG8DHOO373gcrnfcRrev7Z3/CgKBpABYILdkp3tt0XVC6gBps1waxmHjPK6ZMZQ2ArQF1w0mS78KAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACBrc0qO/yRv5zSzjUBGwUju5fBP6Hs6CkI5Vad5Vt4Gaw==", + "code": "audit.outcome-invalid" + }, + { + "id": "private-evidence-digest", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/private-evidence-digest", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "evidence-digest": { + "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcHJpdmF0ZS1ldmlkZW5jZS1kaWdlc3QEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBvZXZpZGVuY2UtZGlnZXN0AVggt+tqpDRG1g0KCJCKR0JRUFIugpJQTfYso57xq1PzcJqiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQMZxE+CfI2H1UBuR+ln/BCwjuzWdf7M6AIBN6kcvZAXtPoffN3qQFeqIJ3WZL1mI5Me6HCMzosemTOpRd5Fj5wECgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "private-relative-basis", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/private-relative-basis", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "relative-basis": { + "uint": 1001 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hAYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcHJpdmF0ZS1yZWxhdGl2ZS1iYXNpcwQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQE1B3FJp0BpSsgGAF8x9pACVChRhbKb717M2qEAcDTiU204sz/f7Nih//6K8jpFnZYEsxWu2JIiyeUQaK1MIxAwCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "missing-record-commitment", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/missing-record-commitment", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hDYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbWlzc2luZy1yZWNvcmQtY29tbWl0bWVudAQaarE7hQWEogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQC4oCX5AqORB3Hl+T3ghaEyHAiRCK1ytmwalytWopYtKRL8sIwa8fOr6oRFF9hx9HGClANFw1jszt62t8XRGzw8CgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "raw-action-commitment", + "schema": "auths.gateway-outcome/3", + "subject": "auths-gateway://stripe-refunds/operations/raw-action-commitment", + "facts": { + "effect-reference": { + "text": "9734ab303089c6e850fd6bfd23f39e92985bdd9fc2c9900cc4821a2aeb6219c3" + }, + "record-commitment": { + "text": "2a2833b6b07679695e9560e74e7d0ea775a320dcde1d9e9a33ee9c244870057a" + }, + "recipe-reference": { + "text": "31e72aab32946fbf19d62f1710d3f5755f8e47863ff64ce1d76458310dd9e09d" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g/YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmF3LWFjdGlvbi1jb21taXRtZW50BBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEAOcw3gnr/Xs16Jc1HBGzz8tleCVZaQFjOM91c10U76nWeZFXvFNwl8Dg7D1gKhkitb0mKjvalvz0sPWqZmP/4NAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "code": "audit.outcome-invalid" + } + ], + "verdict_trusted_context_b64": "sQC4HgAaAAQAAAEaACAAAAIaACAAAAMQBBAFEAYIBxAIGCAJGgABAAAKGCALGCAMGCANGCAOGgAQAAAPGEAQGQIAERhAEhggEwgUGUAAFRggFggXGgAQAAAYGBhAGBkYIBgaGcNQGBsYgBgcGCAYHQQBWCCViPeetRA4sC2CfCrJ0PBEc2YzgxrDsG_avl2BxSxOogKkAPYBAQIBAwEDga0AZHJvb3QBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCgWpyYXcta2V5LXYxA4GiAGlhdXRocy5tY3ABAgSBogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBYF4HG1jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC8GgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0Bxpqr-oACBpqso0ACfYKAQt4GGdhdGV3YXktb2JzZXJ2ZXItdGVzdC12MQyhAAAErgBYIDc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3AYFqcmF3LWtleS12MQKCamVkMjU1MTktdjFucDI1Ni1zaGEyNTYtdjEDgWpyYXcta2V5LXYxBIAFgAaCcm9mZmxpbmUtdmVyaWZpYWJsZXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXIHgAiBcHVyaS1uYW1lc3BhY2UtdjEJgXJudW1lcmljLWNlaWxpbmctdjEKgXgab2JzZXJ2YXRpb24tcmVxdWlyZW1lbnQtdjELgaIAaWF1dGhzLm1jcAECDIFoZXhhY3QtdjENgAV4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAZYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxpqsTuGCKIAeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEBhKgAAAFyb2ZmbGluZS12ZXJpZmlhYmxlAoAD9gT2BfYG9gcBqAAAAXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXICgAP2BPYF9gb2BwGoAAIBcm9mZmxpbmUtdmVyaWZpYWJsZQKAA_YE9gX2BvYHAagAAgF4GnNlbGYtY2VydGlmeWluZy1pZGVudGlmaWVyAoAD9gT2BfYG9gcBCaYAWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAhv__________wOABIAFgAqmAFggAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAIb__________8DgASABYALcHVyaS1uYW1lc3BhY2UtdjEMaGV4YWN0LXYxDWdub25lLXYxDoGnAHBnYXRld2F5LW9ic2VydmVyAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AoFqcmF3LWtleS12MQOBd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zBIJ4KWF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMveCphdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy8FGmqv6gAGGmqyjQAPgBCA", + "verdicts": [ + { + "id": "not-entered-exhausted", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYmoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAbbG5LWuuJ4WYbVOQOwLo18pIXYvBRMbVNGF_zIoF6ZbIdYfK_gJ1Wqu0l_KHPdEvWGURjOHv5XLhYONgLwxcCwKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBcjFs99ePh4ty5K7E1FO689iABn44h_uZEduWxOB4YfgVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YII3wLGib8NBP7HCS5fFf30GEtnTSeiZQJEtzVg-uQCFXDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIEcLIyezVET9gHMkdPjWTB4Gm6RPW84EP09__WQOCKzlAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMcA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhA5cFaX9kTBghNcDeC1wWtm923u5lnMqUdkgilQTsa87riZcbVM8RpVvKzGl52nMS9B_mlcNh8G9o9XsgAU3cCDwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggjfAsaJvw0E_scJLl8V_fQYS2dNJ6JlAkS3NWD65AIVcBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIKiWKdAep7zT0xq-jPcfVRtuUc3zmvux3Zk41JvdcbcbAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIEcLIyezVET9gHMkdPjWTB4Gm6RPW84EP09__WQOCKzlAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMcA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCBHCyMns1RE_YBzJHT41kweBpukT1vOBD9Pf_1kDgis5QFZAxyjAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzMDeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGdyZWZ1c2FsAXgfZ2F0ZXdheS5wb2xpY3kud2luZG93LWV4aGF1c3RlZKIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDoiysqg77p2S9ZaUN08b0CtuNM0RMfmJv7R_DxebMPfveEcLG-UjxHuBgAzmmbUG4hEDLoCWF_YE3wkq9l2C4JAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-after-claim", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYnIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeEFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1hZnRlci1jbGFpbQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEADABdBXwWy_1gag_P3nIFprVbG7AA3vAC9AYCCv5yCNESwwBJb_CMxbbVgOGoIaFeX_VP9mcevM69GcAe6M_4MAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGWrz2bIRWF0w4vpJ99FtjqlneobxHdEL9rsQ0dNJhviBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggggWQo_nsxZ8yrT_OvcMdMKyGt_6LA1eDSZ_72ZlnL88OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggCIEISKlD_BjcizPfrIby2_7HEbjeGZFFy9FDCtVBrl0BeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAyIDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAUzJ4gEWkNLHFODGUdA1ehg4vYoBCgeUV3-cyQukpefhBoQ569RG4FHnI4hwd7hpp7LPWVorInJjterY0rA0IBA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCCCBZCj-ezFnzKtP869wx0wrIa3_osDV4NJn_vZmWcvzwGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg5DXwRfsxsqVKiiuBPrOTDr3uGpBTtA5u8Ifl0ItCQJIBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggCIEISKlD_BjcizPfrIby2_7HEbjeGZFFy9FDCtVBrl0BeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAyIDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKN7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW5vdC1lbnRlcmVkLWFmdGVyLWNsYWltIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlijeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1hZnRlci1jbGFpbSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIAiBCEipQ_wY3Isz36yG8tv-xxG43hmRRcvRQwrVQa5dAVkDIqMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4QWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL25vdC1lbnRlcmVkLWFmdGVyLWNsYWltBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBncmVmdXNhbAF4I2dhdGV3YXkuY3JlZGVudGlhbC5hY2NvdW50LW1pc21hdGNoogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQKw5e2XXgUnpUZxQXOc7JnGrD03WhTfRLqGvVeyWGnOHwKkKMMGhQ0riJeHi_dHJNVsdvBd_dB34hg29DEUSdAkCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-relative-ceiling-above", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYp4GlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeExhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQNBhJ3GGZdhKJf1qRHYE-VdhNsAIxTOo2n2SgUCgWUa7g3TetH1ncarkzmWdYWd1oF7BnrFq0sliLEo6ch6RIAcCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg5J8PzlzPaTdejmYaNHr1w8mM_qvpXlGip5vatthXk5UFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCAP1gwHntTa-Y08gPL25TwB12JkG6osruzPstGUAepUqQ5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCAYLM57cWoR2xInl5ntGANUAqyD4bMupOTGDDGJX1AUFQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDKANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQFH6Q016fT0DVzZWN5kVF3pyhIW-Wpc6G4BNT4mqwH6gdL0itGihI_9i_5hsJcyGgdDyJ3ZUAeIO3RjXB_8BWwoDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIA_WDAee1Nr5jTyA8vblPAHXYmQbqiyu7M-y0ZQB6lSpAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDyP5yXjPzPVQL8DgI1aQAAMYKTHUdh8mjA08SCHb83dAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCAYLM57cWoR2xInl5ntGANUAqyD4bMupOTGDDGJX1AUFQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDKANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYrnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggGCzOe3FqEdsSJ5eZ7RgDVAKsg-GzLqTkxgwxiV9QFBUBWQMoowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWGogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZ3JlZnVzYWwBeB5nYXRld2F5LnJlbGF0aXZlLWNlaWxpbmcuYWJvdmWiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAlRLS3vldgkUq8hBPYW0KIf14jXGAeU3rJiXUgxUop02UavJc1JgKHiy1MPXc6nzYtxqTId-J2dl70U1e7infAwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-pre-entry-condition-false", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeE5hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL25vdC1lbnRlcmVkLXByZS1lbnRyeS1jb25kaXRpb24tZmFsc2UDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAbF5LhMCDGYf1PW1J_R2h992sb5UpPRh5otVIU25O4GsE2fX0OrGPMu7VInskPP9ozr7Oj6jVS2-Bd4XTJAUjCgKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCCrdrvbmPobbL63o7nNMOnlxS5glrLDmFTJkrw5-hLQ8wVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIIJ3a3cSD8hE8AAuPuHs4Y0UVHg0eTE3dDRPudqrgTQZDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIN8VPDo_SfnqDRuXwg-yB-sIaaK7wT5TW_SZ61XTBi-YAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMtA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAVHissxp1XaKY6vntT4kKYYUmoMOrvwTdcEgUrzzMIa3bAb1X-m3OL4rxoqlCLdlcEeYJX0ZCD-nrJWc5WAZiCwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVgggndrdxIPyETwAC4-4ezhjRRUeDR5MTd0NE-52quBNBkBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIK18R30_OQQcj0Z3hyxrThH_C3nAwtp0M05iqhUwWeTUAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIN8VPDo_SfnqDRuXwg-yB-sIaaK7wT5TW_SZ61XTBi-YAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMtA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CVixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFgg3xU8Oj9J-eoNG5fCD7IH6whporvBPlNb9JnrVdMGL5gBWQMtowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEARobezzfYs89qkgoxd5KgCf-IqTakW-TB8GVOZBCLDmIZklSCIZTWbS1wNDX9Q2kKUXx1bB0uxTO_xmRtOl4YJAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "unknown", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYjIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy91bmtub3duAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQFWbiZ60MzeFwb6MhEX0laTSndBLGIBPz30IWQwCJlC7zhQwBcmADfI-ffUJ770Hh1ej9XKn--nFx8N3jJwFmQMCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggtscH4QeiKkrwlyU8LeHChhPlT3nEiPID0rs38Y7QS6QFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCAe561RTeAmoHG1OFuRKuF2aYS8oiy2PcT1IrdwuBbtMg5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCATVkvbScTk9I11d4_NAijX84tuotaIbODZfHVlqz0WuAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC3gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQHzchpJOP0nVitI8cUFP3tuAf4-XDs5NkZrrmaqLaeOrC9onBZZAYbq_WoxEeZnNv9XObsq-8ncLXQh-GkzPHwsDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIB7nrVFN4CagcbU4W5Eq4XZphLyiLLY9xPUit3C4Fu0yAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDcbDPkjjpXqPA1NRtiZR8VJNIPNJzImUf57H-JvXirfAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCATVkvbScTk9I11d4_NAijX84tuotaIbODZfHVlqz0WuAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC3gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYk3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3QtdW5rbm93biJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliTeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggE1ZL20nE5PSNdXePzQIo1_OLbqLWiGzg2Xx1Zas9FrgBWQLeowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWFogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQBSoZY3nibtVJGOULmmE5x6lzr3naKPars_Hqq47bTaoZDW5q9hV5eaepe-qbkAgkJcfxeZOyimZ18KB-cN4CQQCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "unknown-without-counters", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYnIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBi2W-NWqnzxNZoP58aT6Dlce779AN6xQbcSxT1R7wBgXjUcRZjsQ9b877kreQQtkkgWi1Prjfl0mBFvu9mh3oJAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIM5R0dV9avPSfEM6_YdSBJ2pslzxfM1AGmeYY6OHlZL_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggESzLLpsp_ZmZlMPX9JYXFZy1cjGxWSutbwYA9-jcdmUOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggh9W9XMfv9BSOuv-B2CW3ti3PiF38tEWtq2K7876MAd0BeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAu4Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAKgEt3ijzItA4JGUjCU_Q9Clvp65pahueDpnBmO2owhtKfrhcd_FYWrxw6LW9e3Bk_u5Z_S3Ra1X8TQbtwILQHA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCARLMsumyn9mZmUw9f0lhcVnLVyMbFZK61vBgD36Nx2ZQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggGbfgyMHbz-DIpiaYsMbkezwv_F0zWdHhIHeWd5gr81EBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggh9W9XMfv9BSOuv-B2CW3ti3PiF38tEWtq2K7876MAd0BeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAu4Dc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKR7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXVua25vd24td2l0aG91dC1jb3VudGVycyJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlikeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duLXdpdGhvdXQtY291bnRlcnMifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCCH1b1cx-_0FI66_4HYJbe2Lc-IXfy0Ra2rYrvzvowB3QFZAu6jAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzMDeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwQaarE7hQWFogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQGXHEPRcwQhBz93x21Bb1zAzfdoa3eUtBvHo0JTODtfBpL80Gh9_2yGe83SxKaHz1SEhjdxzy0A09LViXA5ejwICgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "response-recorded", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYloGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEAmyV-Bw9EjlyhII6_wlY0e7uxCW6eE-B_drPlnpZTMbd-mSWDlSVx_MyBVOncGfLlnH1JOQK7n6PF0VGRQLBEPAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOpJ6uM9XKEQ0rGQ1-PktKUNkcLESpl4pKPoj2Lh4b_jBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggPS0y30ZFYEumW8HhOqqHNdAnynW8L8Wr250e6Vy1jnwOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg5ilF7ivIW3T65cdEV6wucMVmnQfpFN8Y5KcGZCpneOsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAwMDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEC6hfi16MmSDCpuuWCLn65aX8AHMJER-VTh7dwcpuRlC2Rga8VsJAa_Qix1qzh7zoUY6T2i17ukhE5MXLsRsV0IA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA9LTLfRkVgS6ZbweE6qoc10CfKdbwvxavbnR7pXLWOfAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgggnE9kPRnR7xHgqNSMMR1M4A4dEhqxTo7JXOdQLOec8sBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg5ilF7ivIW3T65cdEV6wucMVmnQfpFN8Y5KcGZCpneOsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAwMDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIOYpRe4ryFt0-uXHRFesLnDFZp0H6RTfGOSnBmQqZ3jrAVkDA6MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAx6Xsc0vDGmgsc8YtuTdP8L67_rRUHW64t8kcMtBy3C9ni0tsptwUBNL7HFLM-sxfsBrYaqexvmmL1HJ8UoDVDAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "response-recorded-provider-rejected", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEChtsVG0fHLfnF4gvIM9rLpWcONtWAmHPntDkiRSsD8cBBmhsGXJ6fNjXMCJpwiwjfJuI9xRYAyZAVUEdKH4RkPAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIC3vQYHiKV3io5vn2ugRYRR3k6Oo_6vYnl6MR3m69vT_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVgguaJHWxJXE1WDFDQ3TI843dtaimILOf125u5o5CiGz8QOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg7v6jfmh7_IxfqYcBJpfv1qEX2tN42rt5CbNOYWy28qUBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAxYDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEClS3iP_4_RzCaQui9WLykxuUDqisXItyxaQp0cN6z5Bux_VUXwLg6MHDhAGJwNWzHZ_r9CSyJuyIo2nccq6CEFA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCC5okdbElcTVYMUNDdMjzjd21qKYgs5_Xbm7mjkKIbPxAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg_Rgt4qV2e4fWm4qqJseBDc4Iv_OL2qLZeN8AHb7BG0wBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg7v6jfmh7_IxfqYcBJpfv1qEX2tN42rt5CbNOYWy28qUBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAxYDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIO7-o35oe_yMX6mHASaX79ahF9rTeNq7eQmzTmFstvKlAVkDFqMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARkBkKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQESLxePrOmq6cs9a6pmIgGIVQn0BYzSxw5oJCqJGsjRWODljw_BvSxN65NBUUSfK2NQlI-yV_l2RlwM9uEhl5wUCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-match", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYkoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDdhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQOsIGbXCiVyHFEnbdBjjx8e-H7mSeCTiOKZfxu3FCOcc-cm0uD8Jex1HR1HNqaF2Rk_VvocLNbDFzsskmj1LGwgCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggAFrwEOQba0G_QEv5t4xDgVynreu24x_bB3QUcY0XBWIFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCBwnutvmVIHQf2F6n_ix9oSvMIRPnX1-YKtjF1zWYW_Ug5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCAnA9sl6aD8zEBfP3AYRFhXqfqnN4mfFApWBwkBFFnyEgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC9gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQJ-sC4_sPVlvL6-jrwPsRvbX0LXiKavajVVH2TNf5kO3OigEMhh3Ae9DjfyU2EvakTfXae0Ap-vn0XUk7QIlEgADogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIHCe62-ZUgdB_YXqf-LH2hK8whE-dfX5gq2MXXNZhb9SAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDHEVsnaBla_vlA56oUpFcpa9vwOnx5glW4TECpK6A8GAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCAnA9sl6aD8zEBfP3AYRFhXqfqnN4mfFApWBwkBFFnyEgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC9gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYmnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliaeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1tYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYICcD2yXpoPzMQF8_cBhEWFep-qc3iZ8UClYHCQEUWfISAVkC9qMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4N2F1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWF0Y2gEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWhvYnNlcnZlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED_xWHXBFiij9AZS-wT-JUSZ6sjbSfkRXY9tVxdweigeWaoS7D45p7mm4d5_Mn5T3Z_WFA2Ter5Rlozcue4gsgHAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-mismatch", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYlYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDphdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1pc21hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQOLiwUlj5GHfqK6o7BS-lCVmxTayGbq_dbevxer901NmqXcja8tf4VTicOrLooQ7agMiWj2Z8Spq63HOwdyanAICgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggSnuqmDji7d-cmF-CpriNq8p-DfV4H1kbyeyehwwhn5EFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCDU18oPtEkaMLXUhFHtQTR19kGRLUemwYds80QZ9I7-UQ5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCC17O8Pql3XXqd5uxXgNRdkoeiuvZj4bZBJT5b7zPCJXAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC-QNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQD3ZthJ6EGKvusage2iasZRcO0g1k7Ky9tx9sHH0o0L0NYBzcW7MfXWuMuNy82vlzBYp6SYjC67agQqqY3exmAQDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYINTXyg-0SRowtdSEUe1BNHX2QZEtR6bBh2zzRBn0jv5RAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCCOajaT5tQ8af3auQ1JYMnS9jNCGcz3P5B1uUXpK_HKBgGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCC17O8Pql3XXqd5uxXgNRdkoeiuvZj4bZBJT5b7zPCJXAF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC-QNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYnXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWlzbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1taXNtYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYILXs7w-qXddep3m7FeA1F2Sh6K69mPhtkElPlvvM8IlcAVkC-aMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4OmF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWlzbWF0Y2gEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWhvYnNlcnZlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEAlmKcAdMDqp83nNQTsBpdGjc2er4flPHPsTRUyunRFdiIjqJCMunXZmxa3OZoNJQHTlEPdZCcxfWD5JDTMHy0BAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-echo-mismatch", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYmoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeD9hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWVjaG8tbWlzbWF0Y2gDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAj56ugmfZSPjPEyTq9eynJTGyVGY_Y0IfTsCtmYHn1u3_o_KhAiz73C6Xe08Ay9L5wVN9-CCxDX8l_-57Y9WsCQKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCARKAzYLEumQVVFAwyi-Z2IN_iePg0-j5RFH7v8or7RPQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIFTM-ckvLBDFHKIu8qAhPlH6D1--lAOnIymyhk2KmtCKDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIDI-L5vehOK4omB8K0euaIv4Oo4JaUyvSqnwSkuZX6PqAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQL-A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAXd74BOzLI5FnRdwzSUkmAItGy9iBvS9qvNrYfbueJO74_Glbsbzy4nDxygvhtj8zH9hm_Aeg-LorYB8jal9hCQOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggVMz5yS8sEMUcoi7yoCE-UfoPX76UA6cjKbKGTYqa0IoBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIDj0i9uGCnWSmnzpAI7m6IFQUod4vYVnleNNhMrrbVJGAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIDI-L5vehOK4omB8K0euaIv4Oo4JaUyvSqnwSkuZX6PqAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQL-A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggMj4vm96E4riiYHwrR65oi_g6jglpTK9KqfBKS5lfo-oBWQL-owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3g_YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAM1L1wBubPKBVUojJ0wWG2dIdatUaa9_3H6GtG5VhlurYH6vpJattPjiDdA6WU4ht2mfFfCyt_gIMptnS_EZODgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-by-provider-after-response", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYqIGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEDH8Ypj0BETBpfdhLUgm6tuu3MwX2zgskcjwJiUEi0b6Ao3_mcWrLQBzbtsWSkABEp90IZrispzGu0WZstjfKMBAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIIiJfvNpIannQPrG3m9zkrZ-EoRswyDMUfRPOgBrKBZKBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVgggD5m33A9jExJOaIujjWtHb4riHTak48vCYF0S6ev9HUOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggljzCW1_7gCfO4Vkf1d-kUAEKM0VFZZlZkwhH5r4T1UcBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAxgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEBTWjkyT8VOik7Lww8PE2EN5BtSK44rr8jPS62LrFzzTkoElezlsglVRbM7M5Di-wFWIB7-1Mu6IpacdESEV2oBA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCCAPmbfcD2MTEk5oi6ONa0dviuIdNqTjy8JgXRLp6_0dQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg996oVOgtH2Sux1prw_rwo5cQoiKjI2cpRcFb30VZdnQBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggljzCW1_7gCfO4Vkf1d-kUAEKM0VFZZlZkwhH5r4T1UcBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAxgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW9ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIJY8wltf-4AnzuFZH9XfpFABCjNFRWWZWZMIR-a-E9VHAVkDGKMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlBBpqsTuFBYaiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAwl6sQDl1fdi8cmCqJ4t1AMEvws6IeU3IkOlMIEJY9s066pJVJAkrFLVCgjY1EUs3J51K-oddC0N0AKJEWV1sBAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "observed-by-provider-after-unknown", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYpoGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeEthdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXVua25vd24DGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhA-w6u2RMGqlUcys0tgHbYD9nOtVOqFdLdn1viu_CV03Dfo4vwChUe_oNO1lrLSD6QRjYWLyrZJXm_kkDs7iu8CwKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAC-t1MYdGRbedBCzqRNOxPsavEPilfFznxXq_AGDuA3gVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIGL1HWsnCiMxIzb97rKEe3EDuXOCxVtP24Kda6m_Eek9DlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIHPmc-dXZmSBBvO6rLQdMjbXdJdZahMlCcj6SrG3e7teAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMFA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAqeIb0Q9-psA5Hzu1kSxYaGLsmvTCvBq9dEzzyV0O7yGIf6M5_yngoDmsveSS-_cnEa4YW0hJGXbiv4T_xou6AgOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggYvUdaycKIzEjNv3usoR7cQO5c4LFW0_bgp1rqb8R6T0BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIF9CxtIGkqTHIsjHqP6lZO9MgYEDnf8YeOhtlaOkpw91AYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIHPmc-dXZmSBBvO6rLQdMjbXdJdZahMlCcj6SrG3e7teAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMFA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggc-Zz51dmZIEG87qstB0yNtd0l1lqEyUJyPpKsbd7u14BWQMFowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8zA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQLgUScs1XcYUgG0vHDGYeoyi0d9L6Ojild0m_2FJkwdgeYaceMkfz5nzRRf34Rb_QtzyDceDTHVokVC46Zem2AECgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "observed-by-provider-with-pre-entry", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYp4GlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeExhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLXdpdGgtcHJlLWVudHJ5AxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQAra4DBDZ6eEtG1XkskKE3htnTiRindmy_TENv5Xol6_3tIuceUzLK_oiP0BFLkoZUsrx2pYMADZMqdIQfC85Q8CgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggc6z1PutB43hXxnS5hMcHYgp_a0WHpkFq_JxOhyAcHPwFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCCLieQOZIHqtpxESIcXZWuVyS_dJY430-ndSB2QseZegw5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCCXEcvqkT-dPK0BXGZNmqRAe7kbTmZ-ZZZzsZqVYU-bNgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDFwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQN4C_iflRTI1WFyCXf2wf3URJ2Rqrenre3uWHY6hzzymtPHvvdvl0asR98LpelqMlT2UbTp-T8180YA0vJ33iAQDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIIuJ5A5kgeq2nERIhxdla5XJL90ljjfT6d1IHZCx5l6DAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCBxCI9AM6t6vdV_mgHJjrP9MzKdv-rSMsV-Q20q1qBHCAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCCXEcvqkT-dPK0BXGZNmqRAe7kbTmZ-ZZZzsZqVYU-bNgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDFwNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYr3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIJcRy-qRP508rQFcZk2apEB7uRtOZn5llnOxmpVhT5s2AVkDF6MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMwN4TGF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkEGmqxO4UFhqIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED7WrQIQhFigo7vIQpmFT3WIwikjPaANne0HaAez70CjuXNI3Dy0kBdEhoM5KDjspD0iiQvYGZrc5DRlUCCyaAFAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "outcome-v1-schema", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYloGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdXRjb21lLXYxLXNjaGVtYQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEAjvYl9eathOszS3jEtl3ZG4Dsm94RrMH_2nEUdp6-OW0EDURF0cyu8s_JLycRxmLJUSR9L6BjMPzAkBN9hifgFAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIK2D_NcDap8GMsStVfvYpsNiJnVkcjPOWtT2pnWlqj90BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggA1sBgocl9zT_NZ-l2NDwonjQ3RSfCVTHeOC3Rduf22YOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg5uHueP7GTvTk--AGfPV__h7oJ_aJrp3EaXedTjL60YgBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAugDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEBEpx3SlAL6zXNLU8BOGMSsqwvqFdQKuzWDoWPa1oxqpCwM1GcybBEPw2zGcvtIBNzubGJN3g6-xWGiUglFnCoOA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCADWwGChyX3NP81n6XY0PCieNDdFJ8JVMd44LdF25_bZgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg3J3vHSRzb3dT9jkKSvzMDAbv_s-ES-MZzmEtLmByH-4BgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg5uHueP7GTvTk--AGfPV__h7oJ_aJrp3EaXedTjL60YgBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAugDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW91dGNvbWUtdjEtc2NoZW1hIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdXRjb21lLXYxLXNjaGVtYSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIObh7nj-xk705PvgBnz1f_4e6Cf2ia6dxGl3nU4y-tGIAVkC6KMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMQN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL291dGNvbWUtdjEtc2NoZW1hBBpqsTuFBYWiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBZ3Vua25vd24BogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhATZ5G4vjiuXYOL7WN_POfF1LIXMqwnPRRoGioTxRYecrMW_ehS24XQJyseOJ6EUGsefbu5tUaKzvAGi17FAeXBQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "indeterminate", + "code": "observation-missing" + }, + { + "id": "outcome-v2-schema", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYloGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdXRjb21lLXYyLXNjaGVtYQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEC_wGFzZqeGgYl5avMc0aFRm21jo4jyYJ6MZ_qnCmACBSvKHtKyVud8-jFVxfnldLBrLa-Tc0kOBHg53xTgAZ0FAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIMVCyjPBKEvnihFh4Ms6t1hWLBaPGSYZA5lxqFqwCOQ8BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggNFFCQNmJCoWkv85bdhCBrn97LgGyZ2_lQEzc8HPCYjQOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggRW_8jQJ1qc6T2iO_AjmGmE2Qm5DNoJjTE6mdgZA4_-EBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAugDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWECwxl8SMMkLqhOdC_kRm65f8sAJxcOu3CDAML94HuyIjG1VWMEcMIY5JficLoI3KOQWXscfb6Jd8gGcafHM4ewIA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA0UUJA2YkKhaS_zlt2EIGuf3suAbJnb-VATNzwc8JiNAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggIS4_3gRCnvVxTP26PIYKCuNtn-dvDQ1S-cQgKsBrHZYBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggRW_8jQJ1qc6T2iO_AjmGmE2Qm5DNoJjTE6mdgZA4_-EBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAugDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW91dGNvbWUtdjItc2NoZW1hIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdXRjb21lLXYyLXNjaGVtYSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIEVv_I0CdanOk9ojvwI5hphNkJuQzaCY0xOpnYGQOP_hAVkC6KMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMgN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL291dGNvbWUtdjItc2NoZW1hBBpqsTuFBYWiAHBlZmZlY3QtcmVmZXJlbmNlAXhAOTczNGFiMzAzMDg5YzZlODUwZmQ2YmZkMjNmMzllOTI5ODViZGQ5ZmMyYzk5MDBjYzQ4MjFhMmFlYjYyMTljM6IAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHJlY2lwZS1yZWZlcmVuY2UBeEAzMWU3MmFhYjMyOTQ2ZmJmMTlkNjJmMTcxMGQzZjU3NTVmOGU0Nzg2M2ZmNjRjZTFkNzY0NTgzMTBkZDllMDlkogBxcmVjb3JkLWNvbW1pdG1lbnQBeEAyYTI4MzNiNmIwNzY3OTY5NWU5NTYwZTc0ZTdkMGVhNzc1YTMyMGRjZGUxZDllOWEzM2VlOWMyNDQ4NzAwNTdhogBlc3RhZ2UBZ3Vua25vd24BogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA3sPU4m9m2kq0arxyPoNmNm155TZlz4Z-zRsLi52S1KXqVsbXXL55KVlAd-hiizlvFSuONSUfKNj1gves4HRiDAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "indeterminate", + "code": "observation-missing" + }, + { + "id": "private-outcome-schema", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYm4GlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeEBhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9wcml2YXRlLW91dGNvbWUtc2NoZW1hAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQLwMYgQSdSd3veN7FOY5I8asjDb-oTmokvN6J7AvYVhc9LuJC6beU6pbIvS6xrMaroF2N0IiWuL4eC7zfLaM4wACgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggQZtzXwURz-fdmGMv8Wqda0fjEz_OrBKdDMxFOBXz8hYFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCBVkAql4NJeDqgOClkZbnh23U7D96zdglPIHDbpsBR_Zw5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCDIZiXuYJifo-udYrDJsbEQlguaHH5y9RZQ0aAYu9UtIgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC9gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQBhZNgGO6sft_91Q6Rns8dfk-HztPQpYSV7N2JqwSQahE8OWU9Zv1fMp3aziFxXIGjtircKaGr7YouJhJ_Ma7AYDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIFWQCqXg0l4OqA4KWRlueHbdTsP3rN2CU8gcNumwFH9nAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDHMH7UusZQJRafdta7z5V87JXfW6I9RabUklQoSDGdBwGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCDIZiXuYJifo-udYrDJsbEQlguaHH5y9RZQ0aAYu9UtIgF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC9gNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYonsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3QtcHJpdmF0ZS1vdXRjb21lLXNjaGVtYSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1wcml2YXRlLW91dGNvbWUtc2NoZW1hIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggyGYl7mCYn6PrnWKwybGxEJYLmhx-cvUWUNGgGLvVLSIBWQL2owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hAYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcHJpdmF0ZS1vdXRjb21lLXNjaGVtYQQaarE7hQWFogBwZWZmZWN0LXJlZmVyZW5jZQF4QDk3MzRhYjMwMzA4OWM2ZTg1MGZkNmJmZDIzZjM5ZTkyOTg1YmRkOWZjMmM5OTAwY2M0ODIxYTJhZWI2MjE5YzOiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAHByZWNpcGUtcmVmZXJlbmNlAXhAMzFlNzJhYWIzMjk0NmZiZjE5ZDYyZjE3MTBkM2Y1NzU1ZjhlNDc4NjNmZjY0Y2UxZDc2NDU4MzEwZGQ5ZTA5ZKIAcXJlY29yZC1jb21taXRtZW50AXhAMmEyODMzYjZiMDc2Nzk2OTVlOTU2MGU3NGU3ZDBlYTc3NWEzMjBkY2RlMWQ5ZTlhMzNlZTljMjQ0ODcwMDU3YaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCJ-mv0YZirI7e0TYc5AvvbMyPWLJGl2iIR9hLWSFoWJRsK-3h15eQkv2flFexz4B_VjsoJxFklwMgdcgmtzhQICgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "indeterminate", + "code": "observation-missing" + }, + { + "id": "other-signer", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYkYGlAHBnYXRld2F5LW9ic2VydmVyAXdhdXRocy5nYXRld2F5LW91dGNvbWUvMwKiAAABeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAHoNKWcuIfnlqKSpx2r1MO1uZGXV0iE_hfDZpu-M4Bx5bChdcNP9QbZ_xdqjT1rJE0LNS_CSHu1AfJm1EDE4RDgKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBmfo5x-8k3xj75dzubWSwsRfJ-BN7eXOUy2N3VWuzgyQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIGfohTImOWwjoBy9isA85tozKQX6oBjxz4FhoeKYalRpDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIElXXSqx4n_PQ_sRPO2gMz4ut4ohjuK5GqD5xieFl8GzAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLjA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAdMjY8rheypVXI9WFi-xRM0fVD2bI3_0V1mIQ07vyCe2cHYZvFcCZh9BjSfqywd0esFXob1P0OdlDQ7M48Cy3CgOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggZ-iFMiY5bCOgHL2KwDzm2jMpBfqgGPHPgWGh4phqVGkBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIDQTwCkGo8RWSZo1yRUa4FYmcvAeg4JVwfdx98QxTJX6AYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIElXXSqx4n_PQ_sRPO2gMz4ut4ohjuK5GqD5xieFl8GzAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLjA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCBJV10qseJ_z0P7ETztoDM-LreKIY7iuRqg-cYnhZfBswFZAuOjAKYAAQF4NmtleTpzaGEyNTY6UXgzSkdLb05EaVNUd1pVR0djUGhzU1RZMmpFelQ0aklEOG5RbF9XejZUcwJ3YXV0aHMuZ2F0ZXdheS1vdXRjb21lLzMDeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIEGmqxO4UFhaIAcGVmZmVjdC1yZWZlcmVuY2UBeEA5NzM0YWIzMDMwODljNmU4NTBmZDZiZmQyM2YzOWU5Mjk4NWJkZDlmYzJjOTkwMGNjNDgyMWEyYWViNjIxOWMzogBsZXZhbHVhdGVkLWF0ARpqsTuAogBwcmVjaXBlLXJlZmVyZW5jZQF4QDMxZTcyYWFiMzI5NDZmYmYxOWQ2MmYxNzEwZDNmNTc1NWY4ZTQ3ODYzZmY2NGNlMWQ3NjQ1ODMxMGRkOWUwOWSiAHFyZWNvcmQtY29tbWl0bWVudAF4QDJhMjgzM2I2YjA3Njc5Njk1ZTk1NjBlNzRlN2QwZWE3NzVhMzIwZGNkZTFkOWU5YTMzZWU5YzI0NDg3MDA1N2GiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCamVkMjU1MTktdjEBWECxPNIoEoJy7_hZjQq-GTDbeAX0dn2_5OYG039UJ7YIirKyLj5_5yeK9yUlK6csbwMc47fveByud9xGt6_tnf8KAoGkAFggt2Sne23RdULqAGmzXBrGYeM8rpkxlDYCtAXXDSZLvwoBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIGtzSo7_JG_nNLONQEbBSO7l8E_oezoKQjlVp3lW3gZr", + "decision": "indeterminate", + "code": "observation-missing" + } + ] +} diff --git a/bindings/fixtures/gateway/private-outcome-v1.json b/bindings/fixtures/gateway/private-outcome-v1.json new file mode 100644 index 000000000..05bf9469f --- /dev/null +++ b/bindings/fixtures/gateway/private-outcome-v1.json @@ -0,0 +1,894 @@ +{ + "schema": "auths.gateway-outcome-vectors/1", + "outcome_schema": "auths.gateway-private-outcome/1", + "observer": { + "seed_byte": 90, + "principal": "key:sha256:WzB6O--wtA9LLP9FZ5qqA0S3Jhnzxy2P_mGmxcJce98" + }, + "observed_at": 1790000005, + "accepted": [ + { + "id": "not-entered-exhausted", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-exhausted", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "refusal": { + "text": "gateway.policy.window-exhausted" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g/YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtZXhoYXVzdGVkBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4H2dhdGV3YXkucG9saWN5LndpbmRvdy1leGhhdXN0ZWSiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAO+sxtw2svZTulyeaGeLkvFtkGgztfVBjVAPEO8G5I01rv4YeAMf7Z8vH41v6dAsMmvZThBDv1PLmP5W/Q7fwCgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "not-entered-after-claim", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-after-claim", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "refusal": { + "text": "gateway.credential.account-mismatch" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtYWZ0ZXItY2xhaW0EGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZ3JlZnVzYWwBeCNnYXRld2F5LmNyZWRlbnRpYWwuYWNjb3VudC1taXNtYXRjaKIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECCcdPxUEezkXtHM38Ss+Px6yqlp15Jk1QswRpsIfwU7Tz5+qcuyas+KstDpTkaOoJAxvwqrWKSy0QrofPFvfgFAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "not-entered-relative-ceiling-above", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-relative-ceiling-above", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "refusal": { + "text": "gateway.relative-ceiling.above" + }, + "relative-basis": { + "uint": 1001 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t/0jB5erH+KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HmdhdGV3YXkucmVsYXRpdmUtY2VpbGluZy5hYm92ZaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQDUTq5F4H/al00COHVSw+/QnrAhUnqjsq+1JOxcWjvd4K/5kEEw+dYnR2Nc/2u4Z9V5hZFp2R+S9+unWpcphDwkCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "not-entered-pre-entry-condition-false", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/not-entered-pre-entry-condition-false", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "pre-entry-digest": { + "bytes_hex": "8f357cf1700de8dbdea8512ceb40438748e972112517522a55e271b097f9cb5c" + }, + "refusal": { + "text": "gateway.pre-entry.condition-false" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl/nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBgh44g2G4433BU2jeS81EnPeO1Cehqej0g/bf4S67vuovcljTitX+WGe2pZJ5lDYbFalmag34S6tBDkbOPwD4LAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "unknown", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/unknown", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "relative-basis": { + "uint": 1001 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t/0jB5erH+KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA+2Rrzwjdx658JuaScuhtqxp+XwSi5BJ8qACcB5iiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECtrVEtwcI/6P72o4lBB0/fFSal2Jh64r4few5yUh8Pg/wuus2OPb0Go1b3yY3LjYis3qgpgtwcmZfx5LltCvYJAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "unknown-without-counters", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/unknown-without-counters", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "unknown" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hBYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy91bmtub3duLXdpdGhvdXQtY291bnRlcnMEGmqxO4UFhKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEAYNUs+eDkXO0sK/PjLDBFwW8skliZNwtJpZx93aap9uDzC5wyk1A9EEMe6YWpM++RXZ6UrrroK+i9+VyIbo6QKAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "response-recorded", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/response-recorded", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "relative-basis": { + "uint": 1001 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQEGmqxO4UFiaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA+2Rrzwjdx658JuaScuhtqxp+XwSi5BJ8qACcB5iiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECmt7Rx57WPOHdKEP0KAuy7NsZ0Lpeu3XO0Pa01hw2QIV68JUtYBCs30i/Y1+ZVzG94yxXSpJA3cYBhW1Vfw1wBAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + }, + { + "id": "response-recorded-provider-rejected", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/response-recorded-provider-rejected", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "http-status": { + "uint": 400 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "relative-basis": { + "uint": 1001 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVzcG9uc2UtcmVjb3JkZWQtcHJvdmlkZXItcmVqZWN0ZWQEGmqxO4UFiaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEZAZCiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhATIvGj1NeGYEHnxrBT9Y3W44ldzHbs58Z2uKOdCBHNYBAdYP1wOf9bQyNA1DOEXRcLuAcHXW3xcr16X7acDa7BwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-match", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/observed-match", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "observation": { + "text": "match" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g3YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1tYXRjaAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAa29ic2VydmF0aW9uAWVtYXRjaKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhANIJwjI4bppTZWzdJhGFqys+mcM2SeSuQVszQapBuQD4a9Ogu6km+kmV7hmoqnJLBk3P3X6i3jdg8gFTd2cy7AgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-mismatch", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/observed-mismatch", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "observation": { + "text": "mismatch" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g6YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1taXNtYXRjaAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAa29ic2VydmF0aW9uAWhtaXNtYXRjaKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA5BqbRwTPLdWSSg+LW6TdjBostt03fT1NFwJ9B5GUi1OY9RxYwvJeLoXHj+QN6NhpMgC1rhXW5IYtTOaw1cbNDAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-echo-mismatch", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/observed-echo-mismatch", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "observation": { + "text": "echo-mismatch" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g/YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYeiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBrb2JzZXJ2YXRpb24BbWVjaG8tbWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCFG6kZWRYrlGib8kJMUPjBo0NNzOk6EQQNm21FO+6aCKWpyMteAKMASstgJRopjhJ/wdbkFaPqF0NyAAOCd0gwCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "observed-by-provider-after-response", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/observed-by-provider-after-response", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "counters-digest": { + "bytes_hex": "8acde68b8f457c2712faad9bda1d0b6edc3b70c22e62eedff48c1e5eac7f8a00" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "evidence-digest": { + "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" + }, + "relative-basis": { + "uint": 1001 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItYWZ0ZXItcmVzcG9uc2UEGmqxO4UFiqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBvY291bnRlcnMtZGlnZXN0AVggis3mi49FfCcS+q2b2h0Lbtw7cMIuYu7f9IweXqx/igCiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG9ldmlkZW5jZS1kaWdlc3QBWCC362qkNEbWDQoIkIpHQlFQUi6CklBN9iyjnvGrU/NwmqIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG5yZWxhdGl2ZS1iYXNpcwEZA+miAHVyZWxhdGl2ZS1iYXNpcy1kaWdlc3QBWCC6s0D7ZGvPCN3Hrnwm5pJy6G2rGn5fBKLkEnyoAJwHmKIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQBz6e/7l4j1Ke50ORUGsWkgEdCns6w5ONJqjFOTKf/Kr6VFwu8evM3ApqxjO2wr78dYeBlGm0rjWXkpN+NqDJQ4CgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=" + }, + { + "id": "observed-by-provider-after-unknown", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-after-unknown", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "evidence-digest": { + "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAcfvb3syFijWnUddkt9qqPEDQBrYIUoiJF1i50umz2hxNAdDGfj2MpwohyURrVwQ2jK7X612mbHqambALUnMoDwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==" + }, + { + "id": "observed-by-provider-with-pre-entry", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://airtable-demo/operations/observed-by-provider-with-pre-entry", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed-by-provider" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "evidence-digest": { + "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" + }, + "pre-entry-digest": { + "bytes_hex": "8f357cf1700de8dbdea8512ceb40438748e972112517522a55e271b097f9cb5c" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hMYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG9ldmlkZW5jZS1kaWdlc3QBWCC362qkNEbWDQoIkIpHQlFQUi6CklBN9iyjnvGrU/NwmqIAa2h0dHAtc3RhdHVzARjIogBwcHJlLWVudHJ5LWRpZ2VzdAFYII81fPFwDejb3qhRLOtAQ4dI6XIRJRdSKlXicbCX+ctcogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBS2vfPb2BoKyEUTXDmAfLNlwzwnGkNnkA92EbwADhMhVVnVuxiR/PPGuhwSkJT+Ee0cg2xS+gBPV+Aqraw3VkDAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw" + } + ], + "refused": [ + { + "id": "outcome-v1-schema", + "schema": "auths.gateway-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/outcome-v1-schema", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCd2F1dGhzLmdhdGV3YXktb3V0Y29tZS8xA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3V0Y29tZS12MS1zY2hlbWEEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQPj63BfEvSVSSSk9YtlKqWpb1bVkCDX4k9qBS0djtO8K+31798TSakACKEBZA2OgpY3YIQmZ/mLBeRLdFo0uRQkCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "http-status-without-response-digest", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/http-status-without-response-digest", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvaHR0cC1zdGF0dXMtd2l0aG91dC1yZXNwb25zZS1kaWdlc3QEGmqxO4UFhaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEDMSF6ISvnFdtzaNhwvR573z5h3t8Pn5yqdsHBHWoiFpLrvN9ijKYUVt8uuts2ox8nTygNQOEPwPa4gUbNueYAHAoGkAFggqhSI2pMFeBC2xC4+/w/whRfOr51AnfdUr+D0/MTy/N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "code": "audit.outcome-invalid" + }, + { + "id": "refusal-on-response-recorded", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/refusal-on-response-recorded", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "refusal": { + "text": "gateway.transport.not-entered" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hGYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVmdXNhbC1vbi1yZXNwb25zZS1yZWNvcmRlZAQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HWdhdGV3YXkudHJhbnNwb3J0Lm5vdC1lbnRlcmVkogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA05Af5GbVqd/EwIW/1kC5M7Ij98ZsRDNK6SPlqB7NKEj6SqkQAqSchwQ5OwuHd3l/sFJk1L8nsLUnIUPinKpnDAKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", + "code": "audit.outcome-invalid" + }, + { + "id": "not-entered-without-refusal", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/not-entered-without-refusal", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "not-entered" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hFYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtd2l0aG91dC1yZWZ1c2FsBBpqsTuFBYSiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQA1mPEHoIUKIJfP4DtViTRB2OUWIndLifM19yE7DujuHAxhmAYscsW0qfJ+MY7IVqcFDkmdF3NA+4a1BcQ4Lsg8CgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "observation-on-response-recorded", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/observation-on-response-recorded", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "observation": { + "text": "match" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hKYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2YXRpb24tb24tcmVzcG9uc2UtcmVjb3JkZWQEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQKeLtiKsKBhROVwbzGF8/VN2W5e4E8wlV8Sqc4U8/ubGv0yOS2A5vq+nufAxyPf/SMmMsNFtWxxmErUvQEFkMQQCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "observed-without-observation", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/observed-without-observation", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hGYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb2JzZXJ2ZWQtd2l0aG91dC1vYnNlcnZhdGlvbgQaarE7hQWGogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFob2JzZXJ2ZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAOlRHErAeFW9CDukodpCDrShvoAFiLJfk6NAnUpKbEG5dCDMZiDowM4TSN01GSfAlcDhcPOdVsMRmISJxDg0gCgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", + "code": "audit.outcome-invalid" + }, + { + "id": "evidence-digest-on-observed", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/evidence-digest-on-observed", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "observed" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "observation": { + "text": "match" + }, + "evidence-digest": { + "bytes_hex": "b7eb6aa43446d60d0a08908a47425150522e8292504df62ca39ef1ab53f3709a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hFYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvZXZpZGVuY2UtZGlnZXN0LW9uLW9ic2VydmVkBBpqsTuFBYiiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQBw4XSfEnJO9F4TdzCQyNI4gd3lHGdzXzWFNukgZMy5+BEYOxpBhuKUIBD6KPzRAcBJ/CxUGDb3DTicN2Iou4gsCgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "relative-basis-2-pow-53", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/relative-basis-2-pow-53", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "relative-basis": { + "uint": 9007199254740992 + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hBYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVsYXRpdmUtYmFzaXMtMi1wb3ctNTMEGmqxO4UFiKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARsAIAAAAAAAAKIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhASMcjGSaIUEMoGBjD5Js+AJNmRJUhXXqzYpikIGf0GBAEbi7+DaGjWC4NP46+e5tONc30doAWuVX9XAGz02lvAwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", + "code": "audit.outcome-invalid" + }, + { + "id": "relative-basis-digest-without-basis", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/relative-basis-digest-without-basis", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "relative-basis-digest": { + "bytes_hex": "bab340fb646bcf08ddc7ae7c26e69272e86dab1a7e5f04a2e4127ca8009c0798" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hNYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvcmVsYXRpdmUtYmFzaXMtZGlnZXN0LXdpdGhvdXQtYmFzaXMEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA1CPqQOPnXjtI707hvJSRl2dlNvGbJO4YDuOFDGfxzWFeZ6cPo7699laucWbT0GHir8UCVda0SuMgfHp+GU77AgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", + "code": "audit.outcome-invalid" + }, + { + "id": "http-status-99", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/http-status-99", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 99 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g4YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvaHR0cC1zdGF0dXMtOTkEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGGOiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr+s2R4EAWWCPBoHMm+np771zJM+QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQOJznC20uIW1/AL+3pd4xkoFgHKEQcFsuOjrHfRUOY8RrDNStLS7mjKwZH5XjlO4pP3gEGT8s4FAeBDVxynSJg4CgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "stage-attempting", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/stage-attempting", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "attempting" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g6YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvc3RhZ2UtYXR0ZW1wdGluZwQaarE7hQWEogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAWphdHRlbXB0aW5nAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQOrFarXiXPxF8Mjid71s96FI03SUn4k/a4ZIm7Xm7+OIKc34t3eQNdZJ1fFhWdkL78aTM/cWvZOOv8Mb5WNcvQICgaQAWCCqFIjakwV4ELbELj7/D/CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN+71gmA1dmubPloVhoqUCrKJlYeI47A=", + "code": "audit.outcome-invalid" + }, + { + "id": "unregistered-fact", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/unregistered-fact", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + }, + "provider-status": { + "text": "succeeded" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g7YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5yZWdpc3RlcmVkLWZhY3QEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG9wcm92aWRlci1zdGF0dXMBaXN1Y2NlZWRlZKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhA83cA/sXR71H2XliCnHWiSIcRor7Ny3VR3kr3RF3/RObTpBXklBFuuh4tpsSQG3RTIG/f4qkrypwcifC0w5qrDgKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq+dQJ33VK/g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s+WhWGipQKsomVh4jjsA==", + "code": "audit.outcome-invalid" + }, + { + "id": "other-signer", + "schema": "auths.gateway-private-outcome/1", + "subject": "auths-gateway://stripe-refunds/operations/other-signer", + "facts": { + "commitment": { + "text": "2140544cbb5400177dc13269ccea1ee4f40133ead3dab72964009605bf63b2b5" + }, + "stage": { + "text": "response-recorded" + }, + "evaluated-at": { + "uint": 1790000000 + }, + "recipe-digest": { + "text": "c3a2887a2ae0dd4f9665d05be14bc9488b143793a5b22098aa2debcc42dd020a" + }, + "http-status": { + "uint": 200 + }, + "response-digest": { + "bytes_hex": "e15948e4ee018aa4afeb3647810059608f0681cc9be9e9efbd7324cf901dd19a" + } + }, + "observation_b64": "owCmAAEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g2YXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvb3RoZXItc2lnbmVyBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK/rNkeBAFlgjwaBzJvp6e+9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OlF4M0pHS29ORGlTVHdaVUdHY1Boc1NUWTJqRXpUNGpJRDhuUWxfV3o2VHMCamVkMjU1MTktdjEBWEDZ3S0cBxA9XAEscYYAaoKxNB2R0xWqSjG5/gavCYDw37mi4XK71aCoP4z8UBkGCyCbCrf3/IQ6rXnIhNmN4DIIAoGkAFggt2Sne23RdULqAGmzXBrGYeM8rpkxlDYCtAXXDSZLvwoBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIGtzSo7/JG/nNLONQEbBSO7l8E/oezoKQjlVp3lW3gZr", + "code": "audit.outcome-invalid" + } + ], + "verdict_trusted_context_b64": "sQC4HgAaAAQAAAEaACAAAAIaACAAAAMQBBAFEAYIBxAIGCAJGgABAAAKGCALGCAMGCANGCAOGgAQAAAPGEAQGQIAERhAEhggEwgUGUAAFRggFggXGgAQAAAYGBhAGBkYIBgaGcNQGBsYgBgcGCAYHQQBWCCViPeetRA4sC2CfCrJ0PBEc2YzgxrDsG_avl2BxSxOogKkAPYBAQIBAwEDga0AZHJvb3QBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCgWpyYXcta2V5LXYxA4GiAGlhdXRocy5tY3ABAgSBogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBYF4HG1jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC8GgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0Bxpqr-oACBpqso0ACfYKAQt4GGdhdGV3YXktb2JzZXJ2ZXItdGVzdC12MQyhAAAErgBYIDc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3AYFqcmF3LWtleS12MQKCamVkMjU1MTktdjFucDI1Ni1zaGEyNTYtdjEDgWpyYXcta2V5LXYxBIAFgAaCcm9mZmxpbmUtdmVyaWZpYWJsZXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXIHgAiBcHVyaS1uYW1lc3BhY2UtdjEJgXJudW1lcmljLWNlaWxpbmctdjEKgXgab2JzZXJ2YXRpb24tcmVxdWlyZW1lbnQtdjELgaIAaWF1dGhzLm1jcAECDIFoZXhhY3QtdjENgAV4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAZYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxpqsTuGCKIAeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEBhKgAAAFyb2ZmbGluZS12ZXJpZmlhYmxlAoAD9gT2BfYG9gcBqAAAAXgac2VsZi1jZXJ0aWZ5aW5nLWlkZW50aWZpZXICgAP2BPYF9gb2BwGoAAIBcm9mZmxpbmUtdmVyaWZpYWJsZQKAA_YE9gX2BvYHAagAAgF4GnNlbGYtY2VydGlmeWluZy1pZGVudGlmaWVyAoAD9gT2BfYG9gcBCaYAWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAhv__________wOABIAFgAqmAFggAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAIb__________8DgASABYALcHVyaS1uYW1lc3BhY2UtdjEMaGV4YWN0LXYxDWdub25lLXYxDoGnAHBnYXRld2F5LW9ic2VydmVyAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AoFqcmF3LWtleS12MQOBeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xBIJ4KWF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMveCphdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy8FGmqv6gAGGmqyjQAPgBCA", + "verdicts": [ + { + "id": "not-entered-exhausted", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYo4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAuhdcGOdXFyERFANmFA8WqqFL3pz-xog-E7GYSPtfKBp3MmE32Ec5A2hOL_zDhjocuTstl_Jjn-geZwzqkuuyCgKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBcjFs99ePh4ty5K7E1FO689iABn44h_uZEduWxOB4YfgVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIE3mHk9lWCpWdbtMwEF2ROe3LAFPCA1FXS-9a-ZINascDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIOj1YZjb2Kcjg0mQrPLE-Sedw-WpZezvY6kLKKCPvZzrAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLFA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAHefsGU9r0vSfgCcWOpZvhh0gXFXdzaNWRfV45AZVj7FnbIfjhrILYtwXiy5LIQGsiJkAAqK3P3LqVaElI2q3BwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggTeYeT2VYKlZ1u0zAQXZE57csAU8IDUVdL71r5kg1qxwBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIAauJtK8cReWKYDBE317QEmOvg2LI2BV89PffEdGEYGOAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIOj1YZjb2Kcjg0mQrPLE-Sedw-WpZezvY6kLKKCPvZzrAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLFA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliheyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1leGhhdXN0ZWQifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCDo9WGY29inI4NJkKzyxPknncPlqWXs72OpCyigj72c6wFZAsWjAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ4H2F1dGhzLmdhdGV3YXktcHJpdmF0ZS1vdXRjb21lLzEDeD9hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1leGhhdXN0ZWQEGmqxO4UFhaIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGdyZWZ1c2FsAXgfZ2F0ZXdheS5wb2xpY3kud2luZG93LWV4aGF1c3RlZKIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEA76zG3Day9lO6XJ5oZ4uS8W2QaDO19UGNUA8Q7wbkjTWu_hh4Ax_tny8fjW_p0Cwya9lOEEO_U8uY_lb9Dt_AKAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-after-claim", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYpYGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeEFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1hZnRlci1jbGFpbQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBgNondaO1cL4KtLHaULleWpbYLQ14tLJ_cPgTFGoHTY-X55jV5W_WWL0dDhK95Y0zrO7evzlxMHtqMDRGRErcMAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGWrz2bIRWF0w4vpJ99FtjqlneobxHdEL9rsQ0dNJhviBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggU8Oi_FsKj9yPT_hnUVGLqOWX8kArnG_0TYDwD3CRzj0OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggJ1CyHkhsJVsimNSncFmL1aB7vw4SHUau_eRrrn90JEsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAwADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEBK3wqWNHgQEHMM9-sDVEaZYCCkykUjOEC062DH57KOPtZPxY_vKUsfjcSyz_rZNLsXj_bOuJc21lduN9G3WpMBA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCBTw6L8WwqP3I9P-GdRUYuo5ZfyQCucb_RNgPAPcJHOPQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggstdeD7135x9EIFIjMA3q0-u4i9izihqZb3w8fcEMxaABgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggJ1CyHkhsJVsimNSncFmL1aB7vw4SHUau_eRrrn90JEsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAwADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKN7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW5vdC1lbnRlcmVkLWFmdGVyLWNsYWltIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlijeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1hZnRlci1jbGFpbSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYICdQsh5IbCVbIpjUp3BZi9Wge78OEh1Grv3ka65_dCRLAVkDAKMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4QWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL25vdC1lbnRlcmVkLWFmdGVyLWNsYWltBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGdyZWZ1c2FsAXgjZ2F0ZXdheS5jcmVkZW50aWFsLmFjY291bnQtbWlzbWF0Y2iiAGVzdGFnZQFrbm90LWVudGVyZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAgnHT8VBHs5F7RzN_ErPj8esqpadeSZNULMEabCH8FO08-fqnLsmrPirLQ6U5GjqCQMb8Kq1ikstEK6Hzxb34BQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-relative-ceiling-above", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYsIGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeExhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQILivUJRmS2vWu9sOjFlwn8kS_wDPgDagKo1JAmRenF571sSyvEjuEQg6pe7fW-g1vlned2ezLlYt6P9Ku0wnw4CgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFgg5J8PzlzPaTdejmYaNHr1w8mM_qvpXlGip5vatthXk5UFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCBDZr05qMttY1eRQ95zQqtPJ8oI5-AY02tbjEv5XRP8rw5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCD8upOZUFEYphL-8onzG3jOA-Cf83eMmNVvFkgAbO1x1gF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDVgNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQER082NtsDkAd8AWzSf-Um2rpp8wWrSevRnyIeuHWKGjTv_DC8YLOdsEZjBSeZy8Uz-mNTQaZtA60ZLgjhFUFA4DogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIENmvTmoy21jV5FD3nNCq08nygjn4BjTa1uMS_ldE_yvAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCBZx7csKU8Gfx0PKrj8IvIIk2V64Yj2pHjcUhseG8N7EQGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCD8upOZUFEYphL-8onzG3jOA-Cf83eMmNVvFkgAbO1x1gF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDVgNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYrnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1yZWxhdGl2ZS1jZWlsaW5nLWFib3ZlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFgg_LqTmVBRGKYS_vKJ8xt4zgPgn_N3jJjVbxZIAGztcdYBWQNWowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hMYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvbm90LWVudGVyZWQtcmVsYXRpdmUtY2VpbGluZy1hYm92ZQQaarE7hQWIogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t_0jB5erH-KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4HmdhdGV3YXkucmVsYXRpdmUtY2VpbGluZy5hYm92ZaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBlc3RhZ2UBa25vdC1lbnRlcmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQDUTq5F4H_al00COHVSw-_QnrAhUnqjsq-1JOxcWjvd4K_5kEEw-dYnR2Nc_2u4Z9V5hZFp2R-S9-unWpcphDwkCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "not-entered-pre-entry-condition-false", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYsoGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeE5hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL25vdC1lbnRlcmVkLXByZS1lbnRyeS1jb25kaXRpb24tZmFsc2UDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAHSrflSB4Mitgj_BIRHZjFySJjODkLQhDmXXimBpjxNejN6uzaZG2VeuJdUKhOGJCNd4RMuHJYIJRAqOrirQ_DAKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCCrdrvbmPobbL63o7nNMOnlxS5glrLDmFTJkrw5-hLQ8wVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YINsUexq4iUkDfj9VGek-gd-3SId93x31N4VuqFTsonk0DlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIGLk1Vj0tvpRRC6RPj4XBvsE5GZ5qSDygRkPS7R15aknAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMMA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAKQ8JNAtAxscVhtY47DhP_sgHkZ0shqniyIWunauAorsrjzCZyl2L9tphjNQUp9Zwpfg1b6W7CNPD-YUm2Ee9CwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVgg2xR7GriJSQN-P1UZ6T6B37dIh33fHfU3hW6oVOyieTQBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIL39S-Dx2FGmr_KoRL5Fpyn4x5hUEGCzl5DCftGJyCHhAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIGLk1Vj0tvpRRC6RPj4XBvsE5GZ5qSDygRkPS7R15aknAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQMMA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CVixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlixeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggYuTVWPS2-lFELpE-PhcG-wTkZnmpIPKBGQ9LtHXlqScBWQMMowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hOYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9ub3QtZW50ZXJlZC1wcmUtZW50cnktY29uZGl0aW9uLWZhbHNlBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl_nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBncmVmdXNhbAF4IWdhdGV3YXkucHJlLWVudHJ5LmNvbmRpdGlvbi1mYWxzZaIAZXN0YWdlAWtub3QtZW50ZXJlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEBgh44g2G4433BU2jeS81EnPeO1Cehqej0g_bf4S67vuovcljTitX-WGe2pZJ5lDYbFalmag34S6tBDkbOPwD4LAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "unknown", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYlYGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDFhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy91bmtub3duAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQBSPhTYp4HDMsGRfpU_dp3oMdC6DzthAOmSR9vU43EE3SwZJqAN6W8IYkxjW2erbxgxq5lnv5BTUbDF8DiiTXQoCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggtscH4QeiKkrwlyU8LeHChhPlT3nEiPID0rs38Y7QS6QFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCCIZiTRp5jrbzKduwyA_7OvZyuaewhEaRJ3ZZ6Y6iV3ag5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCCXy2bW5-SPR8KfLQa_-DczgSRA4CFkqdtqjHchwxCx9QF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDDANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQMEGtdsPf4XDJ8aAhMmY4s2P6ezfBF6ZTDuaFI6MLNJVprNLUopAhWgstQA1vyncnNGzJr4gM521vwUioXDC1QADogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIIhmJNGnmOtvMp27DID_s69nK5p7CERpEndlnpjqJXdqAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCBJInpCz1JIdCxw5MKvaKLDPhMT0xd0e3fmrvWpGD2FrgGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCCXy2bW5-SPR8KfLQa_-DczgSRA4CFkqdtqjHchwxCx9QF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDDANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYk3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3QtdW5rbm93biJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliTeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggl8tm1ufkj0fCny0Gv_g3M4EkQOAhZKnbaox3IcMQsfUBWQMMowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3gxYXV0aHMtZ2F0ZXdheTovL3N0cmlwZS1yZWZ1bmRzL29wZXJhdGlvbnMvdW5rbm93bgQaarE7hQWHogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAG9jb3VudGVycy1kaWdlc3QBWCCKzeaLj0V8JxL6rZvaHQtu3Dtwwi5i7t_0jB5erH-KAKIAbGV2YWx1YXRlZC1hdAEaarE7gKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA-2Rrzwjdx658JuaScuhtqxp-XwSi5BJ8qACcB5iiAGVzdGFnZQFndW5rbm93bgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWECtrVEtwcI_6P72o4lBB0_fFSal2Jh64r4few5yUh8Pg_wuus2OPb0Go1b3yY3LjYis3qgpgtwcmZfx5LltCvYJAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "unknown-without-counters", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYpYGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEDGijjfVmtjN4l5xbW4_B0ARs2I9muzBt9tndGx85ATkU6cvhZWCPjtJo7wVACThX6WFfqsnrWfcg7n7npATAQPAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIM5R0dV9avPSfEM6_YdSBJ2pslzxfM1AGmeYY6OHlZL_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggu8ffeGhGf_O98WQje79AlD-IrUiBQfQZnyKYYTHLuigOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg7lU6NG4QJRwnkDjSrYfoqypbSRG9Wf-tlXFmS-NZA3QBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZApcDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWECSKGjD5QXlsS1WNFF7Cw0UGrYL0_FySTAqwQfk7IIjBlPGyNUFaO16m7YPbI2UKtH4AyT5-Qlprrz48XAES1ELA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCC7x994aEZ_873xZCN7v0CUP4itSIFB9BmfIphhMcu6KAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggpHQPeIPAHhe6yASF8E9Yn_FLro8j6MGAoxUdycwmo0oBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg7lU6NG4QJRwnkDjSrYfoqypbSRG9Wf-tlXFmS-NZA3QBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZApcDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWKR7ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXVua25vd24td2l0aG91dC1jb3VudGVycyJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQqA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlikeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC11bmtub3duLXdpdGhvdXQtY291bnRlcnMifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCDuVTo0bhAlHCeQONKth-irKltJEb1Z_62VcWZL41kDdAFZApejAKYAAQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJ4H2F1dGhzLmdhdGV3YXktcHJpdmF0ZS1vdXRjb21lLzEDeEFhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL3Vua25vd24td2l0aG91dC1jb3VudGVycwQaarE7hQWEogBqY29tbWl0bWVudAF4QDIxNDA1NDRjYmI1NDAwMTc3ZGMxMzI2OWNjZWExZWU0ZjQwMTMzZWFkM2RhYjcyOTY0MDA5NjA1YmY2M2IyYjWiAGxldmFsdWF0ZWQtYXQBGmqxO4CiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAZXN0YWdlAWd1bmtub3duAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQBg1Sz54ORc7Swr8-MsMEXBbyySWJk3C0mlnH3dpqn24PMLnDKTUD0QQx7phakz75FdnpSuuugr6L35XIhujpAoCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "response-recorded", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYn4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECBmBocd00VZZ9OJXUVeIXxpRMhWUtf_YLhEXsuOPn8e9zRUJyDmO5jbp-upIviYCsv7EsFiOnK65ZhpQjsKi0MAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIOpJ6uM9XKEQ0rGQ1-PktKUNkcLESpl4pKPoj2Lh4b_jBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggEYFuKkZFeKRmQYyt5B8yjol3NYA4BntDLx4P2B2mjVsOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg6lnlLrftI0L11KbQ-n9wkLP-qus-9gLibkdEagJeeSEBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA2YDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEAudJTmA7uNlrjw3mDVhi6l0FtZvnS9voeWOf-OKPXTRPE1zLDygd-pa_zGmXgPv6wFunpczFf_tGgPC9_nB-4AA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCARgW4qRkV4pGZBjK3kHzKOiXc1gDgGe0MvHg_YHaaNWwGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg-SfCMdthWjEUXqEf23cigKjmjpKAQTmoTWKg7ez-p1sBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg6lnlLrftI0L11KbQ-n9wkLP-qus-9gLibkdEagJeeSEBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA2YDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIOpZ5S637SNC9dSm0Pp_cJCz_qrrPvYC4m5HRGoCXnkhAVkDZqMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkBBpqsTuFBYmiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAbnJlbGF0aXZlLWJhc2lzARkD6aIAdXJlbGF0aXZlLWJhc2lzLWRpZ2VzdAFYILqzQPtka88I3ceufCbmknLobasafl8EouQSfKgAnAeYogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQFxcmVzcG9uc2UtcmVjb3JkZWQBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhApre0cee1jzh3ShD9CgLsuzbGdC6Xrt1ztD2tNYcNkCFevCVLWAQrN9Iv2NfmVcxveMsV0qSQN3GAYVtVX8NcAQKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "response-recorded-provider-rejected", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYsYGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZAMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEAS8hao3XM8wvRWwTvF1ZHzAysaC-bv2wAGJSJyLmIcq5v3L5mwZERljiS6apSXKp7IS2YOwRnjdZN5IpuM-bgCAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIC3vQYHiKV3io5vn2ugRYRR3k6Oo_6vYnl6MR3m69vT_BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggS8p6sQ_oDMlHzigdHrQ_uX1gEJBIltCIZEPrStgLqvQOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggABU-I7gcQ7hx1AenAVBYwj1bwuqTSWdptcIGrGnK9rQBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA3kDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEA04TKg5L2tNbXGgAJLMhDCmbhB0lHQIEacJg2WFA97dlahBNbcgDaY_mwtS4LadLoCqgBwFF92HvUVy9B7UEEJA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCBLynqxD-gMyUfOKB0etD-5fWAQkEiW0IhkQ-tK2Auq9AGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg9DP58jeZQD_hmW-Ixmqgxx8T3BFHxrBqfQwcS11V6DMBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggABU-I7gcQ7hx1AenAVBYwj1bwuqTSWdptcIGrGnK9rQBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA3kDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LXJlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1yZXNwb25zZS1yZWNvcmRlZC1wcm92aWRlci1yZWplY3RlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIAAVPiO4HEO4cdQHpwFQWMI9W8Lqk0lnabXCBqxpyva0AVkDeaMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL3Jlc3BvbnNlLXJlY29yZGVkLXByb3ZpZGVyLXJlamVjdGVkBBpqsTuFBYmiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGQGQogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG5yZWxhdGl2ZS1iYXNpcwEZA-miAHVyZWxhdGl2ZS1iYXNpcy1kaWdlc3QBWCC6s0D7ZGvPCN3Hrnwm5pJy6G2rGn5fBKLkEnyoAJwHmKIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQEyLxo9TXhmBB58awU_WN1uOJXcx27OfGdrijnQgRzWAQHWD9cDn_W0MjQNQzhF0XC7gHB11t8XK9el-2nA2uwcCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-match", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYm4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDdhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQCmzABGRxNWhrJYRkARYzfMRGJBQ1Pos0lyRt8506PuDeKpVrQ61MYdpj5ZM0wAfyDzt2oPQbYnP0jLFqW4NaQ4CgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggAFrwEOQba0G_QEv5t4xDgVynreu24x_bB3QUcY0XBWIFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCBESFeMm_LRfgO_rKYBWl-E084BCPZX37cPyd0zZMWsHg5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCDcveCSJZzguXSqM3slMUhd-UnETA1JwP2eIbC0bjgL_QF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC6QNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQHngwbddp055fhMDDDcGW8ipz06F1-Qf7WtrW4_tPmUTYVtI7PZnB5vLJ70f-bn6KLMOVBqKeRXv5N8dvkKcTwEDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIERIV4yb8tF-A7-spgFaX4TTzgEI9lfftw_J3TNkxaweAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCCrov2221CwUvK6wQsOg5g1JR6Lus4Wteg9fKhb3hAZxwGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCDcveCSJZzguXSqM3slMUhd-UnETA1JwP2eIbC0bjgL_QF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC6QNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYmnsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliaeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1tYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYINy94JIlnOC5dKozeyUxSF35ScRMDUnA_Z4hsLRuOAv9AVkC6aMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4N2F1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWF0Y2gEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFlbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQDSCcIyOG6aU2Vs3SYRhasrPpnDNknkrkFbM0GqQbkA-GvToLupJvpJle4ZqKpySwZNz91-ot43YPIBU3dnMuwICgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-mismatch", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYnoGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDphdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLW1pc21hdGNoAxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQPEODV0UBXrJtRDHueNFDGFqE2DCEtSUiAfrIlvoP8fDzt0v_WNTCFGYRVBQWkLl0HMcFXgxFLYcQ_1sFky2vQkCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggSnuqmDji7d-cmF-CpriNq8p-DfV4H1kbyeyehwwhn5EFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCD6ZJgevqwhIJa_scqhRgmAm7XFDv8MIXHJloSlHgWhRg5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCDTGNqARqS9a5cxLurakMOFelVXfDxhBVU-ZkIZZJgTAwF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC7wNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQNNDMzmC0uf7Bnq7U9iGCwr_X8h2Z1o9j1RgOXGVDFDgIeaaIlGMuL52UtBuIm-iARXF8wUZh1GQQmkMLCzygQMDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIPpkmB6-rCEglr-xyqFGCYCbtcUO_wwhccmWhKUeBaFGAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCDW88os1liq941M1YFFh9TVcQmb0_RvXRbH2LwOfAOluAGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCDTGNqARqS9a5cxLurakMOFelVXfDxhBVU-ZkIZZJgTAwF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkC7wNzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYnXsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtbWlzbWF0Y2gifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1taXNtYXRjaCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYINMY2oBGpL1rlzEu6tqQw4V6VVd8PGEFVT5mQhlkmBMDAVkC76MApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4OmF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtbWlzbWF0Y2gEGmqxO4UFh6IAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAGtvYnNlcnZhdGlvbgFobWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQOQam0cEzy3VkkoPi1uk3YwaLLbdN309TRcCfQeRlItTmPUcWMLyXi6Fx4_kDejYaTIAta4V1uSGLUzmsNXGzQwCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-echo-mismatch", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYo4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeD9hdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWVjaG8tbWlzbWF0Y2gDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhATWXOPOfvw5LffR1QJCW4mYl8Qt1ZFV3x5d5st_K9ldFjNawwAADelqFhm7WvjosOZPgV1TP2x8kSKK3IUKQfCQKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCARKAzYLEumQVVFAwyi-Z2IN_iePg0-j5RFH7v8or7RPQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YINdAgYzWreTXEyjvU72MWtgI8759_6sVDtZEDjcQdvWvDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYINO33SoP6njOA48ZqQfSrwxRJALQuhGzL1IpxMFESgcoAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQL5A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAJX3ekgutCtJa8du76SOkkZmAhDASDrZ1aqvPe0hCITEGTD02DQ5MSEac89JcrRUX55VsRfpwLUOofZHKRqd3AwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVgg10CBjNat5NcTKO9TvYxa2Ajzvn3_qxUO1kQONxB29a8BgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIIwLemPKLik6kUuOJ54PJfmbQQwh_h1hlOV_WFitRmzJAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYINO33SoP6njOA48ZqQfSrwxRJALQuhGzL1IpxMFESgcoAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQL5A3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliieyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1lY2hvLW1pc21hdGNoIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFgg07fdKg_qeM4DjxmpB9KvDFEkAtC6EbMvUinEwURKBygBWQL5owCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3g_YXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1lY2hvLW1pc21hdGNoBBpqsTuFBYeiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBrb2JzZXJ2YXRpb24BbWVjaG8tbWlzbWF0Y2iiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBaG9ic2VydmVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6V3pCNk8tLXd0QTlMTFA5Rlo1cXFBMFMzSmhuenh5MlBfbUdteGNKY2U5OAJqZWQyNTUxOS12MQFYQCFG6kZWRYrlGib8kJMUPjBo0NNzOk6EQQNm21FO-6aCKWpyMteAKMASstgJRopjhJ_wdbkFaPqF0NyAAOCd0gwCgaQAWCCqFIjakwV4ELbELj7_D_CFF86vnUCd91Sv4PT8xPL83wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgDXVQdU4IAKXSN-71gmA1dmubPloVhoqUCrKJlYeI47A", + "decision": "denied", + "code": "observation-condition-false" + }, + { + "id": "observed-by-provider-after-response", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYsYGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeE1hdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBEmWX3uCnaJos_MuIiIRiIRL8YJjegkihKnYzwfRqaUK-LlA4VWpZ1dr4ELCkWHBk2TczUi1fqglsvoPxwGjUKAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIIiJfvNpIannQPrG3m9zkrZ-EoRswyDMUfRPOgBrKBZKBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggJQubfEQ0u0XTqUACFflTQPSv9GcLlzOy3IyrtTkKY0wOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFggi5-FdpOeFS1EyFNXSjDJVv-Nz6Z2o9ssbUJ6Ykn_yDsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA7ADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWECwjhDLmhiL6fqwjv4toPBp4kTGwlCHejZrw_VRWKwxj1Eh_60Bf3faH6jSlwAhPSmDudhpPVVdTLCQ757_Cr8MA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCAlC5t8RDS7RdOpQAIV-VNA9K_0ZwuXM7LcjKu1OQpjTAGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg9iMHorwDIAs7Ax9cZTsWYkJvKaZ9Qqr_7goxgq2C49ABgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFggi5-FdpOeFS1EyFNXSjDJVv-Nz6Z2o9ssbUJ6Ykn_yDsBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZA7ADc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWK97ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW9ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci1yZXNwb25zZSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIIufhXaTnhUtRMhTV0owyVb_jc-mdqPbLG1CemJJ_8g7AVkDsKMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4TWF1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXJlc3BvbnNlBBpqsTuFBYqiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAb2NvdW50ZXJzLWRpZ2VzdAFYIIrN5ouPRXwnEvqtm9odC27cO3DCLmLu3_SMHl6sf4oAogBsZXZhbHVhdGVkLWF0ARpqsTuAogBvZXZpZGVuY2UtZGlnZXN0AVggt-tqpDRG1g0KCJCKR0JRUFIugpJQTfYso57xq1PzcJqiAGtodHRwLXN0YXR1cwEYyKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBucmVsYXRpdmUtYmFzaXMBGQPpogB1cmVsYXRpdmUtYmFzaXMtZGlnZXN0AVggurNA-2Rrzwjdx658JuaScuhtqxp-XwSi5BJ8qACcB5iiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK_rNkeBAFlgjwaBzJvp6e-9cyTPkB3RmqIAZXN0YWdlAXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWEAc-nv-5eI9SnudDkVBrFpIBHQp7OsOTjSaoxTkyn_yq-lRcLvHrzNwKasYztsK-_HWHgZRptK41l5KTfjagyUOAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "observed-by-provider-after-unknown", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYr4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeEthdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLWFmdGVyLXVua25vd24DGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhABLJ3QBs0R-iuXiP4qMxU-kjyYxS5U5IkfesoUjspfDomwCJ3BxQE_imOE0SULoLRLVKnSunJC7DEO4qJBjxoAQKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCAC-t1MYdGRbedBCzqRNOxPsavEPilfFznxXq_AGDuA3gVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIHGoc4XNsXYuUyXGKnaEET8H2HFz-lG_PumniV0ZsB7bDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIDb6ARdsS4OwQuet0zFtztJJeG-FDZqD95z5zSSJK_B4AXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLjA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhAEzW3IfCBs3CLiOWAIKoT-231pjj49fQ4r6XBuL-jzVg7V1QolbXshnTBbri7wrwINddtleUNWqyXrkw_OMTwDAOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggcahzhc2xdi5TJcYqdoQRPwfYcXP6Ub8-6aeJXRmwHtsBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIPf4oqDE-Fo1KeKGx5NwCtwjQsO8RJSR7GnTh_Z2zIysAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIDb6ARdsS4OwQuet0zFtztJJeG-FDZqD95z5zSSJK_B4AXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLjA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliueyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9A6IAanRvb2xzL2NhbGwBeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQT2BYGiAFggNvoBF2xLg7BC563TMW3O0kl4b4UNmoP3nPnNJIkr8HgBWQLjowCmAAEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCeB9hdXRocy5nYXRld2F5LXByaXZhdGUtb3V0Y29tZS8xA3hLYXV0aHMtZ2F0ZXdheTovL2FpcnRhYmxlLWRlbW8vb3BlcmF0aW9ucy9vYnNlcnZlZC1ieS1wcm92aWRlci1hZnRlci11bmtub3duBBpqsTuFBYWiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAb2V2aWRlbmNlLWRpZ2VzdAFYILfraqQ0RtYNCgiQikdCUVBSLoKSUE32LKOe8atT83CaogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAcfvb3syFijWnUddkt9qqPEDQBrYIUoiJF1i50umz2hxNAdDGfj2MpwohyURrVwQ2jK7X612mbHqambALUnMoDwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "observed-by-provider-with-pre-entry", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYsIGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeExhdXRocy1nYXRld2F5Oi8vYWlydGFibGUtZGVtby9vcGVyYXRpb25zL29ic2VydmVkLWJ5LXByb3ZpZGVyLXdpdGgtcHJlLWVudHJ5AxkOEASBowADAWVzdGFnZQKBdG9ic2VydmVkLWJ5LXByb3ZpZGVyAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6OEdKZGx2Q0FyZnlGOGJiSUdMdlQzd01WZ0c2bmVHcU1WcWRMbzI3SnZkcwJqZWQyNTUxOS12MQFYQLcWBqlrRcrtzvwS5r4x_0nR5TgjTNwoMFQOmLHsXoGCsJ2vUyvP_gRJl3VDDWpIbbGjk88V6w1thN91bGSKhQQCgaIAswABAWlhdXRocy5tY3ACAgN4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uBFggc6z1PutB43hXxnS5hMcHYgp_a0WHpkFq_JxOhyAcHPwFanRvb2xzL2NhbGwGeC9tY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QvdG9vbHMvc2V0X3N0YXR1c192MQf2CHgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CVggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGmqxLXALGmqxSZAMeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcNWCDdfD0GEQsDQHzgJ5e9Z3eMBlhGoENvnuhxwAcH9BfmGA5YIBzWQK8dk0LWf36loJ_o9ImgEQay3NGSjrCIm0yx4MfhD2dub25lLXYxEFggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsRgacAWCAGLy2qlva7cGCHiphU5HSPvh_h_kWULa1dYgP_gHEiKQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDYANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9BKAAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdwJqZWQyNTUxOS12MQFYQCJlAs8zNNBNO4CSeu3bVQH2crx3HFawVHZqXM2wb0sL6TD4Rm493kKnGCUaqCqLg_0gw9Mhu9zuaD7ZEfy63AkDogAAAVggCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsEgqQAWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5QFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAg0EqyMnQrtKs6E2i9RhXk5tAiSrcaAWuvhSCjMsl3hzekAFggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIKCapfR6Z1mAL_lV-NwtKhSlyZ0jvpf4ZBJ_-Tg0VaTwBYKiAKIAAAFYIN18PQYRCwNAfOAnl71nd4wGWEagQ2-e6HHABwf0F-YYAYFYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflogCiAAEBWCBNeJrQeBeIbTgM6Tdd1XU7FXuXmK9Tvlsj0oR88ifDsgGBWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6waAB4AIgacAWCAGLy2qlva7cGCHiphU5HSPvh_h_kWULa1dYgP_gHEiKQF4KWFwcGxpY2F0aW9uL3ZuZC5hdXRocy5vYnNlcnZhdGlvbi52MStjYm9yAhkDYANzYXV0aG9yaXphdGlvbi1pbnB1dAT0BfUG9AlYr3siYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6InZlcmRpY3Qtb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliveyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vYnNlcnZlZC1ieS1wcm92aWRlci13aXRoLXByZS1lbnRyeSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIAYvLaqW9rtwYIeKmFTkdI--H-H-RZQtrV1iA_-AcSIpAVkDYKMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AngfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQN4TGF1dGhzLWdhdGV3YXk6Ly9haXJ0YWJsZS1kZW1vL29wZXJhdGlvbnMvb2JzZXJ2ZWQtYnktcHJvdmlkZXItd2l0aC1wcmUtZW50cnkEGmqxO4UFiKIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBvZXZpZGVuY2UtZGlnZXN0AVggt-tqpDRG1g0KCJCKR0JRUFIugpJQTfYso57xq1PzcJqiAGtodHRwLXN0YXR1cwEYyKIAcHByZS1lbnRyeS1kaWdlc3QBWCCPNXzxcA3o296oUSzrQEOHSOlyESUXUipV4nGwl_nLXKIAbXJlY2lwZS1kaWdlc3QBeEBjM2EyODg3YTJhZTBkZDRmOTY2NWQwNWJlMTRiYzk0ODhiMTQzNzkzYTViMjIwOThhYTJkZWJjYzQyZGQwMjBhogBvcmVzcG9uc2UtZGlnZXN0AVgg4VlI5O4BiqSv6zZHgQBZYI8Ggcyb6envvXMkz5Ad0ZqiAGVzdGFnZQF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AmplZDI1NTE5LXYxAVhAUtr3z29gaCshFE1w5gHyzZcM8JxpDZ5APdhG8AA4TIVVZ1bsYkfzzxrocEpCU_hHtHINsUvoAT1fgKq2sN1ZAwKBpABYIKoUiNqTBXgQtsQuPv8P8IUXzq-dQJ33VK_g9PzE8vzfAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACANdVB1TggApdI37vWCYDV2a5s-WhWGipQKsomVh4jjsA", + "decision": "authorized", + "code": "authorized" + }, + { + "id": "outcome-v1-schema", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYn4GlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDthdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdXRjb21lLXYxLXNjaGVtYQMZDhAEgaMAAwFlc3RhZ2UCgXRvYnNlcnZlZC1ieS1wcm92aWRlcgGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWEBX-WfNEPQ8_wOk-eB3p84OWxYEmTlMoUXCgFM_nerpdr2FQwFOTQ8XTfOMloZtR6TYMLzGBLDLKVV-7AtoZCsIAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIK2D_NcDap8GMsStVfvYpsNiJnVkcjPOWtT2pnWlqj90BWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggdf9OWT2DxL37frf9_qA_nUQEsVD6nkq5nYxgONMCpaEOWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYGnAFgg_BLeDa33pQBj0X9qJEhV2CQ3tOcDe4fQjsxmavyeAygBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAtgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQSgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEC2CEJumirKUhedYvmcs9Iapuy0Y9XtJDU9Eh-FIAD5szMz6JhqnQJMSUZrcfvITrO8-u2-DKaIUy7rZRKrSd0FA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCB1_05ZPYPEvft-t_3-oD-dRASxUPqeSrmdjGA40wKloQGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVgg-Mw0V5P3e-OcfxCs2HR8pcv3EWyFZcbvnrVBIs_AUDQBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIGnAFgg_BLeDa33pQBj0X9qJEhV2CQ3tOcDe4fQjsxmavyeAygBeClhcHBsaWNhdGlvbi92bmQuYXV0aHMub2JzZXJ2YXRpb24udjErY2JvcgIZAtgDc2F1dGhvcml6YXRpb24taW5wdXQE9AX1BvQJWJ17ImFyZ3VtZW50cyI6eyJvcGVyYXRpb25faWQiOiJ2ZXJkaWN0LW91dGNvbWUtdjEtc2NoZW1hIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlideyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdXRjb21lLXYxLXNjaGVtYSJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWBogBYIPwS3g2t96UAY9F_aiRIVdgkN7TnA3uH0I7MZmr8ngMoAVkC2KMApgABAXg2a2V5OnNoYTI1NjpXekI2Ty0td3RBOUxMUDlGWjVxcUEwUzNKaG56eHkyUF9tR214Y0pjZTk4AndhdXRocy5nYXRld2F5LW91dGNvbWUvMQN4O2F1dGhzLWdhdGV3YXk6Ly9zdHJpcGUtcmVmdW5kcy9vcGVyYXRpb25zL291dGNvbWUtdjEtc2NoZW1hBBpqsTuFBYaiAGpjb21taXRtZW50AXhAMjE0MDU0NGNiYjU0MDAxNzdkYzEzMjY5Y2NlYTFlZTRmNDAxMzNlYWQzZGFiNzI5NjQwMDk2MDViZjYzYjJiNaIAbGV2YWx1YXRlZC1hdAEaarE7gKIAa2h0dHAtc3RhdHVzARjIogBtcmVjaXBlLWRpZ2VzdAF4QGMzYTI4ODdhMmFlMGRkNGY5NjY1ZDA1YmUxNGJjOTQ4OGIxNDM3OTNhNWIyMjA5OGFhMmRlYmNjNDJkZDAyMGGiAG9yZXNwb25zZS1kaWdlc3QBWCDhWUjk7gGKpK_rNkeBAFlgjwaBzJvp6e-9cyTPkB3RmqIAZXN0YWdlAXFyZXNwb25zZS1yZWNvcmRlZAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2Old6QjZPLS13dEE5TExQOUZaNXFxQTBTM0pobnp4eTJQX21HbXhjSmNlOTgCamVkMjU1MTktdjEBWED4-twXxL0lUkkpPWLZSqlqW9W1ZAg1-JPagUtHY7TvCvt9e_fE0mpAAihAWQNjoKWN2CEJmf5iwXkS3RaNLkUJAoGkAFggqhSI2pMFeBC2xC4-_w_whRfOr51AnfdUr-D0_MTy_N8BanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAIA11UHVOCACl0jfu9YJgNXZrmz5aFYaKlAqyiZWHiOOw", + "decision": "indeterminate", + "code": "observation-missing" + }, + { + "id": "other-signer", + "proof_b64": "qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgaIAeBpvYnNlcnZhdGlvbi1yZXF1aXJlbWVudC12MQFYmoGlAHBnYXRld2F5LW9ic2VydmVyAXgfYXV0aHMuZ2F0ZXdheS1wcml2YXRlLW91dGNvbWUvMQKiAAABeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIDGQ4QBIGjAAMBZXN0YWdlAoF0b2JzZXJ2ZWQtYnktcHJvdmlkZXIBogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1Njo4R0pkbHZDQXJmeUY4YmJJR0x2VDN3TVZnRzZuZUdxTVZxZExvMjdKdmRzAmplZDI1NTE5LXYxAVhAAOErqdesI-oBAdUSjtoi3jtJTx4BUiOvpeoBpJMJxpH5LP0GDHZVfH2jV7eR-QD9480eHfvUnNguAQA1Hc1IDgKBogCzAAEBaWF1dGhzLm1jcAICA3gmYXBwbGljYXRpb24vdm5kLmF1dGhzLm1jcC1jYWxsLnYyK2pzb24EWCBmfo5x-8k3xj75dzubWSwsRfJ-BN7eXOUy2N3VWuzgyQVqdG9vbHMvY2FsbAZ4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxB_YIeBttY3A6Ly9nYXRld2F5LW9ic2VydmVyLXRlc3QJWCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoaarEtcAsaarFJkAx4NmtleTpzaGEyNTY6WXF6dFI5QjhJQkc0RGdYNGZIOVNzbmZpVEptYW9GVG9GY2drRXF6MWFYdw1YIKwNVvm6ruzDuc-FbDKIrIM2mFXQz4ymC1oq_Whid1PTDlggHNZArx2TQtZ_fqWgn-j0iaARBrLc0ZKOsIibTLHgx-EPZ25vbmUtdjEQWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCxGBpwBYIK7uWRxWfl0qwcr9E1iVU-NhAa1_1b9KqIgrn6T13SUJAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLcA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0EoABogCjAGpyYXcta2V5LXYxAXg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3AmplZDI1NTE5LXYxAVhA0FD53BfAc-nv4Al6kF8lI_ZSZ1ZIK1ltoOsZUqEkSup7mC8J2cRAipL74U1pXeKqRLj18l1j6Dqi1CfkRhc-AwOiAAABWCALCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwSCpABYIBCabr0mWp9yNsGIgpwWOaP6qypDh9qcecSvxkb5YhflAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACDQSrIydCu0qzoTaL1GFeTm0CJKtxoBa6-FIKMyyXeHN6QAWCDNG-pxBbrPTE0ZZbShY4UsAG2EkrGYkVzHFtcB6ZzG6wFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAgoJql9HpnWYAv-VX43C0qFKXJnSO-l_hkEn_5ODRVpPAFgqIAogAAAVggrA1W-bqu7MO5z4VsMoisgzaYVdDPjKYLWir9aGJ3U9MBgVggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-WiAKIAAQFYIJVwmYRVCGw_nwnmyEHzAHf-PhrffXq1DKfoCC9Cl1YBAYFYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrBoAHgAiBpwBYIK7uWRxWfl0qwcr9E1iVU-NhAa1_1b9KqIgrn6T13SUJAXgpYXBwbGljYXRpb24vdm5kLmF1dGhzLm9ic2VydmF0aW9uLnYxK2Nib3ICGQLcA3NhdXRob3JpemF0aW9uLWlucHV0BPQF9Qb0CViYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0KgA", + "action_b64": "pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAliYeyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoidmVyZGljdC1vdGhlci1zaWduZXIifSwibmFtZSI6InNldF9zdGF0dXNfdjEiLCJwcm9maWxlIjoiYXV0aHMubWNwIiwicHJvZmlsZV92ZXJzaW9uIjoyLCJzZXJ2aWNlIjoiZ2F0ZXdheS1vYnNlcnZlci10ZXN0In0DogBqdG9vbHMvY2FsbAF4L21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdC90b29scy9zZXRfc3RhdHVzX3YxBPYFgaIAWCCu7lkcVn5dKsHK_RNYlVPjYQGtf9W_SqiIK5-k9d0lCQFZAtyjAKYAAQF4NmtleTpzaGEyNTY6UXgzSkdLb05EaVNUd1pVR0djUGhzU1RZMmpFelQ0aklEOG5RbF9XejZUcwJ4H2F1dGhzLmdhdGV3YXktcHJpdmF0ZS1vdXRjb21lLzEDeDZhdXRocy1nYXRld2F5Oi8vc3RyaXBlLXJlZnVuZHMvb3BlcmF0aW9ucy9vdGhlci1zaWduZXIEGmqxO4UFhqIAamNvbW1pdG1lbnQBeEAyMTQwNTQ0Y2JiNTQwMDE3N2RjMTMyNjljY2VhMWVlNGY0MDEzM2VhZDNkYWI3Mjk2NDAwOTYwNWJmNjNiMmI1ogBsZXZhbHVhdGVkLWF0ARpqsTuAogBraHR0cC1zdGF0dXMBGMiiAG1yZWNpcGUtZGlnZXN0AXhAYzNhMjg4N2EyYWUwZGQ0Zjk2NjVkMDViZTE0YmM5NDg4YjE0Mzc5M2E1YjIyMDk4YWEyZGViY2M0MmRkMDIwYaIAb3Jlc3BvbnNlLWRpZ2VzdAFYIOFZSOTuAYqkr-s2R4EAWWCPBoHMm-np771zJM-QHdGaogBlc3RhZ2UBcXJlc3BvbnNlLXJlY29yZGVkAaIAowBqcmF3LWtleS12MQF4NmtleTpzaGEyNTY6UXgzSkdLb05EaVNUd1pVR0djUGhzU1RZMmpFelQ0aklEOG5RbF9XejZUcwJqZWQyNTUxOS12MQFYQNndLRwHED1cASxxhgBqgrE0HZHTFapKMbn-Bq8JgPDfuaLhcrvVoKg_jPxQGQYLIJsKt_f8hDqteciE2Y3gMggCgaQAWCC3ZKd7bdF1QuoAabNcGsZh4zyumTGUNgK0BdcNJku_CgFqcmF3LWtleS12MQJ4IGFwcGxpY2F0aW9uL3ZuZC5hdXRocy5yYXcta2V5LnYxA1gyQVVUSFMtUkFXLUtFWQABAQAga3NKjv8kb-c0s41ARsFI7uXwT-h7OgpCOVWneVbeBms", + "decision": "indeterminate", + "code": "observation-missing" + } + ] +} diff --git a/bindings/python/README.md b/bindings/python/README.md index a83a1c590..b7d780a7c 100644 --- a/bindings/python/README.md +++ b/bindings/python/README.md @@ -122,3 +122,10 @@ published release. Publication, promotion, and independent-review status remain governed by `sdk-capability.json`. + +The application observation protocol is `auths.gateway-observe/4`. Public signed +outcomes use `auths.gateway-outcome/3` and hiding effect/record references; public +pre-entry history returns only the observation count and a hiding record +commitment. No protected observation bytes or raw content-derived digests are +returned. Operator-only `auths-gateway audit-export` completes private audit +bundles; these are not application SDK results. Superseded schemas are rejected. diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl index c9d50afcd..cc8225b8e 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl @@ -164,7 +164,19 @@ does not recover implicitly. **`bin/export`** (agent) writes `audit/bundle.json`: one entry per operation ID, the approval responses, the recipe, and the trusted context. -**`bin/audit`** (auditor) runs `auths-gateway audit` offline on the bundle +Before auditing, the trusted operator completes the public inventory while the +gateway is running: + +```sh +/path/to/auths-gateway audit-export --state-dir enforcement/gateway \ + --bundle audit/bundle.json --out audit/private-bundle.json +``` + +The audit directory must be owner-private. The command creates a new 0600 file +and never overwrites an existing artifact. Keep the completed bundle and detailed +report with the operator; the application sees redacted public outcomes only. + +**`bin/audit`** (auditor) runs `auths-gateway audit` offline on `audit/private-bundle.json` with the two pinned values in `audit/pins.json`, and passes its report, standard error, and exit status through unchanged. By default the audit fails the bundle when any entry has no gateway-signed outcome diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl index 076cbb8cc..1a7f134ac 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/app/refund_client.py.tmpl @@ -348,7 +348,7 @@ def export(arguments: List[str]) -> Dict[str, Any]: [json.loads(line) for line in approvals.read_text().splitlines() if line] if approvals.exists() else [] ) bundle = { - "schema": "auths.gateway-audit-bundle/2", + "schema": "auths.gateway-audit-bundle/3", "recipe_b64": _b64(RECIPE.read_bytes()), "profile_lock_b64": _b64(PROFILE_LOCK.read_bytes()), "trusted_context_b64": _b64((AGENT / "trust" / "gateway.context.cbor").read_bytes()), diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl index adedcc745..bb86e62a7 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/operate.py.tmpl @@ -506,7 +506,7 @@ def audit(arguments: List[str]) -> NoReturn: prog="bin/audit", description="Run auths-gateway audit offline on the bundle, with the pinned values.", ) - parser.add_argument("--bundle", type=Path, default=AUDIT / "bundle.json") + parser.add_argument("--bundle", type=Path, default=AUDIT / "private-bundle.json") parser.add_argument( "--allow-unverified-refusals", action="store_true", diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl index d8c1d498f..f48650db8 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl @@ -946,7 +946,9 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started # The bundle, and the offline audit under the default rule and the relaxation. status, exported, stderr = commands.run("export") expect(status == 0, f"bin/export: {exported} {stderr}") - bundle = read_json(AUDIT / "bundle.json") + gateway_json(config, "audit-export", "--state-dir", str(STATE), + "--bundle", str(AUDIT / "bundle.json"), "--out", str(AUDIT / "private-bundle.json")) + bundle = read_json(AUDIT / "private-bundle.json") unrecorded = {entry["operation_id"] for entry in bundle["entries"] if entry.get("outcome_b64") is None} expect(unrecorded == UNRECORDED, f"entries without a signed outcome: {sorted(unrecorded)}") strict_status, strict, strict_stderr = commands.run("audit") diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index 893366a89..6c9568a23 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -2,10 +2,9 @@ This client does not accept a provider URL, method, body, header, or credential. It does not establish deployment isolation: that is an operator property. -Besides submission, it can ask the gateway for one signed observation (a -read-back of the recipe's observed field, or the stored outcome of a logical -operation) to attach to a later action, or for the signed pre-entry -observations stored for one operation; an observation request never writes. +Besides submission, it can request a signed redacted outcome or redacted +pre-entry history. Protected evidence is exported separately by the operator; +application observation requests never write or disclose provider content. """ from __future__ import annotations @@ -22,15 +21,15 @@ from typing import Final, Literal, Mapping, Optional, Union, cast _REQUEST_SCHEMA = "auths.gateway-submit/2" -_OBSERVE_SCHEMA = "auths.gateway-observe/3" -_OUTCOME_SCHEMA: Final = "auths.gateway-outcome/2" +_OBSERVE_SCHEMA = "auths.gateway-observe/4" +_OUTCOME_SCHEMA: Final = "auths.gateway-outcome/3" _OBSERVATION_MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor" _MAX_OBSERVATION_BYTES = 4_096 _MAX_PRE_ENTRY_OBSERVATIONS = 4 _MAX_SUBJECT_BYTES = 1_024 _MAX_PROOF_BYTES = 4 * 1024 * 1024 _MAX_ACTION_BYTES = 64 * 1024 -# Room for four maximal pre-entry observations in one base64url response. +# Bounded public result frame; protected pre-entry observations are operator-only. _MAX_RESPONSE_BYTES = 32 * 1024 _DIGEST = re.compile(r"[0-9a-f]{64}") _OPERATION_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}") @@ -302,11 +301,11 @@ class GatewaySignedObservation: observation asserts only what the gateway saw at ``observed_at`` (gateway wall-clock seconds, covered by the signature); it is not a write receipt and does not prove the fact still holds. ``schema`` is - ``auths.gateway-readback/1`` for a read-back and ``auths.gateway-outcome/2`` + ``auths.gateway-readback/1`` for a read-back and ``auths.gateway-outcome/3`` for an operation outcome. """ - schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/2"] + schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/3"] subject: str observed_at: int media_type: Literal["application/vnd.auths.observation.v1+cbor"] @@ -324,17 +323,11 @@ class GatewayObservationRefused: @dataclass(frozen=True) class GatewayPreEntryObservations: - """The signed pre-entry observations the gateway stored for one operation. - - Each item is the exact canonical ``auths.gateway-readback/1`` observation - the gateway signed after the credential lease and before the write, in - pointer order; the tuple is empty when none were recorded. The gateway - signs nothing new to answer and contacts no provider. An audit bundle - carries them as an entry's ``pre_entry_b64``. - """ + """Redacted pre-entry history; protected observation bytes stay with the operator.""" operation_id: str - observations: tuple[bytes, ...] + observations: int + record_commitment: str outcome: Literal["pre-entry"] = "pre-entry" @@ -361,7 +354,7 @@ def _decode_base64url(text: str, maximum: int) -> bytes: def _parse_observe_result( - raw: bytes, schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/2"] + raw: bytes, schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/3"] ) -> GatewayObserveResult: try: decoded: object = _gateway_json(raw) @@ -394,7 +387,7 @@ def _parse_observe_result( or not 1 <= len(subject.encode("utf-8", "surrogatepass")) <= _MAX_SUBJECT_BYTES or not isinstance(observed_at, int) or isinstance(observed_at, bool) - or not 0 <= observed_at <= _MAX_U64 + or not 0 <= observed_at <= 2**53 - 1 or not isinstance(encoded, str) ): raise GatewayProtocolError("gateway returned invalid signed observation") @@ -412,7 +405,7 @@ def _parse_refusal(value: Mapping[str, object]) -> GatewayObservationRefused: if ( set(value) != {"outcome", "code"} or not isinstance(code, str) - or not 1 <= len(code) <= 128 + or not 1 <= len(code.encode("utf-8")) <= 128 ): raise GatewayProtocolError("gateway returned invalid refusal") return GatewayObservationRefused(code) @@ -429,26 +422,19 @@ def _parse_pre_entry_result(raw: bytes, operation_id: str) -> GatewayPreEntryRes outcome = value.get("outcome") if outcome == "refused": return _parse_refusal(value) - encoded = value.get("observations_b64") + observations = value.get("observations") + commitment = value.get("record_commitment") if ( outcome != "pre-entry" - or set(value) != {"outcome", "operation_id", "observations_b64"} + or set(value) != {"outcome", "operation_id", "observations", "record_commitment"} or value.get("operation_id") != operation_id - or not isinstance(encoded, list) - ): - raise GatewayProtocolError("gateway returned invalid pre-entry observations") - items = cast("list[object]", encoded) - if len(items) > _MAX_PRE_ENTRY_OBSERVATIONS or not all( - isinstance(item, str) for item in items + or type(observations) is not int + or not 0 <= observations <= _MAX_PRE_ENTRY_OBSERVATIONS + or not isinstance(commitment, str) + or re.fullmatch(r"[0-9a-f]{64}", commitment) is None ): - raise GatewayProtocolError("gateway returned invalid pre-entry observations") - return GatewayPreEntryObservations( - operation_id, - tuple( - _decode_base64url(cast(str, item), _MAX_OBSERVATION_BYTES) - for item in items - ), - ) + raise GatewayProtocolError("gateway returned invalid pre-entry history") + return GatewayPreEntryObservations(operation_id, observations, commitment) def _submission(proof: bytes, action: bytes, approval: bytes) -> dict[str, str]: @@ -600,7 +586,7 @@ async def observe_pre_entry(self, operation_id: str) -> GatewayPreEntryResult: async def _observe( self, request: Mapping[str, object], - schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/2"], + schema: Literal["auths.gateway-readback/1", "auths.gateway-outcome/3"], ) -> GatewayObserveResult: payload = json.dumps( {"schema": _OBSERVE_SCHEMA, "request": request}, diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index dad22ba80..e483d8980 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -263,14 +263,14 @@ async def scenario(reply: bytes) -> tuple[object, list[dict[str, object]]]: subject = "auths-gateway://ns/operations/step-1" signed, seen = asyncio.run( - scenario(_signed(schema="auths.gateway-outcome/2", subject=subject)) + scenario(_signed(schema="auths.gateway-outcome/3", subject=subject)) ) assert signed == GatewaySignedObservation( - "auths.gateway-outcome/2", subject, 1_790_000_000, _MEDIA_TYPE, _OBSERVATION + "auths.gateway-outcome/3", subject, 1_790_000_000, _MEDIA_TYPE, _OBSERVATION ) assert seen == [ { - "schema": "auths.gateway-observe/3", + "schema": "auths.gateway-observe/4", "request": {"kind": "outcome", "operation_id": "step-1"}, } ] @@ -297,21 +297,21 @@ async def scenario(reply: bytes, outcome: Optional[str] = None) -> object: asyncio.run(scenario(_signed(), "step-1")) for hostile in [ _signed(schema="retired"), - _signed(schema="auths.gateway-outcome/2", media_type="application/cbor"), - _signed(schema="auths.gateway-outcome/2", subject=""), - _signed(schema="auths.gateway-outcome/2", subject="s" * 1_025), - _signed(schema="auths.gateway-outcome/2", observed_at=-1), - _signed(schema="auths.gateway-outcome/2", observed_at=True), - _signed(schema="auths.gateway-outcome/2", observed_at="1790000000"), - _signed(schema="auths.gateway-outcome/2", observation_b64=""), - _signed(schema="auths.gateway-outcome/2", observation_b64=_b64(_OBSERVATION) + "="), - _signed(schema="auths.gateway-outcome/2", observation_b64=base64.b64encode(b"\xfb\xff").decode()), - _signed(schema="auths.gateway-outcome/2", observation_b64="AB"), - _signed(schema="auths.gateway-outcome/2", observation_b64="A"), - _signed(schema="auths.gateway-outcome/2", observation_b64="QUJD RA"), - _signed(schema="auths.gateway-outcome/2", observation_b64=_b64(b"x" * 4_097)), - _signed(schema="auths.gateway-outcome/2", confirmed=True), - _signed(schema="auths.gateway-outcome/2", observation=_b64(_OBSERVATION)), + _signed(schema="auths.gateway-outcome/3", media_type="application/cbor"), + _signed(schema="auths.gateway-outcome/3", subject=""), + _signed(schema="auths.gateway-outcome/3", subject="s" * 1_025), + _signed(schema="auths.gateway-outcome/3", observed_at=-1), + _signed(schema="auths.gateway-outcome/3", observed_at=True), + _signed(schema="auths.gateway-outcome/3", observed_at="1790000000"), + _signed(schema="auths.gateway-outcome/3", observation_b64=""), + _signed(schema="auths.gateway-outcome/3", observation_b64=_b64(_OBSERVATION) + "="), + _signed(schema="auths.gateway-outcome/3", observation_b64=base64.b64encode(b"\xfb\xff").decode()), + _signed(schema="auths.gateway-outcome/3", observation_b64="AB"), + _signed(schema="auths.gateway-outcome/3", observation_b64="A"), + _signed(schema="auths.gateway-outcome/3", observation_b64="QUJD RA"), + _signed(schema="auths.gateway-outcome/3", observation_b64=_b64(b"x" * 4_097)), + _signed(schema="auths.gateway-outcome/3", confirmed=True), + _signed(schema="auths.gateway-outcome/3", observation=_b64(_OBSERVATION)), b'{"outcome":"refused"}', b'{"outcome":"refused","code":""}', b'{"outcome":"refused","code":"x","reason":"y"}', @@ -341,27 +341,33 @@ def reply(**overrides: object) -> bytes: body: dict[str, object] = { "outcome": "pre-entry", "operation_id": "step-1", - "observations_b64": [_b64(_OBSERVATION)], + "observations": 1, "record_commitment": "01" * 32, } body.update(overrides) return json.dumps(body).encode() result, seen = asyncio.run(scenario(reply())) - assert result == GatewayPreEntryObservations("step-1", (_OBSERVATION,)) + assert result == GatewayPreEntryObservations("step-1", 1, "01" * 32) assert seen == [ { - "schema": "auths.gateway-observe/3", + "schema": "auths.gateway-observe/4", "request": {"kind": "pre-entry", "operation_id": "step-1"}, } ] - empty, _ = asyncio.run(scenario(reply(observations_b64=[]))) - assert empty == GatewayPreEntryObservations("step-1", ()) + empty, _ = asyncio.run(scenario(reply(observations=0))) + assert empty == GatewayPreEntryObservations("step-1", 0, "01" * 32) refused, _ = asyncio.run( scenario(b'{"outcome":"refused","code":"gateway.observer.operation-unknown"}') ) assert refused == GatewayObservationRefused("gateway.observer.operation-unknown") for hostile in [ reply(operation_id="step-2"), + reply(observations=5), + reply(observations=-1), + reply(observations=True), + reply(record_commitment="01" * 31), + reply(record_commitment="01" * 32 + "\n"), + reply(record_commitment="AB" * 32), reply(observations_b64=[_b64(_OBSERVATION)] * 5), reply(observations_b64=[""]), reply(observations_b64=[_b64(_OBSERVATION) + "="]), @@ -491,3 +497,19 @@ def test_content_controls_refuse_unbounded_or_invalid_input(socket_dir) -> None: for acknowledgement in (b"", b"a" * 4097): with pytest.raises(ValueError): asyncio.run(client.acknowledge_disclosure("fixture-1", acknowledgement)) + + +def test_history_parsers_match_native_public_corpus() -> None: + from auths.gateway import _parse_observe_result, _parse_pre_entry_result + fixture = Path(__file__).resolve().parents[2] / "fixtures/gateway/native-public-mutation-evidence-file.json" + corpus = json.loads(fixture.read_text()) + for case in corpus["history_wire_cases"]: + def parse() -> object: + if case["kind"] == "pre-entry": + return _parse_pre_entry_result(case["response"].encode(), "step-1") + return _parse_observe_result(case["response"].encode(), "auths.gateway-outcome/3") + if case["accepted"]: + parse() + else: + with pytest.raises(GatewayProtocolError): + parse() diff --git a/bindings/python/tests/test_gateway_outcome_v2.py b/bindings/python/tests/test_gateway_outcome_v3.py similarity index 93% rename from bindings/python/tests/test_gateway_outcome_v2.py rename to bindings/python/tests/test_gateway_outcome_v3.py index 86593352b..4706c41ad 100644 --- a/bindings/python/tests/test_gateway_outcome_v2.py +++ b/bindings/python/tests/test_gateway_outcome_v3.py @@ -1,4 +1,4 @@ -"""Signed outcome `/2` conformance: the Python SDK accepts every vector the +"""Signed outcome `/3` conformance: the Python SDK accepts every vector the gateway signs, refuses the retired schema, and its native verifier reaches the gateway's decision on a grant that requires the outcome's stage.""" @@ -22,7 +22,7 @@ ) FIXTURE: dict[str, Any] = json.loads( - (Path(__file__).parents[2] / "fixtures" / "gateway" / "outcome-v2.json").read_text() + (Path(__file__).parents[2] / "fixtures" / "gateway" / "outcome-v3.json").read_text() ) MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor" @@ -72,8 +72,8 @@ async def handle( ) -def test_fixture_names_outcome_v2() -> None: - assert FIXTURE["outcome_schema"] == "auths.gateway-outcome/2" +def test_fixture_names_outcome_v3() -> None: + assert FIXTURE["outcome_schema"] == "auths.gateway-outcome/3" assert FIXTURE["accepted"] and FIXTURE["refused"] and FIXTURE["verdicts"] @@ -85,10 +85,10 @@ def test_python_client_accepts_every_signed_outcome( entry: dict[str, Any], tmp_path: Path ) -> None: result = asyncio.run( - _observe_outcome(tmp_path / "gateway.sock", entry, "auths.gateway-outcome/2") + _observe_outcome(tmp_path / "gateway.sock", entry, "auths.gateway-outcome/3") ) assert result == GatewaySignedObservation( - "auths.gateway-outcome/2", + "auths.gateway-outcome/3", entry["subject"], FIXTURE["observed_at"], MEDIA_TYPE, diff --git a/bindings/security-evidence-cutover-v1.json b/bindings/security-evidence-cutover-v1.json index 951a0afa3..864f2554e 100644 --- a/bindings/security-evidence-cutover-v1.json +++ b/bindings/security-evidence-cutover-v1.json @@ -14,8 +14,8 @@ { "claim": "An unknown write is recovered from a gateway-signed outcome or read-back, never by a blind retry, and a retired outcome schema is refused.", "evidence": [ - "bindings/python/tests/test_gateway_outcome_v2.py", - "bindings/typescript/test/integration/gateway-outcome-v2.test.js", + "bindings/python/tests/test_gateway_outcome_v3.py", + "bindings/typescript/test/integration/gateway-outcome-v3.test.js", "product/runtime/auths-gateway/src/scenario_tests.rs" ] }, @@ -56,7 +56,7 @@ { "path": "bindings/python/tests/test_product_errors.py", "disposition": "replaced", "evidence": ["bindings/python/tests/test_registry_code_inventory.py"] }, { "path": "bindings/python/tests/test_product_waist_conformance.py", "disposition": "replaced", "evidence": ["bindings/python/tests/test_native_boundary_contract.py", "bindings/python/tests/test_public_api_v2.py"] }, { "path": "bindings/python/tests/test_production_client.py", "disposition": "old remote control-plane client claim retired", "evidence": ["bindings/python/tests/test_gateway_client.py", "bindings/python/README.md"] }, - { "path": "bindings/python/tests/test_profile_runtime_v1.py", "disposition": "local-agent session and generated-package runtime retired; the gateway is the single provider-write path", "evidence": ["bindings/python/tests/test_gateway_client.py", "bindings/python/tests/test_gateway_outcome_v2.py"] }, + { "path": "bindings/python/tests/test_profile_runtime_v1.py", "disposition": "local-agent session and generated-package runtime retired; the gateway is the single provider-write path", "evidence": ["bindings/python/tests/test_gateway_client.py", "bindings/python/tests/test_gateway_outcome_v3.py"] }, { "path": "bindings/python/tests/test_receipt_inspection.py", "disposition": "replaced", "evidence": ["bindings/python/tests/test_public_api_v2.py", "bindings/python/tests/test_native_boundary_contract.py"] }, { "path": "bindings/python/tests/test_vocabulary_parity.py", "disposition": "replaced", "evidence": ["bindings/python/tests/test_public_api_v2.py", "bindings/public-topology-v1.json"] }, @@ -64,7 +64,7 @@ { "path": "bindings/typescript/test/integration/development-product.test.js", "disposition": "old callback-based development launch retired", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/README.md"] }, { "path": "bindings/typescript/test/integration/diagnostic.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/package/packed-doctor.test.js", "bindings/typescript/test/unit/public-api-v2.test.js"] }, { "path": "bindings/typescript/test/integration/effect-axis-boundary.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/contract/effect-axis.ts", "bindings/python/tests/test_registry_code_inventory.py"] }, - { "path": "bindings/typescript/test/integration/fixtures/crash-after-provider-entry.mjs", "disposition": "replaced by gateway attempt-store restart tests", "evidence": ["product/runtime/auths-gateway/src/scenario_tests.rs", "bindings/python/tests/test_gateway_outcome_v2.py"] }, + { "path": "bindings/typescript/test/integration/fixtures/crash-after-provider-entry.mjs", "disposition": "replaced by gateway attempt-store restart tests", "evidence": ["product/runtime/auths-gateway/src/scenario_tests.rs", "bindings/python/tests/test_gateway_outcome_v3.py"] }, { "path": "bindings/typescript/test/integration/identity.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js", "bindings/typescript/test/contract/nonforgeability.ts"] }, { "path": "bindings/typescript/test/integration/inspection.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js"] }, { "path": "bindings/typescript/test/integration/non-forgeability.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/contract/nonforgeability.ts", "bindings/python/tests/test_native_boundary_contract.py"] }, @@ -78,13 +78,13 @@ { "path": "bindings/typescript/test/unit/custody-conformance.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js"] }, { "path": "bindings/typescript/test/unit/doctor.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/package/packed-doctor.test.js"] }, { "path": "bindings/typescript/test/unit/github-agent.test.js", "disposition": "old remote endpoint GitHub launch claim retired", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/README.md"] }, - { "path": "bindings/typescript/test/unit/preparation-evidence.test.js", "disposition": "local-agent protected-lease preparation evidence retired with the local agent", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/test/integration/gateway-outcome-v2.test.js"] }, + { "path": "bindings/typescript/test/unit/preparation-evidence.test.js", "disposition": "local-agent protected-lease preparation evidence retired with the local agent", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/test/integration/gateway-outcome-v3.test.js"] }, { "path": "bindings/typescript/test/unit/product-errors.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/errors.test.js", "bindings/python/tests/test_registry_code_inventory.py"] }, { "path": "bindings/typescript/test/unit/product-waist-conformance.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js", "bindings/typescript/test/contract/nonforgeability.ts"] }, { "path": "bindings/typescript/test/unit/product.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js", "bindings/typescript/test/unit/gateway-client.test.js"] }, { "path": "bindings/typescript/test/unit/profile-file-node.test.js", "disposition": "generated-profile file reader retired with the local agent", "evidence": ["bindings/typescript/test/unit/profile-cli.test.js", "bindings/typescript/test/package/packed-profile-cli.test.js"] }, { "path": "bindings/typescript/test/unit/profile-runtime-limits.test.js", "disposition": "generated-profile descriptor limits retired with the local agent", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/test/unit/public-api-v2.test.js"] }, - { "path": "bindings/typescript/test/unit/receipt-integrity.test.js", "disposition": "local-agent receipt-integrity outcomes retired with the local agent", "evidence": ["bindings/typescript/test/unit/portable-receipt-v1.test.js", "bindings/typescript/test/integration/gateway-outcome-v2.test.js"] }, + { "path": "bindings/typescript/test/unit/receipt-integrity.test.js", "disposition": "local-agent receipt-integrity outcomes retired with the local agent", "evidence": ["bindings/typescript/test/unit/portable-receipt-v1.test.js", "bindings/typescript/test/integration/gateway-outcome-v3.test.js"] }, { "path": "bindings/typescript/test/unit/session-admission.test.js", "disposition": "local-agent session admission retired with the local agent", "evidence": ["bindings/typescript/test/unit/gateway-client.test.js", "bindings/typescript/test/unit/public-api-v2.test.js"] }, { "path": "bindings/typescript/test/unit/testkit.test.js", "disposition": "replaced", "evidence": ["bindings/typescript/test/unit/public-api-v2.test.js"] } ] diff --git a/bindings/typescript/README.md b/bindings/typescript/README.md index 69665021b..0fb05f5c7 100644 --- a/bindings/typescript/README.md +++ b/bindings/typescript/README.md @@ -118,3 +118,10 @@ published release. Publication, promotion, and independent-review status remain governed by `sdk-capability.json`. + +The application observation protocol is `auths.gateway-observe/4`. Public signed +outcomes use `auths.gateway-outcome/3` and hiding effect/record references; public +pre-entry history returns only the observation count and a hiding record +commitment. No protected observation bytes or raw content-derived digests are +returned. Operator-only `auths-gateway audit-export` completes private audit +bundles; these are not application SDK results. Superseded schemas are rejected. diff --git a/bindings/typescript/api/public-api.txt b/bindings/typescript/api/public-api.txt index f423ebfb6..301daa263 100644 --- a/bindings/typescript/api/public-api.txt +++ b/bindings/typescript/api/public-api.txt @@ -1,5 +1,5 @@ # Installed @auths-dev/sdk public API v1 -# declaration-sha256 c148be1e92ca3fd36566796f02d985ac8dfe646e5a0a79bfa96eecda2652c207 +# declaration-sha256 fb3421417faea607509803e70a0e7c4741c1f72598b30b6aabc97266d0772d28 . AuthsError value+type . AuthsIssue type . EffectState type diff --git a/bindings/typescript/docs/customer-journey-matrix.md b/bindings/typescript/docs/customer-journey-matrix.md index 9f8ada7ec..6702b34e4 100644 --- a/bindings/typescript/docs/customer-journey-matrix.md +++ b/bindings/typescript/docs/customer-journey-matrix.md @@ -8,7 +8,7 @@ verification contracts. | Journey | Semantic owner | TypeScript evidence | Python evidence | | --- | --- | --- | --- | | Submit one exact authorized write without an app provider credential | Gateway engine | `test/unit/gateway-client.test.js` | `tests/test_gateway_client.py` | -| Verify a gateway-signed outcome and refuse a retired schema | Gateway outcome signer plus Rust verifier | `test/integration/gateway-outcome-v2.test.js` | `tests/test_gateway_outcome_v2.py` | +| Verify a gateway-signed outcome and refuse a retired schema | Gateway outcome signer plus Rust verifier | `test/integration/gateway-outcome-v3.test.js` | `tests/test_gateway_outcome_v3.py` | | Require approvals from any K of N named approvers for one exact action | Approval-quorum authoring and the Rust verifier | `test/integration/approval-quorum.test.js` | `tests/test_approval_quorum.py` | | Run one application-owned exact MCP operation | MCP profile plus self-hosted runner | `test/integration/self-hosted.test.js` | `tests/test_self_hosted_execution.py` | | Verify existing evidence without an effect | Rust verifier | `@auths-dev/sdk/verify` | `auths.verify` | diff --git a/bindings/typescript/sdk-capability.json b/bindings/typescript/sdk-capability.json index 7fe21164a..7141eb70d 100644 --- a/bindings/typescript/sdk-capability.json +++ b/bindings/typescript/sdk-capability.json @@ -40,7 +40,7 @@ "semanticSafety": { "status": "verified", "evidence": ["test/contract/nonforgeability.ts", "test/contract/effect-axis.ts"] }, "typeSafety": { "status": "verified", "evidence": ["test/contract/nonforgeability.ts", "test/contract/self-hosted.ts"] }, "productionIntegration": { "status": "external-review-required", "evidence": ["../../docs/specs/0040-generic-profile-sdk-and-contributor-system.md"] }, - "operationalCompleteness": { "status": "external-review-required", "evidence": ["test/integration/gateway-outcome-v2.test.js", "../../product/runtime/auths-gateway/src/engine.rs"] }, + "operationalCompleteness": { "status": "external-review-required", "evidence": ["test/integration/gateway-outcome-v3.test.js", "../../product/runtime/auths-gateway/src/engine.rs"] }, "debuggability": { "status": "verified", "evidence": ["src/doctor.ts", "README.md"] }, "extensibility": { "status": "verified", "evidence": ["src/self-hosted.ts", "src/testkit/self-hosted-conformance.ts"] }, "portability": { "status": "verified", "evidence": ["test/package/packed-node.test.js", "test/package/packed-browser.mjs"] }, diff --git a/bindings/typescript/src/gateway.ts b/bindings/typescript/src/gateway.ts index a7ab9bfe2..42e64cae0 100644 --- a/bindings/typescript/src/gateway.ts +++ b/bindings/typescript/src/gateway.ts @@ -8,9 +8,9 @@ import { createConnection } from "node:net"; import { platform } from "node:os"; const REQUEST_SCHEMA = "auths.gateway-submit/2"; -const OBSERVE_SCHEMA = "auths.gateway-observe/3"; +const OBSERVE_SCHEMA = "auths.gateway-observe/4"; const READ_BACK_SCHEMA = "auths.gateway-readback/1"; -const OUTCOME_SCHEMA = "auths.gateway-outcome/2"; +const OUTCOME_SCHEMA = "auths.gateway-outcome/3"; const OBSERVATION_MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor"; const MAX_OBSERVATION_BYTES = 4_096; const MAX_SUBJECT_BYTES = 1_024; @@ -103,7 +103,7 @@ export type GatewayResult = */ export type GatewaySignedObservation = Readonly<{ outcome: "signed"; - schema: "auths.gateway-readback/1" | "auths.gateway-outcome/2"; + schema: "auths.gateway-readback/1" | "auths.gateway-outcome/3"; subject: string; observedAt: number; mediaType: "application/vnd.auths.observation.v1+cbor"; @@ -115,17 +115,12 @@ export type GatewayObserveResult = | GatewaySignedObservation | Readonly<{ outcome: "refused"; code: string }>; -/** - * The signed pre-entry observations the gateway stored for one operation: each the exact - * canonical `auths.gateway-readback/1` observation it signed after the credential lease - * and before the write, in pointer order, and empty when none were recorded. The - * gateway signs nothing new to answer and contacts no provider. An audit bundle carries - * them as an entry's `pre_entry_b64`. - */ +/** Redacted pre-entry history; protected observation bytes stay with the operator. */ export type GatewayPreEntryObservations = Readonly<{ outcome: "pre-entry"; operationId: string; - observations: readonly Uint8Array[]; + observations: number; + recordCommitment: string; }>; /** Closed result of a pre-entry request: the stored observations, or a refusal. */ @@ -258,7 +253,7 @@ function parseResult(bytes: Uint8Array): GatewayResult { const value = decoded as Record; const outcome = value.outcome; if (outcome === "denied" || outcome === "indeterminate" || outcome === "not-entered") { - if (!exactKeys(value, ["outcome", "code"]) || typeof value.code !== "string" || value.code.length < 1 || value.code.length > 128) { + if (!exactKeys(value, ["outcome", "code"]) || typeof value.code !== "string" || value.code.length < 1 || utf8Length(value.code) > 128) { throw new GatewayProtocolError("gateway returned invalid refusal"); } return { outcome, code: value.code }; @@ -353,22 +348,19 @@ function parsePreEntryResult(bytes: Uint8Array, operationId: string): GatewayPre if (value.outcome === "refused") { return parseRefusal(value); } - const encoded = value.observations_b64; + const observations = value.observations; + const commitment = value.record_commitment; if ( value.outcome !== "pre-entry" - || !exactKeys(value, ["outcome", "operation_id", "observations_b64"]) + || !exactKeys(value, ["outcome", "operation_id", "observations", "record_commitment"]) || value.operation_id !== operationId - || !Array.isArray(encoded) - || encoded.length > MAX_PRE_ENTRY_OBSERVATIONS - || !encoded.every((item) => typeof item === "string") + || !Number.isSafeInteger(observations) + || (observations as number) < 0 || (observations as number) > MAX_PRE_ENTRY_OBSERVATIONS + || typeof commitment !== "string" || commitment.length !== 64 || !/^[0-9a-f]{64}$/u.test(commitment) ) { - throw new GatewayProtocolError("gateway returned invalid pre-entry observations"); + throw new GatewayProtocolError("gateway returned invalid pre-entry history"); } - return { - outcome: "pre-entry", - operationId, - observations: (encoded as string[]).map((item) => decodeBase64Url(item, MAX_OBSERVATION_BYTES)), - }; + return { outcome: "pre-entry", operationId, observations: observations as number, recordCommitment: commitment }; } function submission(input: Readonly<{ proof: Uint8Array; action: Uint8Array; approval: Uint8Array }>): Record { diff --git a/bindings/typescript/test/integration/gateway-outcome-v2.test.js b/bindings/typescript/test/integration/gateway-outcome-v3.test.js similarity index 89% rename from bindings/typescript/test/integration/gateway-outcome-v2.test.js rename to bindings/typescript/test/integration/gateway-outcome-v3.test.js index 4783ebbc2..5a1b9f0bf 100644 --- a/bindings/typescript/test/integration/gateway-outcome-v2.test.js +++ b/bindings/typescript/test/integration/gateway-outcome-v3.test.js @@ -9,11 +9,11 @@ import { test } from "node:test"; import { GatewayClient, GatewayEndpoint, GatewayProtocolError } from "../../dist/gateway.js"; import { createVerifier } from "../../dist/verify.js"; -// Signed outcome `/2` conformance: the TypeScript SDK accepts every vector the +// Signed outcome `/3` conformance: the TypeScript SDK accepts every vector the // gateway signs, refuses the retired schema, and its WASM verifier reaches the // gateway's decision on a grant that requires the outcome's stage. const fixture = JSON.parse(readFileSync( - new URL("../../../fixtures/gateway/outcome-v2.json", import.meta.url), "utf8", + new URL("../../../fixtures/gateway/outcome-v3.json", import.meta.url), "utf8", )); const MEDIA_TYPE = "application/vnd.auths.observation.v1+cbor"; const observation = (entry) => new Uint8Array(Buffer.from(entry.observation_b64, "base64")); @@ -51,17 +51,17 @@ async function observeOutcome(entry, schema) { } } -test("the fixture names outcome /2", () => { - assert.equal(fixture.outcome_schema, "auths.gateway-outcome/2"); +test("the fixture names outcome /3", () => { + assert.equal(fixture.outcome_schema, "auths.gateway-outcome/3"); assert.ok(fixture.accepted.length > 0 && fixture.refused.length > 0 && fixture.verdicts.length > 0); }); -test("the TypeScript client accepts every signed outcome /2", { skip: process.platform === "win32" }, async () => { +test("the TypeScript client accepts every signed outcome /3", { skip: process.platform === "win32" }, async () => { for (const entry of fixture.accepted) { - const result = await observeOutcome(entry, "auths.gateway-outcome/2"); + const result = await observeOutcome(entry, "auths.gateway-outcome/3"); assert.deepEqual(result, { outcome: "signed", - schema: "auths.gateway-outcome/2", + schema: "auths.gateway-outcome/3", subject: entry.subject, observedAt: fixture.observed_at, mediaType: MEDIA_TYPE, @@ -75,7 +75,7 @@ test("the TypeScript client refuses the retired outcome schema", { skip: process await assert.rejects(observeOutcome(retired, "auths.gateway-outcome/1"), GatewayProtocolError); }); -test("the TypeScript verifier reaches the gateway verdict on every outcome /2 case", async () => { +test("the TypeScript verifier reaches the gateway verdict on every outcome /3 case", async () => { const verifier = await createVerifier(); const trustedContext = b64url(fixture.verdict_trusted_context_b64); for (const item of fixture.verdicts) { diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index d4d3de877..656cbac20 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -220,13 +220,13 @@ test("gateway recovery carries the native envelope and returns report bytes", { test("gateway client requests an outcome and surfaces a refusal as a result", { skip: process.platform === "win32" }, async () => { const subject = "auths-gateway://ns/operations/step-1"; - const signedOutcome = await observeOnce(signed({ schema: "auths.gateway-outcome/2", subject }), outcome); + const signedOutcome = await observeOnce(signed({ schema: "auths.gateway-outcome/3", subject }), outcome); assert.equal(signedOutcome.result.outcome, "signed"); - assert.equal(signedOutcome.result.schema, "auths.gateway-outcome/2"); + assert.equal(signedOutcome.result.schema, "auths.gateway-outcome/3"); assert.equal(signedOutcome.result.subject, subject); assert.deepEqual(signedOutcome.result.observation, OBSERVATION); assert.deepEqual(signedOutcome.seen, [{ - schema: "auths.gateway-observe/3", + schema: "auths.gateway-observe/4", request: { kind: "outcome", operation_id: "step-1" }, }]); const refused = await observeOnce('{"outcome":"refused","code":"gateway.observer.not-provisioned"}', outcome); @@ -238,21 +238,21 @@ test("gateway client rejects malformed observation frames", { skip: process.plat await assert.rejects(observeOnce(signed(), outcome), GatewayProtocolError); for (const hostile of [ signed({ schema: "retired" }), - signed({ schema: "auths.gateway-outcome/2", media_type: "application/cbor" }), - signed({ schema: "auths.gateway-outcome/2", subject: "" }), - signed({ schema: "auths.gateway-outcome/2", subject: "s".repeat(1025) }), - signed({ schema: "auths.gateway-outcome/2", observed_at: -1 }), - signed({ schema: "auths.gateway-outcome/2", observed_at: 1.5 }), - signed({ schema: "auths.gateway-outcome/2", observed_at: "1790000000" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: "" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: `${Buffer.from(OBSERVATION).toString("base64url")}=` }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: "+/8=" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: "AB" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: "A" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: "QUJD RA" }), - signed({ schema: "auths.gateway-outcome/2", observation_b64: Buffer.alloc(4097, 1).toString("base64url") }), - signed({ schema: "auths.gateway-outcome/2", confirmed: true }), - signed({ schema: "auths.gateway-outcome/2", observation: "AAAA" }), + signed({ schema: "auths.gateway-outcome/3", media_type: "application/cbor" }), + signed({ schema: "auths.gateway-outcome/3", subject: "" }), + signed({ schema: "auths.gateway-outcome/3", subject: "s".repeat(1025) }), + signed({ schema: "auths.gateway-outcome/3", observed_at: -1 }), + signed({ schema: "auths.gateway-outcome/3", observed_at: 1.5 }), + signed({ schema: "auths.gateway-outcome/3", observed_at: "1790000000" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: "" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: `${Buffer.from(OBSERVATION).toString("base64url")}=` }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: "+/8=" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: "AB" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: "A" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: "QUJD RA" }), + signed({ schema: "auths.gateway-outcome/3", observation_b64: Buffer.alloc(4097, 1).toString("base64url") }), + signed({ schema: "auths.gateway-outcome/3", confirmed: true }), + signed({ schema: "auths.gateway-outcome/3", observation: "AAAA" }), '{"outcome":"refused"}', '{"outcome":"refused","code":""}', '{"outcome":"refused","code":"x","reason":"y"}', @@ -270,18 +270,24 @@ test("gateway client requests stored pre-entry observations and refuses malforme const reply = (overrides = {}) => JSON.stringify({ outcome: "pre-entry", operation_id: "step-1", - observations_b64: [Buffer.from(OBSERVATION).toString("base64url")], + observations: 1, record_commitment: "01".repeat(32), ...overrides, }); const { result, seen } = await observeOnce(reply(), preEntry); - assert.deepEqual(result, { outcome: "pre-entry", operationId: "step-1", observations: [OBSERVATION] }); - assert.deepEqual(seen, [{ schema: "auths.gateway-observe/3", request: { kind: "pre-entry", operation_id: "step-1" } }]); - const empty = await observeOnce(reply({ observations_b64: [] }), preEntry); - assert.deepEqual(empty.result, { outcome: "pre-entry", operationId: "step-1", observations: [] }); + assert.deepEqual(result, { outcome: "pre-entry", operationId: "step-1", observations: 1, recordCommitment: "01".repeat(32) }); + assert.deepEqual(seen, [{ schema: "auths.gateway-observe/4", request: { kind: "pre-entry", operation_id: "step-1" } }]); + const empty = await observeOnce(reply({ observations: 0 }), preEntry); + assert.deepEqual(empty.result, { outcome: "pre-entry", operationId: "step-1", observations: 0, recordCommitment: "01".repeat(32) }); const refused = await observeOnce('{"outcome":"refused","code":"gateway.observer.operation-unknown"}', preEntry); assert.deepEqual(refused.result, { outcome: "refused", code: "gateway.observer.operation-unknown" }); for (const hostile of [ reply({ operation_id: "step-2" }), + reply({ observations: 5 }), + reply({ observations: -1 }), + reply({ observations: true }), + reply({ record_commitment: "01".repeat(31) }), + reply({ record_commitment: "AB".repeat(32) }), + reply({ record_commitment: "01".repeat(32) + "\n" }), reply({ observations_b64: Array(5).fill(Buffer.from(OBSERVATION).toString("base64url")) }), reply({ observations_b64: [""] }), reply({ observations_b64: [`${Buffer.from(OBSERVATION).toString("base64url")}=`] }), @@ -358,3 +364,13 @@ test("content controls reject invalid operation and ACK bounds", async () => { await assert.rejects(client.acknowledgeDisclosure("fixture-1", acknowledgement), TypeError); } }); + + +test("history parsers agree with native public outcome and pre-entry corpus", { skip: process.platform === "win32" }, async () => { + const corpus = JSON.parse(await readFile(new URL("../../../fixtures/gateway/native-public-mutation-evidence-file.json", import.meta.url), "utf8")); + for (const item of corpus.history_wire_cases) { + const request = (client) => item.kind === "pre-entry" ? client.observePreEntry("step-1") : client.observeOutcome("step-1"); + if (item.accepted) await observeOnce(item.response, request); + else await assert.rejects(observeOnce(item.response, request), GatewayProtocolError, item.case); + } +}); diff --git a/compliance.toml b/compliance.toml index f7ba2e8fe..d86ee45a5 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1310,7 +1310,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway/fuzz" core_apis = ["auths-codec", "auths-model"] -protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/16", "auths.gateway-outcome/2", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] +protocol_versions = ["auths.gateway-recipe-source/3", "auths.gateway-attempt/16", "auths.gateway-outcome/3", "auths.gateway-observe/4", "auths.gateway-recover/1", "auths.gateway-admin-request/2"] wire_objects = ["CompiledRecipe", "ClosedProviderRequest", "GatewayAttemptSnapshot", "SignedObservation", "AdminRequestCommand"] fixture_suites = ["bindings/fixtures/gateway", "product/runtime/auths-gateway/fuzz/corpus"] principal_families = ["raw-key-v1"] @@ -1455,8 +1455,8 @@ language-binding = [ "bindings/python/tests/test_openapi_derivation.py#test_derive_generate_check_and_hand_edit", "bindings/python/tests/test_public_api_v2.py#test_exact_public_inventory", "bindings/python/tests/test_portable_receipt_v1.py#test_portable_receipt_v1_rejects_contradictory_projection", - "bindings/python/tests/test_gateway_outcome_v2.py#test_python_client_accepts_every_signed_outcome", - "bindings/python/tests/test_gateway_outcome_v2.py#test_python_verifier_reaches_the_gateway_verdict", + "bindings/python/tests/test_gateway_outcome_v3.py#test_python_client_accepts_every_signed_outcome", + "bindings/python/tests/test_gateway_outcome_v3.py#test_python_verifier_reaches_the_gateway_verdict", "bindings/python/tests/test_self_hosted_operator.py#test_trusted_context_is_the_native_compile_bound_to_one_request", "bindings/python/tests/test_self_hosted_operator.py#test_root_grant_equals_the_native_path_and_carries_the_signer_evidence", "bindings/python/tests/test_enforcement_init.py#test_double_mode_hands_the_key_on_unchanged_and_writes_only_its_digest", @@ -1498,7 +1498,7 @@ security_state = [] [packages.auths-proof-wasm.claims] core-wire-consumer = ["bindings/wasm/auths-proof-wasm/src/lib.rs#authoring_abi_planning_matches_the_native_owner", "bindings/wasm/auths-proof-wasm/src/lib.rs#native_mcp_authorization_assembly_matches_profile_and_core_owners", "bindings/wasm/auths-proof-wasm/src/lib.rs#native_wasm_boundary_matches_the_portable_contract", "bindings/wasm/auths-proof-wasm/src/lib.rs#root_grant_statement_matches_the_native_model", "bindings/wasm/auths-proof-wasm/src/lib.rs#trusted_context_template_matches_the_rust_sdk_builder", "bindings/wasm/auths-proof-wasm/src/lib.rs#trusted_context_template_carries_approvals_like_the_rust_sdk_builder"] -language-binding = ["bindings/typescript/test/integration/remote-approval.test.js#TypeScript issues the native requests", "bindings/typescript/test/integration/remote-approval.test.js#TypeScript opens every request vector with the native code", "bindings/typescript/test/integration/remote-approval.test.js#TypeScript collects every vector with the native statuses and proof", "bindings/typescript/test/integration/approval-quorum.test.js#TypeScript authors the exact gateway quorum bytes", "bindings/typescript/test/integration/approval-quorum.test.js#the TypeScript verifier decides every gateway vector identically", "bindings/typescript/test/integration/approval-quorum.test.js#TypeScript authors the exact gateway quorum bytes remotely", "bindings/typescript/test/integration/remote-approval.test.js#the actor signs the native action with its grant chain", "bindings/typescript/test/unit/portable-receipt-v1.test.js#packaged WASM exposes the canonical portable receipt decoder", "bindings/typescript/test/unit/public-api-v2.test.js#clean-cut modules expose the intended domain-neutral surface", "bindings/typescript/test/unit/self-hosted-authority.test.js#compileTrustedContext reproduces the Rust SDK builder's quorum template byte for byte", "bindings/typescript/test/unit/self-hosted-authority.test.js#a root grant's critical extension reaches the verifier, which enforces it", "bindings/typescript/test/integration/gateway-outcome-v2.test.js#the TypeScript client accepts every signed outcome /2", "bindings/typescript/test/integration/gateway-outcome-v2.test.js#the TypeScript verifier reaches the gateway verdict on every outcome /2 case"] +language-binding = ["bindings/typescript/test/integration/remote-approval.test.js#TypeScript issues the native requests", "bindings/typescript/test/integration/remote-approval.test.js#TypeScript opens every request vector with the native code", "bindings/typescript/test/integration/remote-approval.test.js#TypeScript collects every vector with the native statuses and proof", "bindings/typescript/test/integration/approval-quorum.test.js#TypeScript authors the exact gateway quorum bytes", "bindings/typescript/test/integration/approval-quorum.test.js#the TypeScript verifier decides every gateway vector identically", "bindings/typescript/test/integration/approval-quorum.test.js#TypeScript authors the exact gateway quorum bytes remotely", "bindings/typescript/test/integration/remote-approval.test.js#the actor signs the native action with its grant chain", "bindings/typescript/test/unit/portable-receipt-v1.test.js#packaged WASM exposes the canonical portable receipt decoder", "bindings/typescript/test/unit/public-api-v2.test.js#clean-cut modules expose the intended domain-neutral surface", "bindings/typescript/test/unit/self-hosted-authority.test.js#compileTrustedContext reproduces the Rust SDK builder's quorum template byte for byte", "bindings/typescript/test/unit/self-hosted-authority.test.js#a root grant's critical extension reaches the verifier, which enforces it", "bindings/typescript/test/integration/gateway-outcome-v3.test.js#the TypeScript client accepts every signed outcome /3", "bindings/typescript/test/integration/gateway-outcome-v3.test.js#the TypeScript verifier reaches the gateway verdict on every outcome /3 case"] [packages.auths-openapi-derive-wasm] kind = "cargo" @@ -1641,7 +1641,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway" core_apis = ["auths-author", "auths-codec", "auths-did-keri", "auths-did-key", "auths-model", "auths-multikey", "auths-ports", "auths-raw-key", "auths-raw-key-core", "auths-registries", "auths-signature", "auths-verifier"] -protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/2", "auths.gateway-public-evidence/1", "auths.gateway-public-commitment/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/3", "auths.gateway-recover/1", "auths.gateway-outcome/2", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/2", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] +protocol_versions = ["auths.gateway-disclose/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclosure-acknowledge/1", "auths.gateway-execution-witness/1", "auths.gateway-commissioning-execution/1", "auths.gateway-commissioning-budget/1", "auths.qualification-commissioning-permit/2", "auths.qualification-commissioning-budget-key/1", "auths.qualification-commissioning-budget-binding/2", "auths.gateway-credential-journal/1", "auths.gateway-credential-collection/1", "auths.gateway-readiness/1", "auths.gateway-support-bundle/2", "auths.gateway-generation-floor/1", "auths.gateway-emergency-stop/1", "auths.gateway-installation/7", "auths.effect-policy/1", "auths.effect-review-contract/1", "auths.private-effect-review/2", "auths.literal-complete-review/1", "auths.effect-configuration/2", "auths.effect-entry/3", "auths.effect-configuration-review/1", "auths.bound-effect/3", "auths.gateway-recovery-read/1", "auths.gateway-candidate-check/1", "auths.gateway-credential-candidate/1", "auths.gateway-disclosure-ack/1", "auths.gateway-disclosure/1", "auths.gateway-unix-disclosure-channel/1", "auths.gateway-disclosure-auth/1", "auths.gateway-content-read/1", "auths.gateway-content-acquisition/1", "auths.gateway-protected-content/1", "auths.gateway-recovery/2", "auths.gateway-public-evidence/1", "auths.gateway-public-commitment/1", "auths.gateway-private-outcome/1", "auths.gateway-private-audit/1", "auths.effect-allocation/1", "auths.exact-effect-approval/1", "auths.private-effect-signing/2", "auths.recipe-qualification/1", "auths.recipe-qualification-attestation/1", "auths.qualification-trust-root/1", "auths.qualification-signer-certificate/1", "auths.qualification-revocation-list/1", "auths.qualification-release-index/1", "auths.gateway-semantic-closure/1", "auths.qualification-verification-vectors/1", "auths.gateway-operator-attestation/2", "auths.gateway-admin-request/2", "auths.gateway-admin-response/2", "auths.gateway-connection/1", "auths.provider-connection/2", "auths.gateway-key-identity/1", "auths.lifecycle.transactional-store/4", "auths.gateway-recipe-source/3", "auths.gateway-compiled-recipe/2", "auths.gateway-recipe-review/3", "auths.gateway-recovery-capability/1", "auths.gateway-connection-descriptor/1", "auths.gateway-attempt/16", "auths.gateway-pre-entry/1", "auths.lifecycle.postgresql/8", "auths.gateway-echo/1", "auths.gateway-idempotency-key/1", "auths.gateway-observe/4", "auths.gateway-recover/1", "auths.gateway-outcome/3", "auths.gateway-readback/1", "auths.self-hosted-profile-lock/1", "mcp-arguments-v1", "auths.gateway-audit-bundle/3", "auths.gateway-audit-report/3", "auths.gateway-counter-set/1", "auths.gateway-echo-verification/1", "auths.gateway-codes/1", "auths.gateway-production-codes/1", "auths.gateway-custody-vectors/1", "auths.gateway-outcome-vectors/1", "bounded-policy-commitment-v1", "auths.approval-response/1", "auths.gateway-bounded-count/2", "auths.gateway-bounded-sum/1", "auths.gateway.argument-ceiling-window-count/2", "auths.gateway.argument-ceiling-policy/2"] wire_objects = ["AppDisclosure", "AppDisclosureTarget", "AppContentResult", "ContentHistory", "AppContent", "AppContentHistory", "AppDisclosureAcknowledgement", "UnixDisclosurePolicy","ContentReadTarget", "ClosedContentRead", "DisclosureAcknowledgementRequest", "DisclosureAcknowledgement", "CandidateCredentialTarget", "CandidatePublication", "GatewayExecutionWitness", "CommissioningBudgetSnapshot", "CompiledRecipe", "ClosedProviderRequest", "ClosedCredentialReads", "RecipeReview", "RecoveryCapability", "GatewayAttemptSnapshot", "GatewayPreEntry", "GatewayRecordEntry", "GatewayConnectionDescriptor", "ConnectionRecord", "OperatorAttestation", "OperatorStatement", "GatewayAdminStatus", "GatewayEvidenceSummary", "GatewayObserveRequest", "GatewayObserveResult", "AppRecovery", "AppRecoveryResult", "GatewayProviderEvidence", "GatewaySubmitResult", "SignedObservation", "ArgumentCeilingPolicy", "BoundedPolicyCommitment", "AuditReport", "ProviderResult", "AuditedPreEntry", "EchoVerification", "AdminRequestCommand", "ListedValues"] fixture_suites = ["bindings/fixtures/approval", "bindings/fixtures/gateway", "bindings/fixtures/qualification"] principal_families = ["raw-key-v1", "did-key-v1", "did-keri-v1"] @@ -1966,7 +1966,8 @@ principal-evidence-integration = [ "product/runtime/auths-gateway/src/audit_tests.rs#audit_requires_the_counter_set_the_audit_derives", "product/runtime/auths-gateway/src/audit_tests.rs#audit_checks_the_pre_entry_observations", "product/runtime/auths-gateway/src/audit_tests.rs#audit_applies_the_account_scope_binding", - "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_v2_vectors_are_current", + "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#private_outcome_v1_vectors_are_current", + "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#public_outcome_v3_vectors_are_current", "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verifier_accepts_every_vector_with_its_facts_and_refuses_the_rest", "product/runtime/auths-gateway/src/pending_vectors/outcomes.rs#outcome_verdicts_follow_the_stage_condition", "product/runtime/auths-gateway/src/pending_vectors/codes.rs#gateway_codes_inventory_is_closed", @@ -1986,7 +1987,7 @@ kind = "cargo" layer = "product" path = "product/runtime/auths-gateway-kernel" core_apis = [] -protocol_versions = ["auths.gateway-recovery-capability/1", "auths.gateway-outcome/2"] +protocol_versions = ["auths.gateway-recovery-capability/1", "auths.gateway-outcome/3"] wire_objects = ["BuiltRequest", "RecoveryCapability", "SubmitDecision", "AttemptView", "OutcomeFacts"] fixture_suites = ["bindings/fixtures/gateway"] principal_families = [] @@ -2184,7 +2185,7 @@ kind = "npm" layer = "demos" path = "demos/stripe-gateway" core_apis = [] -protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1"] +protocol_versions = ["auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/3", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport"] fixture_suites = ["demos/stripe-gateway", "qualification/simulation/live/stripe-platform"] principal_families = ["raw-key-v1"] @@ -2208,7 +2209,7 @@ kind = "npm" layer = "demos" path = "demos/airtable-gateway" core_apis = [] -protocol_versions = ["auths.airtable-gateway-demo/2", "auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/2", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1", "auths.private-effect-review/2", "auths.private-effect-signing/2", "auths.gateway-content-read/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclose/1", "auths.gateway-unix-disclosure-channel/1"] +protocol_versions = ["auths.airtable-gateway-demo/2", "auths-proof/v1", "auths.gateway-submit/2", "auths.gateway-audit-bundle/3", "auths.gateway-recipe-source/3", "auths.exact-effect-approval/1", "auths.gateway-recover/1", "auths.private-effect-review/2", "auths.private-effect-signing/2", "auths.gateway-content-read/1", "auths.gateway-content/1", "auths.gateway-content-history/1", "auths.gateway-disclose/1", "auths.gateway-unix-disclosure-channel/1"] wire_objects = ["CanonicalAction", "ProofBundle", "SignedObservation", "GatewayAuditBundle", "ExactEffectApproval", "GatewayRecoveryReport", "AcquisitionSnapshot", "DisclosureSnapshot"] fixture_suites = ["demos/airtable-gateway", "bindings/fixtures/gateway/airtable"] principal_families = ["raw-key-v1"] diff --git a/demos/airtable-gateway/README.md b/demos/airtable-gateway/README.md index 3a34a7883..a1234d0ba 100644 --- a/demos/airtable-gateway/README.md +++ b/demos/airtable-gateway/README.md @@ -61,8 +61,9 @@ docker run --platform linux/amd64 --rm --init --name auths-airtable-gateway-demo Open . Choose **Set exact record to Approved**, then replay, approval, unsupported value, swapped record, two-gateway race and response-loss controls. The UI and CLI show actual native gateway results. Their history is unsigned; -**Inspect the evidence** exposes native signed outcome/pre-entry bytes in the -actual gateway audit-bundle format. Missing evidence remains missing. +**Inspect the evidence** exposes redacted signed public outcomes and a submission +inventory. Protected pre-entry observations and full audit facts are available +only through the operator export below. Missing evidence remains missing. Default mode is clearly labeled **simulation**. An independent HTTP double counts real native reads and PATCH entries; it never reaches Airtable. Two @@ -120,6 +121,21 @@ docker exec --user 62004:62005 auths-airtable-gateway-demo \ /opt/consumer/bin/python /opt/demo/app.py export > audit-bundle.json ``` +The application export contains public history, not a completed private audit. In +a trusted operator shell, while the gateway is running, complete it with native +journal evidence in a new owner-private file: + +```sh +docker exec auths-airtable-gateway-demo /opt/demo/bin/auths-gateway-simulation \ + audit-export --state-dir /run/demo/gateway0 \ + --bundle /run/demo/app/audit.json --out /run/demo/private/audit-bundle.json +``` + +Run the offline auditor against that private bundle with independently pinned +trust and observer values. Keep the bundle and detailed report in the operator +boundary; public output does not contain protected facts. The export is read-only, +never overwrites an existing file, and grants no provider entry or retry. + An IPC failure is unconfirmed, never permission to send another PATCH. Operator-only recovery uses a separately authorized native read and exact approval; diagnostics remain available through the shipped CLI: diff --git a/demos/airtable-gateway/app.py b/demos/airtable-gateway/app.py index fdf80fd9f..4714f1be3 100644 --- a/demos/airtable-gateway/app.py +++ b/demos/airtable-gateway/app.py @@ -19,7 +19,7 @@ from auths.authoring import (GrantEvidence, collect_approvals, propose_mcp_approval, sign_approval_action) from auths.gateway import (GatewayClient, GatewayEndpoint, GatewayProtocolError, - GatewaySignedObservation, GatewayPreEntryObservations) + GatewaySignedObservation) from auths.self_hosted import load_signer_file from demo_common import Refusal, b64, canonical, decode, read, require, unb64, write @@ -219,9 +219,6 @@ async def remember(self, packet, record): observed = await self.clients[0].observe_outcome(operation) if isinstance(observed, GatewaySignedObservation): entry['outcome_b64'] = b64(observed.observation) - pre = await self.clients[0].observe_pre_entry(operation) - if isinstance(pre, GatewayPreEntryObservations): - entry['pre_entry_b64'] = [b64(item) for item in pre.observations] except GatewayProtocolError: pass # Missing signed evidence stays missing; audit must report it. self.entries[operation] = entry @@ -341,7 +338,7 @@ async def execute(self, experiment): return result def audit(self): - return {'schema': 'auths.gateway-audit-bundle/2', + return {'schema': 'auths.gateway-audit-bundle/3', 'recipe_b64': self.plan['recipe_source_b64'], 'profile_lock_b64': b64(read(HERE / 'profile.lock.json')), 'trusted_context_b64': self.plan['contexts'][0], diff --git a/demos/airtable-gateway/operate.py b/demos/airtable-gateway/operate.py index e9911bec3..93b0869dc 100644 --- a/demos/airtable-gateway/operate.py +++ b/demos/airtable-gateway/operate.py @@ -647,6 +647,13 @@ def application(self, *arguments): return subprocess.run(['/opt/consumer/bin/python', str(HERE / 'app.py'), *arguments], env=ENVIRONMENT, capture_output=True, user=APP_UID, group=APP_GID, extra_groups=[], timeout=90) + def export_audit(self, destination): + # Only the operator can reach native private audit facts. The application + # bundle is an untrusted submission inventory with redacted public history. + gateway(self.binary, 'audit-export', '--state-dir', HOME / 'gateway0', + '--bundle', HOME / 'app/audit.json', '--out', destination) + return destination + def witnesses(self): values = [] for host in range(3): diff --git a/demos/airtable-gateway/selftest.py b/demos/airtable-gateway/selftest.py index 08c24c725..63720eba6 100644 --- a/demos/airtable-gateway/selftest.py +++ b/demos/airtable-gateway/selftest.py @@ -129,7 +129,9 @@ def execute(label): 'DemoStatus': action['replacement'], 'auths_echo': echo}, 'demo.selftest-independent-read-back') require(evidence[commitment_field] != digest(raw), 'demo.selftest-public-raw-evidence-digest') - cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(raw)} + from operate import PRIVATE + write(PRIVATE / ('independent-readback-' + label + '.json'), raw, new=True) + cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'exact_fields_and_native_link_checked': True} for label in ['replay', 'typescript']: _, records, traffic = execute(label) require(records[0]['outcome'] == 'observed-by-provider' @@ -285,14 +287,27 @@ def test_application_isolation_and_native_audit(operator): require(checks['observer-custody']['state'] == 'not-ready', 'demo.selftest-software-observer-not-production-ready') pins = decode(read(HOME / 'private/pins.json')) - audit = child([operator.binary, 'audit', '--bundle', HOME / 'app/audit.json', + private_bundle = operator.export_audit(HOME / 'private/verified-audit.json') + audit = child([operator.binary, 'audit', '--bundle', private_bundle, '--trusted-context-sha256', pins['trusted_context_sha256'], '--observer', pins['observer']['observer_anchor']['principal']]) + private_report = HOME / 'private/verified-audit-report.json' + write(private_report, audit.stdout, new=True) + for protected in [private_bundle, private_report]: + probe = subprocess.run(['/opt/consumer/bin/python', '-c', + 'import sys; open(sys.argv[1], "rb").read()', str(protected)], + user=APP_UID, group=APP_GID, extra_groups=[], env=ENVIRONMENT, capture_output=True) + require(probe.returncode != 0 and not probe.stdout, 'demo.selftest-private-audit-readable-by-app') + require(protected.stat().st_mode & 0o777 == 0o600, 'demo.selftest-private-audit-mode') result = decode(audit.stdout) require(result['inconsistent'] == 0 and result['unverified'] == 0 and len(result['approval_responses']) >= 2, 'demo.selftest-audit-open') - return {'doctor': doctor_value, 'audit': result} + # Full native report is protected. Publish only aggregate verification + # counts; preserve all detailed assertions above in the operator process. + summary = {key: result[key] for key in ['verified', 'refused', 'unverified', 'inconsistent']} + summary['private_report_retained'] = True + return {'doctor': doctor_value, 'audit': summary} def test_exact_operator_consent_binding(operator): @@ -392,6 +407,32 @@ def run(operator): capture_output=True, timeout=30) require(support.returncode == 0, 'demo.selftest-support-refused') published = data + audit + support.stdout + protected_report = decode(read(HOME / 'private/verified-audit-report.json')) + protected_digests = [] + for entry in protected_report['entries']: + result = entry.get('provider_result') or {} + for key in ['response_digest', 'evidence_digest', 'relative_basis_digest']: + if result.get(key): + protected_digests.append(bytes.fromhex(result[key])) + public_buffers = [published] + def collect_public(value): + if isinstance(value, dict): + for item in value.values(): + collect_public(item) + elif isinstance(value, list): + for item in value: + collect_public(item) + elif isinstance(value, str): + try: + public_buffers.append(base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))) + except (ValueError, UnicodeError): + pass + for payload in [decode(data), decode(audit), decode(support.stdout)]: + collect_public(payload) + for raw in protected_digests: + for encoded in [raw, raw.hex().encode(), base64.b64encode(raw), base64.urlsafe_b64encode(raw)]: + require(all(encoded not in payload for payload in public_buffers), + 'demo.selftest-public-private-body-digest-exposure') private_seeds = [read(HOME / 'private' / (name + '.seed')) for name in ['root', 'reader', 'manager-a', 'manager-b', 'manager-c']] for secret in list(operator.keys.values()) + private_seeds + [read(HOME / 'app/actor.seed')]: diff --git a/demos/airtable-gateway/tests/browser.py b/demos/airtable-gateway/tests/browser.py index 75d2654f6..fcd64de30 100644 --- a/demos/airtable-gateway/tests/browser.py +++ b/demos/airtable-gateway/tests/browser.py @@ -24,7 +24,7 @@ def test_packaged_workbench_and_unsigned_evidence(): expect(page.locator('#submit')).to_be_enabled() expect(page.locator('#explanation')).to_contain_text('no automatic retry') page.locator('#receipt-link').click() - expect(page.locator('#result-json')).to_contain_text('auths.gateway-audit-bundle/2') + expect(page.locator('#result-json')).to_contain_text('auths.gateway-audit-bundle/3') expect(page.locator('#result-json')).to_contain_text('outcome_b64') page.screenshot(path='/evidence/workbench-evidence.png', full_page=True) page.goto('http://localhost:8081') diff --git a/demos/stripe-gateway/README.md b/demos/stripe-gateway/README.md index 94f7b6f5b..d69441350 100644 --- a/demos/stripe-gateway/README.md +++ b/demos/stripe-gateway/README.md @@ -7,8 +7,9 @@ gateway state. No coupled Stripe vertical service executes this demo. The web workbench and CLI show the actual gateway result. Verification, admission, HTTP response and linked provider read-back are separate stages. -The evidence page exports the native audit-bundle format with available signed -outcome/pre-entry observations; its display and history are explicitly unsigned. +The evidence page exports a submission inventory with redacted signed public +outcomes; its display and history are explicitly unsigned. Full audit facts and +protected pre-entry observations are available only through the operator export. Every closed fixture action now traverses the public native approval protocol: the app constructs an exact typed proposal, two of three operator-held manager @@ -206,3 +207,18 @@ not disable that gate or provision shared environment credentials. The Stripe family's current report contributes only one of the two required live providers. Human review and actual GitHub-release installation are separate acceptance gates. See [AP-SPEC-067](../../docs/specs/0067-stripe-general-gateway-demo.md). + +The application export contains public history, not a completed private audit. In +a trusted operator shell, while the gateway is running, complete it with native +journal evidence in a new owner-private file: + +```sh +docker exec auths-stripe-gateway-demo /opt/demo/bin/auths-gateway-simulation \ + audit-export --state-dir /run/demo/gateway0 \ + --bundle /run/demo/app/audit.json --out /run/demo/private/audit-bundle.json +``` + +Run the offline auditor against that private bundle with independently pinned +trust and observer values. Keep the bundle and detailed report in the operator +boundary; public output does not contain protected facts. The export is read-only, +never overwrites an existing file, and grants no provider entry or retry. diff --git a/demos/stripe-gateway/app.py b/demos/stripe-gateway/app.py index a0e53c49c..40ed6c20d 100644 --- a/demos/stripe-gateway/app.py +++ b/demos/stripe-gateway/app.py @@ -18,7 +18,7 @@ from auths.authoring import (GrantEvidence, collect_approvals, propose_mcp_approval, sign_approval_action) from auths.gateway import (GatewayClient, GatewayEndpoint, GatewayProtocolError, - GatewaySignedObservation, GatewayPreEntryObservations) + GatewaySignedObservation) from auths.self_hosted import load_signer_file from demo_common import Refusal, b64, canonical, decode, read, require, unb64, write @@ -168,9 +168,6 @@ async def remember(self, packet, record): observed = await self.clients[0].observe_outcome(operation) if isinstance(observed, GatewaySignedObservation): entry['outcome_b64'] = b64(observed.observation) - pre = await self.clients[0].observe_pre_entry(operation) - if isinstance(pre, GatewayPreEntryObservations): - entry['pre_entry_b64'] = [b64(item) for item in pre.observations] except GatewayProtocolError: pass # Missing signed evidence stays missing; audit must report it. self.entries[operation] = entry @@ -274,7 +271,7 @@ async def execute(self, experiment): return result def audit(self): - return {'schema': 'auths.gateway-audit-bundle/2', + return {'schema': 'auths.gateway-audit-bundle/3', 'recipe_b64': b64(read(HERE / 'recipe.json')), 'profile_lock_b64': b64(read(HERE / 'profile.lock.json')), 'trusted_context_b64': self.plan['contexts'][0], diff --git a/demos/stripe-gateway/operate.py b/demos/stripe-gateway/operate.py index 4698ea665..ff0f13d96 100644 --- a/demos/stripe-gateway/operate.py +++ b/demos/stripe-gateway/operate.py @@ -547,6 +547,13 @@ def application(self, *arguments): return subprocess.run(['/opt/consumer/bin/python', str(HERE / 'app.py'), *arguments], env=ENVIRONMENT, capture_output=True, user=APP_UID, group=APP_GID, extra_groups=[], timeout=90) + def export_audit(self, destination): + # Only the operator can reach native private audit facts. The application + # bundle is an untrusted submission inventory with redacted public history. + gateway(self.binary, 'audit-export', '--state-dir', HOME / 'gateway0', + '--bundle', HOME / 'app/audit.json', '--out', destination) + return destination + def witnesses(self): values = [] for host in range(3): diff --git a/demos/stripe-gateway/selftest.py b/demos/stripe-gateway/selftest.py index 5f51bb7ff..ab5c0b162 100644 --- a/demos/stripe-gateway/selftest.py +++ b/demos/stripe-gateway/selftest.py @@ -138,7 +138,9 @@ def execute(label): and refund['metadata']['auths_echo'] == echo, 'demo.selftest-independent-read-back') require(evidence[commitment_field] != digest(refund_bytes), 'demo.selftest-public-raw-evidence-digest') - cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'response_sha256': digest(refund_bytes)} + from operate import PRIVATE + write(PRIVATE / ('independent-readback-' + label + '.json'), refund_bytes, new=True) + cases[-1]['independent_read_back'] = {'fixture_api_entries': 1, 'exact_fields_and_native_link_checked': True} for label in ['replay', 'typescript']: _, records, traffic = execute(label) require(records[0]['outcome'] == 'observed-by-provider' @@ -213,14 +215,27 @@ def test_application_isolation_and_native_audit(operator): require(checks['observer-custody']['state'] == 'not-ready', 'demo.selftest-software-observer-not-production-ready') pins = decode(read(HOME / 'private/pins.json')) - audit = child([operator.binary, 'audit', '--bundle', HOME / 'app/audit.json', + private_bundle = operator.export_audit(HOME / 'private/verified-audit.json') + audit = child([operator.binary, 'audit', '--bundle', private_bundle, '--trusted-context-sha256', pins['trusted_context_sha256'], '--observer', pins['observer']['observer_anchor']['principal']]) + private_report = HOME / 'private/verified-audit-report.json' + write(private_report, audit.stdout, new=True) + for protected in [private_bundle, private_report]: + probe = subprocess.run(['/opt/consumer/bin/python', '-c', + 'import sys; open(sys.argv[1], "rb").read()', str(protected)], + user=APP_UID, group=APP_GID, extra_groups=[], env=ENVIRONMENT, capture_output=True) + require(probe.returncode != 0 and not probe.stdout, 'demo.selftest-private-audit-readable-by-app') + require(protected.stat().st_mode & 0o777 == 0o600, 'demo.selftest-private-audit-mode') result = decode(audit.stdout) require(result['inconsistent'] == 0 and result['unverified'] == 0 and len(result['approval_responses']) >= 2, 'demo.selftest-audit-open') - return {'doctor': doctor_value, 'audit': result} + # Full native report is protected. Publish only aggregate verification + # counts; preserve all detailed assertions above in the operator process. + summary = {key: result[key] for key in ['verified', 'refused', 'unverified', 'inconsistent']} + summary['private_report_retained'] = True + return {'doctor': doctor_value, 'audit': summary} def test_exact_operator_consent_binding(operator): @@ -319,6 +334,32 @@ def run(operator): capture_output=True, timeout=30) require(support.returncode == 0, 'demo.selftest-support-refused') published = data + audit + support.stdout + protected_report = decode(read(HOME / 'private/verified-audit-report.json')) + protected_digests = [] + for entry in protected_report['entries']: + result = entry.get('provider_result') or {} + for key in ['response_digest', 'evidence_digest', 'relative_basis_digest']: + if result.get(key): + protected_digests.append(bytes.fromhex(result[key])) + public_buffers = [published] + def collect_public(value): + if isinstance(value, dict): + for item in value.values(): + collect_public(item) + elif isinstance(value, list): + for item in value: + collect_public(item) + elif isinstance(value, str): + try: + public_buffers.append(base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))) + except (ValueError, UnicodeError): + pass + for payload in [decode(data), decode(audit), decode(support.stdout)]: + collect_public(payload) + for raw in protected_digests: + for encoded in [raw, raw.hex().encode(), base64.b64encode(raw), base64.urlsafe_b64encode(raw)]: + require(all(encoded not in payload for payload in public_buffers), + 'demo.selftest-public-private-body-digest-exposure') private_seeds = [read(HOME / 'private' / (name + '.seed')) for name in ['root', 'reader', 'manager-a', 'manager-b', 'manager-c']] for secret in list(operator.keys.values()) + private_seeds + [read(HOME / 'app/actor.seed')]: diff --git a/demos/stripe-gateway/tests/browser.py b/demos/stripe-gateway/tests/browser.py index bbe635b9e..1a3de60ad 100644 --- a/demos/stripe-gateway/tests/browser.py +++ b/demos/stripe-gateway/tests/browser.py @@ -24,7 +24,7 @@ def test_packaged_workbench_and_unsigned_evidence(): expect(page.locator('#submit')).to_be_enabled() expect(page.locator('#explanation')).to_contain_text('no automatic retry') page.locator('#receipt-link').click() - expect(page.locator('#result-json')).to_contain_text('auths.gateway-audit-bundle/2') + expect(page.locator('#result-json')).to_contain_text('auths.gateway-audit-bundle/3') expect(page.locator('#result-json')).to_contain_text('outcome_b64') page.screenshot(path='/evidence/workbench-evidence.png', full_page=True) page.goto('http://localhost:8080') diff --git a/docs/adr/0013-recipe-capabilities-and-sum-budget.md b/docs/adr/0013-recipe-capabilities-and-sum-budget.md index f342078ad..c8479472a 100644 --- a/docs/adr/0013-recipe-capabilities-and-sum-budget.md +++ b/docs/adr/0013-recipe-capabilities-and-sum-budget.md @@ -249,7 +249,7 @@ evidence pipeline for the recipe it names. - Epics 2–7 of AP-SPEC-063 implement the capabilities. Epic 1 commits their vectors under `bindings/fixtures/gateway/` (`hostile-recipes-v2.json`, - `attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v2.json`, + `attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v3.json`, `key-identity.json`, and `codes.json`), each with a test showing that current code does not satisfy it. - ADR 0012 stays in force. Epic 8 rewrote its decision and consequences diff --git a/docs/adr/0014-stripe-refund-recipe-qualification.md b/docs/adr/0014-stripe-refund-recipe-qualification.md index 9a6713e53..8030ec5b7 100644 --- a/docs/adr/0014-stripe-refund-recipe-qualification.md +++ b/docs/adr/0014-stripe-refund-recipe-qualification.md @@ -61,7 +61,7 @@ the gateway receives only the restricted test key. ## Corpus, recovery and publication gates The maintained platform profile/recipe are accompanied by gateway -`attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v2.json` and +`attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v3.json` and `hostile-recipes-v2.json`. They must be expanded into the family-owned `auths.qualification-corpus/3` with executable coverage of every mandatory wall scenario; they are not the missing protected family corpus. diff --git a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md index 1ec8e3b4a..ed80bd8a6 100644 --- a/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md +++ b/docs/operations/GATEWAY_TRUST_AND_GIT_SIGNING_RUNBOOK.md @@ -299,7 +299,7 @@ custody is suspect. rotation. Do not disable the old key yet. 2. Record the new key's anchor facts: principal, `raw-key-v1`, verification method, `p256-sha256-v1`, both schemas (`auths.gateway-readback/1`, - `auths.gateway-outcome/2`), and both subject namespaces. For a + `auths.gateway-outcome/3`), and both subject namespaces. For a development seed, `auths-gateway observer-show` prints them together with `observer_custody`. 3. Update the trust as in §4, replacing the principal of the existing diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 28a203bf1..245b8472f 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -1,5 +1,18 @@ # AP-SPEC-074 implementation and evidence ledger +## Resumed — 5 November 2026 + +The user reactivated the complete AP074 goal. Main is reconciling the saved +signed-output/private-audit checkpoint with the published `3cb2caad` fixes and +finishing the direct native/SDK/demo cutover. The original full objective and +acceptance requirements remain in force; no completion claim is made. + +The CI subagent reports the published `3cb2caad` cohort is terminal: 88 passed, +zero failed and eight conditional skips. It verified 48 actual native selectors, +installed owner/UID evidence, 49 Kani harnesses, 329 Lean statements, source +closures and final evidence rollups. Main did not inspect CI. Its report is +`/tmp/ap074-ci-3cb2-report.md`; these results do not qualify subsequent changes. + ## User-requested pause — 30 October 2026 AP074 remains incomplete. The user requested a committed, pushed pause. @@ -3764,3 +3777,67 @@ or deployment claim is made by AP074 source work. `93ef3b915cc48f0c0d4c0d4de7e03d0ed394e83526fbdfdc2ad19443dec5ec20`. Semantic freeze 426 updates only the generator-required identity 169, evolution contract 83 and public surface 426; the metadata constructor passed. + +## Signed public history and private audit cutover — resumed implementation + +- Reconciled saved checkpoint `f55aa61a` over published `3cb2caad`, preserving the + completed CI repairs. App observe `/4` now returns signed public outcome `/3` + or redacted pre-entry history. Action, recipe and full journal-record references + are hiding HMACs scoped to the complete binding and private immutable nonce; + raw body-derived digests, pre-entry values and relative basis stay protected. + Recipe references are hiding because a recipe can include fixed private data. +- Operator-only `audit-export` uses the existing peer-UID gate and one native + snapshot. Private outcome `/1` retains all original full-fact presence, signature, + counter/recount, pre-entry and basis audit checks. Native bundle `/3` assembly + discards supplied public history and obtains private facts per operation; + absence remains unverified. It grants no admission or audit verdict. Bounded + sequence decoding, canonical base64 and aggregate caps apply before retaining + extra evidence. Serialization buffers and attached private export data are + zeroized on drop where owned by the new assembler. +- CLI export modes select one operation or one submission inventory, run under + the existing 60-second operator deadline, print only success metadata, and + create a new 0600 file in an owner-private directory. They cannot overwrite. + Both demos, maintained Python/TypeScript journeys and generated scaffold use + operator-side completion; the app receives only public projections. Detailed + private bundles/reports are not copied to public demo evidence. +- Cut over SDK types/parsers and native public/private vector corpora directly. + Removed the superseded outcome-v2 fixture and renamed affected binding tests. + Both SDKs consume 15 native mutation-result vectors plus 35 public-history + vectors covering malformed/obsolete/private schemas, byte/count/time limits, + duplicates, fractional/exponent numbers, BOM and noncanonical base64. Their + complete suites await hosted execution. The TypeScript declaration build and + required API snapshot constructor completed successfully. +- Artifact construction passed: file privacy 1 passed / 0 ignored (0.73 s), TLS + PostgreSQL privacy 1 passed / 0 ignored (0.92 s); admin/app/public/private/code + constructors 5 passed / 0 ignored (0.03 s); built native CLI inventory 1 passed / + 0 ignored (0.01 s); installed Unix interface constructor 1 passed / 0 ignored + (2.73 s). Two fixture setup defects were fixed: activate observer configuration + before compiling approvals and use the silent activation CLI's exit status. +- The Unix constructor now performs an actual approved mutation in addition to + acquisition/disclosure, inspects configured signed public history, completes a + private audit with one independently verified entry, checks 0600 output and + overwrite refusal, and preserves no-new-entry/custody and source-byte checks + under hostile app probes. Its inventory has 33 app cases, 12 operator commands + and 53 CLI help routes; the distinct-UID probe adds a fifth private CLI route. + Linux execution remains for hosted CI; this local constructor uses one UID. +- Added private-export substitution/duplicate/encoding/collection-limit tests + without weakening existing private-audit tamper assertions. These tests await + hosted execution. Redacted protected counter, relative-basis and pre-entry Debug + implementations as well as the native private-export Debug. +- Source-closure construction and rebuilt check each passed (1 passed / 0 ignored, + 0.11 s and 0.06 s). Exact combined-head hosted evidence remains required. No + complete acceptance row is closed by artifact construction alone. Main has not + inspected CI, migrated AP070, touched AP073 or expanded delegation. +- Final privacy-batch source closure is + `899847a8307da6574f1b83a8fa9d85e9d4d54fa4f94c2952f696dafacb2e8a07`. + Semantic-freeze metadata is 427, with generator-required increments only: + formal closure 106, identity 170, portable ABI 128, external custody 7, + public SDK 166, vocabulary 30, evolution 84 and public surface 427. + The prior metadata-constructor process handle expired before its final output + could be recovered; generated files are present, and hosted verification must + establish freshness on the committed revision. +- Both demos now retain detailed audit reports and independent read-back bodies + in private 0600 files. Public evidence carries bounded result counts and + checked-state flags. A recursive public-artifact scan checks raw, hex and + base64 provider/body-derived digests against retained private evidence. + These final Python changes await hosted execution. diff --git a/docs/plans/0074-public-output-checkpoint.md b/docs/plans/0074-public-output-checkpoint.md new file mode 100644 index 000000000..8783c07b5 --- /dev/null +++ b/docs/plans/0074-public-output-checkpoint.md @@ -0,0 +1,54 @@ +# AP074 public-output cutover checkpoint + +The user requested a committed, pushed pause on 30 October 2026 and resumed the +complete AP074 goal on 5 November 2026. AP074 remains incomplete. +The original checkpoint branch preserves unfinished work at `f55aa61a`. It has +now been reconciled onto `codex/effect-recovery-foundation` over `3cb2caad`; the +implementation ledger records subsequent integration and evidence. The original +checkpoint alone is not a qualification or merge candidate. + +## Saved work + +- Native hiding effect and full journal-record commitments under the existing + protected immutable nonce; the nonce is excluded from the sealed message. +- Public signed outcome `/3`, redacted pre-entry history and app observe `/4`. +- Operator-only `audit-export`, writing a new private 0600 file. The private + signed outcome `/1` retains the complete existing outcome presence predicate + and audit checks. This avoids exporting the journal nonce or adding a second + journal decoder. No journal schema or entry transition changes are intended. +- Python/TypeScript public pre-entry types and parser changes, native public `/3` + and private `/1` reference-vector constructors, and native sentinel assertions. + +## Construction evidence and limits + +The actual file-backed signed-public-output privacy constructor passed (1 passed, +0 ignored, 0.74 s), including the existing private evidence and native-signature +checks. The new public `/3` vector constructor passed (1 passed, 0 ignored, +0.04 s). A later small source edit consumed the public stage field and adjusted +Debug output; it has not been rebuilt. No SDK suite or broad gate ran locally. +These are artifact-construction checks, not complete acceptance or CI evidence. + +## Required before integrating this cutover + +1. Reconcile this checkpoint against the completed CI-repair commits on the PR. + Preserve the redacted Debug/assertion repairs and updated SDK API snapshot. +2. Finish native private export integration and all SDK/demo/example/template + consumers. Public app history must never carry raw protected pre-entry bytes + or private outcomes. Complete private audit bundles at the operator boundary; + keep existing offline audit, recount, basis, pre-entry and tamper checks. + Do not restore raw public echoes/digests or weaken any existing assertion. +3. Finish the direct schema/fixture cutover. Remove superseded public `/2` + fixtures/readers; keep full private fact fixtures explicitly private. Regenerate + all affected native catalogs, CLI inventory and Unix interface artifacts. + The new command must be covered by Linux wrong-UID and private-output probes. +4. Update the specification, compliance inventory, acceptance ledger, binding + documentation, source closure, semantic freeze and public API snapshot + atomically. The existing generated metadata is stale on this checkpoint. +5. Generate the required file and TLS PostgreSQL artifacts, commit the coherent + change, and give the CI subagent the exact SHA to publish and qualify. +6. Continue the remaining full AP074 acceptance work from the main status ledger. + Do not claim A17 or the entire specification complete from this checkpoint. + +AP070 remains the independent application-owned reference. AP073 remains paused +and untouched. No additional delegation is authorized. The user has resumed the main goal; continue the full acceptance work recorded +in the implementation ledger. diff --git a/docs/product/SELF_HOSTED_CLAIM_LEDGER.md b/docs/product/SELF_HOSTED_CLAIM_LEDGER.md index 804bb16c7..53e0c225b 100644 --- a/docs/product/SELF_HOSTED_CLAIM_LEDGER.md +++ b/docs/product/SELF_HOSTED_CLAIM_LEDGER.md @@ -158,10 +158,9 @@ The gateway can now hold an observer signing key and sign two kinds of observation for the application to attach to its next action: `auths.gateway-readback/1` (the value the gateway read from the recipe's observed field, and the echo field when present) and -`auths.gateway-outcome/2` (the stored record of one logical operation: its -commitment, stage, evaluation time, recipe digest, and, as recorded, the -counter-set digest, refusal, response status and digest, read-back -comparison, evidence digest, pre-entry digest, and relative-ceiling basis). A grant's observation requirement can then require, for example, +`auths.gateway-outcome/3` (hiding effect/recipe/record references, conservative +stage, evaluation time and bounded status/refusal). Protected full outcome facts +and pre-entry bytes remain operator-only. A grant's observation requirement can then require, for example, that the record held the action's `expected` value, or that step N−1 is `observed-by-provider`, before the verifier authorizes step N. The gateway verifies at its own clock and exposes top-level verified MCP arguments as @@ -295,13 +294,13 @@ multiplying either, all-or-none reservation, fixed-context tightening, and decider soundness, with the chain leaves translated and refined. No hosted CI result is cited here. -### Outcome and audit `/2` with the provider result (AP-SPEC-063 §8, repository-local only) +### Public outcome `/3` and private audit with the provider result (AP-SPEC-063 §8, repository-local only) **Claim.** For every claimed submission the gateway records the stage, the gateway evaluation time, the refusal code when it refused, and the HTTP status and response digest when a complete response exists. When an observer key is provisioned, it signs that record on request as -`auths.gateway-outcome/2`, with the counter-set digest, the pre-entry +operator-private `auths.gateway-private-outcome/1`, with the counter-set digest, the pre-entry digest, and the relative-ceiling basis when recorded; the gateway refuses to sign, and the auditor refuses to accept, any fact set its stage could not carry. The offline audit (`auths.gateway-audit-report/3`) re-verifies each @@ -328,7 +327,8 @@ proof whose outcome was removed. Until AP-SPEC-038 Epic 4 supplies a custody client, a production gateway signs no outcomes, so every entry audits as `unverified` and the audit fails. -Current evidence is `bindings/fixtures/gateway/outcome-v2.json`: Rust +Public evidence is `bindings/fixtures/gateway/outcome-v3.json`; native private +full-fact cases remain in `private-outcome-v1.json`. Rust verifies every accepted vector with its exact facts and refuses every refused one, and Rust, the Python SDK (native), and the TypeScript SDK (WASM) reach the same verdict on every case of a grant requiring diff --git a/docs/research/domains/abstraction-cases/0007-declarative-credential-isolated-request.md b/docs/research/domains/abstraction-cases/0007-declarative-credential-isolated-request.md index 0ded36cba..48fed3f36 100644 --- a/docs/research/domains/abstraction-cases/0007-declarative-credential-isolated-request.md +++ b/docs/research/domains/abstraction-cases/0007-declarative-credential-isolated-request.md @@ -180,7 +180,7 @@ identical subset is extracted; the rest stays with the recipe author or the vertical. "Vertical" means `product/integrations/auths-stripe` unless a row names another consumer. The vectors for every capability are in `bindings/fixtures/gateway/` (`hostile-recipes-v2.json`, -`attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v2.json`, +`attempt-scenarios-v3.json`, `bounds-aggregate.json`, `outcome-v3.json`, `key-identity.json`, `codes.json`), and tests in `product/runtime/auths-gateway/src/pending_vectors/` show that current code does not satisfy them. diff --git a/docs/specs/0060-evidence-conditioned-authority.md b/docs/specs/0060-evidence-conditioned-authority.md index 67213535a..c8610a413 100644 --- a/docs/specs/0060-evidence-conditioned-authority.md +++ b/docs/specs/0060-evidence-conditioned-authority.md @@ -79,7 +79,7 @@ and a new manifest, or a product-layer evaluator under 0025. ObservationStatement = { version: 1, observer: PrincipalId, ; signer - schema: ObservationSchemaId, ; e.g. "auths.gateway-outcome/2" + schema: ObservationSchemaId, ; e.g. "auths.gateway-outcome/3" subject: ResourceId, ; what was observed observed_at: Timestamp, facts: { 1*16 FactName => FactValue }, @@ -242,7 +242,7 @@ current value equals the action's `expected` value, observed within the last ```text requirement: observer_anchor: gateway-observer - schema: auths.gateway-outcome/2 + schema: auths.gateway-outcome/3 subject: action_fact("depends_on") ; step N-1's commitment URI max_age_seconds: 3600 conditions: [ member("stage", ["observed-by-provider"]) ] diff --git a/docs/specs/0063-generalized-gateway.md b/docs/specs/0063-generalized-gateway.md index da6442da5..6f9e94c1f 100644 --- a/docs/specs/0063-generalized-gateway.md +++ b/docs/specs/0063-generalized-gateway.md @@ -96,7 +96,7 @@ All five share one recipe revision (§3) and one store contract (§9). - For every claimed submission it records the stage, the gateway evaluation time, the refusal code when it refused, and the HTTP status and response digest when a complete response exists. When an observer key is - provisioned, it signs that record on request as `auths.gateway-outcome/2`. + provisioned, it signs a redacted public projection as `auths.gateway-outcome/3`; complete audit facts are operator-private `auths.gateway-private-outcome/1`. A production gateway has no observer key until AP-SPEC-038 Epic 4 supplies a custody client (§16). - Within one namespace and one store, a bounded grant's count bounds every @@ -1339,13 +1339,16 @@ custody unavailability can never block the kill switch. ## 8. Evidence and assurance -### 8.1 `auths.gateway-outcome/2` +### 8.1 Public outcome `/3` and private outcome `/1` -The outcome keeps its subject -(`auths-gateway:///operations/`) and observer. Its -fact set changes meaning, so the schema becomes `/2` and `/1` is removed -(§13, reading 1). The kernel treats schema identifiers and fact names as -opaque, so the core CDDL, codec, registry, and corpus stay (060 §3.1). +AP074 directly replaces the public `/2` fact set with +`auths.gateway-outcome/3`. Public facts are hiding effect/recipe/record references, +conservative stage, evaluation time and bounded status/refusal. Full facts below +are signed only as operator-private `auths.gateway-private-outcome/1`; the +application cannot request that schema or receive protected pre-entry bytes. +The existing kernel presence predicate and offline audit checks remain unchanged. + +The private subject is `auths-gateway:///operations/`. | Fact | Type | Present when | | --- | --- | --- | @@ -1371,38 +1374,25 @@ apart. At most 13 of an observation's 16 facts are used. a later window no longer moves its entry into that window. A chained step's `member("stage", ["observed-by-provider"])` (060 §5) works unchanged. -**Consumers**, all changed in one cutover: - -- in the gateway: `observer.rs` (`OUTCOME_SCHEMA`, `outcome_facts`, - `verify_outcome`, `ObserverAnchorTemplate`), `engine.rs`, `audit.rs`, - `harness.rs`, and `observed_tests.rs`; -- the custody test in `product/integrations/auths-custody/src/lib.rs`; -- the Python and TypeScript gateway clients, their tests, and their public-API - inventories; -- the north-star example and every trusted context's observer anchors; -- `compliance.toml`, 060, the claim ledger, and the runbook. - -**Fixtures.** `bindings/fixtures/gateway/outcome-v2.json` holds, for each stage -and fact combination, the canonical outcome signed by a fixed test observer -and its expected facts. Rust verifies every entry. The Python (native) and -TypeScript (WASM) SDKs accept every entry and, through local verification, -reach the gateway's verdict on a grant requiring `member("stage", -["observed-by-provider"])`. Go consumes no gateway schema, so no Go vector is -added. - -### 8.2 Observe request `/2` - -`auths.gateway-observe/2` keeps `read-back`, which is refused for a path with -a `response-field` segment, and `outcome`. It adds `pre-entry -{operation_id}`, which returns one operation's stored signed pre-entry -observations as `{"outcome": "pre-entry", "operation_id", "observations_b64": -[...]}`. It signs nothing new and contacts no provider. The clients add -`observe_pre_entry` and `observePreEntry`. - -### 8.3 Audit bundle and report `/2` - -`auths.gateway-audit-bundle/2` entries add an optional `pre_entry_b64`. -`auths.gateway-audit-report/2` adds the recipe's `recovery` object to its +Public conformance vectors are `bindings/fixtures/gateway/outcome-v3.json`; +full private fact/presence vectors are `private-outcome-v1.json`. Native, Python +and TypeScript consume the public corpus. The native private corpus preserves +all accepted and refused full-fact cases. Superseded public schemas are rejected. + +### 8.2 Observe request `/4` + +`auths.gateway-observe/4` permits local outcome and pre-entry history only. +Pre-entry returns operation ID, count and hiding record commitment. It performs +no provider I/O and returns no protected observation bytes. Independently +approved recovery uses `auths.gateway-recover/1`. Operator-only `audit-export` +collects private signed outcomes and protected pre-entry bytes from one native +snapshot, and completes private audit bundles in new owner-private files. +See AP074 for the exact hiding, framing, deadline and non-bypassability contract. + +### 8.3 Private audit bundle `/3` and report `/3` + +`auths.gateway-audit-bundle/3` entries add an optional `pre_entry_b64`. +`auths.gateway-audit-report/3` adds the recipe's `recovery` object to its header and a `provider_result` to each entry: ```json @@ -1521,7 +1511,7 @@ entry, with its test evidence, in the change that introduces it: | Recipe | `auths.gateway-recipe-source/2`, `auths.gateway-compiled-recipe/2`, `auths.gateway-recipe-review/2`, `auths.gateway-recovery-capability/1` | | Store | `auths.gateway-attempt/3`, `auths.gateway-bounded-count/2`, `auths.gateway-bounded-sum/1`, `auths.gateway-connection/1`, `auths.lifecycle.postgresql/6` | | Policy | `auths.gateway.argument-ceiling-window-count/2`, `auths.gateway.argument-ceiling-policy/2`, `auths.gateway-counter-set/1` | -| Evidence | `auths.gateway-pre-entry/1`, `auths.gateway-outcome/2`, `auths.gateway-observe/2`, `auths.gateway-audit-bundle/2`, `auths.gateway-audit-report/2`, `auths.gateway-echo-verification/1`, `auths.gateway-codes/1` | +| Evidence | `auths.gateway-pre-entry/1`, `auths.gateway-outcome/2`, `auths.gateway-observe/2`, `auths.gateway-audit-bundle/3`, `auths.gateway-audit-report/3`, `auths.gateway-echo-verification/1`, `auths.gateway-codes/1` | | Operator | `auths.gateway-operator-attestation/1`, `auths.gateway-installation/3`, `auths.gateway-admin-request/1`, `auths.gateway-admin-response/1` | ## 9. Store contract @@ -1876,7 +1866,7 @@ decision (option A, 2026-09-27) and is not listed. | 32 | An admin state change that loses a compare-and-swap to another process | (a) reload and reapply up to 8 rounds, then `gateway.admin.generation-conflict`; (b) fail at once | (a): a kill switch should not fail on an unrelated concurrent change; the bound keeps it within the admin deadline | | 33 | The pool `serve`'s descriptor check counts | (a) the `PostgreSQL` pool's maximum connections, and zero for the file store; (b) a fixed number | (a) | | 34 | Where §8.1's presence rule lives | (a) a leaf of the translated kernel (`outcome_facts_present`), checked exhaustively by Kani, with no refinement theorem; (b) a Lean model and theorem as well | (a): the rule decides what a signed record may say, not whether a credential is leased or a write is sent, so §11 does not require a theorem; the leaf sits in the kernel crate, outside the translated slice, so adding it to the slice and a theorem later needs no move | -| 35 | How the SDKs "reach the gateway's verdict" on `outcome-v2.json` | (a) the fixture adds verdict cases: each accepted vector's exact bytes attached to an action whose grant requires `member("stage", ["observed-by-provider"])` of it, under a context compiled as the SDKs compile it and pinned to the packaged configuration, with the native decision and code; (b) the SDKs re-derive the facts themselves | (a): the SDKs verify through their own native and WASM verifiers, and no SDK gains a second reading of the facts | +| 35 | How the SDKs "reach the gateway's verdict" on `outcome-v3.json` | (a) the fixture adds verdict cases: each accepted vector's exact bytes attached to an action whose grant requires `member("stage", ["observed-by-provider"])` of it, under a context compiled as the SDKs compile it and pinned to the packaged configuration, with the native decision and code; (b) the SDKs re-derive the facts themselves | (a): the SDKs verify through their own native and WASM verifiers, and no SDK gains a second reading of the facts | | 36 | What an audit bundle entry's `pre_entry_b64` holds | (a) an array of at most four unpadded base64url observations, in pointer order, as observe `/2`'s `pre-entry` answer returns them; (b) one concatenated blob | (a) | | 37 | An entry's `provider_result` when no verified outcome exists | (a) `null`; (b) an object of nulls | (a): nothing signed stands behind it | | 38 | The clock at which the audit evaluates pre-entry requirements | (a) the latest pre-entry `observed_at`, each already required to lie in `[evaluated-at, evaluated-at + 60]`; (b) `evaluated-at` | (a): the gateway evaluated after its read, so (b) could refuse an observation the gateway saw as fresh | @@ -1936,12 +1926,12 @@ on the exact revision, or a commit whose diff holds the evidence. | Epic | Work | Done | | --- | --- | --- | -| 1. Case file and fixtures | ADR 0013 and the case 0007 comparisons (§2), for all ten recipe capabilities and the sum budget; hostile recipe cases for every new construct, including basis points 0 and 10 001, a `POST` or `field`-segment denied read, a refused status of 429, five denied reads, `Stripe-Account` in `provider_headers`, an unregistered account-scope header, and an unbound partition; attempt scenarios `/3`, including `pre-entry-replaced-after-observation`, `relative-ceiling-above`, `relative-ceiling-exact-boundary`, `relative-basis-unavailable`, `relative-binding-mismatch`, `account-substituted-at-lease`, `denied-read-answered`, `account-scope-outside-grant`, `account-scope-unbound`, and `account-scope-only-on-action-requests`; §6.8's count and sum cases in `bounds-aggregate.json`; `outcome-v2.json`, `key-identity.json`, and `codes.json` | The vectors exist and fail against current code; the ADR and case file are reviewed | +| 1. Case file and fixtures | ADR 0013 and the case 0007 comparisons (§2), for all ten recipe capabilities and the sum budget; hostile recipe cases for every new construct, including basis points 0 and 10 001, a `POST` or `field`-segment denied read, a refused status of 429, five denied reads, `Stripe-Account` in `provider_headers`, an unregistered account-scope header, and an unbound partition; attempt scenarios `/3`, including `pre-entry-replaced-after-observation`, `relative-ceiling-above`, `relative-ceiling-exact-boundary`, `relative-basis-unavailable`, `relative-binding-mismatch`, `account-substituted-at-lease`, `denied-read-answered`, `account-scope-outside-grant`, `account-scope-unbound`, and `account-scope-only-on-action-requests`; §6.8's count and sum cases in `bounds-aggregate.json`; `outcome-v3.json`, `key-identity.json`, and `codes.json` | The vectors exist and fail against current code; the ADR and case file are reviewed | | 2. Recipe `/2` | The compiler, including §3.2's rows for the credential account and denied reads, `account_scope`, `bounds`, and `relative_ceiling`, and §5.1's registry classes; `recovery_capability`, and review `/2` in both CLIs; account-scope headers in request construction; derivation emits `/2`; the fixtures, north-star recipe, and derivation corpus are regenerated | Every fixture compiles to its documented class; every hostile case fails with its code; both packaged CLIs pass the corpus; §11.3's capability theorems and §11.5, including `account_scope_header_exact` and `credential_reads_fixed`, are proved and registered, with `cargo xtask formal` green | | 3. Store and engine | §9 (kinds, `insert_all`, sweep, the file batch, schema 5, record `/3`); the §5.5 steps marked 3, including the account read and denied reads at onboarding and every lease (§5.7, §5.8) and the relative ceiling (§5.6, `ratio.rs`); re-observation of `attempting` | Conformance passes on both stores (PostgreSQL in its workflow); the scenario corpus drives the counting provider; every hostile suite has zero unauthorized entries, and every pre-claim refusal zero leases; each relative-ceiling, account, and denied-read scenario records `not-entered` with its code, one lease, and zero writes; §11.2, §11.3's transition theorems, and §11.6 are proved and registered, with `cargo xtask formal` green | | 4. One spend limit | Formal first (the Lean model, theorems, and the three translated leaves, with `cargo xtask formal` green); then evaluator `/2` with policy `/2` (§6.10), the account-scope binding (§5.9), the count and sum slots of §5.5 step 6, §6.5's sweep, §6.7, and every §6.4 description | `bounds-aggregate.json` passes on both stores, including both races; no count or sum slot leaks; the audit flags the capacity-3 and capacity-1 bundle and the sum bundle and passes every valid one; `account-scope-outside-grant` and `account-scope-unbound` refuse with zero leases | | 5. Operator plane | §7, including connection record `/2` (§7.3), and the §5.5 steps marked 5 | With the application at full capacity, every admin command answers within its deadline; a disable or revoke through process A stops new entries in process B at B's next reload, on PostgreSQL; a second host joins only with the matching secret, including after a disable and enable, and a cross-process `rotate` followed by a disable and enable still leases on every host; `did:key` and `raw-key-v1` aliasing is refused at install and per proof; an invalid attestation is refused; §11.4 is proved and registered, with `cargo xtask formal` green | -| 6. Evidence and assurance | Step 1, repairing the scheduled Fuzz job (`.github/workflows/fuzz.yml`) so a scheduled campaign can pass, with a unit test on a captured libFuzzer log, merged in #168; scheduled runs pass from 2026-09-27. Then §8: outcome `/2` and its consumers (including `relative-basis`), observe `/2`, audit `/2` (including the relative-ceiling and sum checks), `echo-verify`, the SDK projections, the fuzz crate, property tests, Kani harnesses, and the code inventory | A scheduled Fuzz run is green with the gateway targets; Rust, Python, and TypeScript agree on `outcome-v2.json`; the north-star audit shows `http_status` for every entered refund, including a rejected one, and flags a bundle whose basis does not admit its argument | +| 6. Evidence and assurance | Step 1, repairing the scheduled Fuzz job (`.github/workflows/fuzz.yml`) so a scheduled campaign can pass, with a unit test on a captured libFuzzer log, merged in #168; scheduled runs pass from 2026-09-27. Then §8: outcome `/2` and its consumers (including `relative-basis`), observe `/2`, audit `/2` (including the relative-ceiling and sum checks), `echo-verify`, the SDK projections, the fuzz crate, property tests, Kani harnesses, and the code inventory | A scheduled Fuzz run is green with the gateway targets; Rust, Python, and TypeScript agree on `outcome-v3.json`; the north-star audit shows `http_status` for every entered refund, including a rejected one, and flags a bundle whose basis does not admit its argument | | 7. North-star recipe | The Stripe recipe moves to §3.1, declaring all five Stripe checks, with an approval window of at most 86 340 seconds; its grants carry policy `/2` with a sum limit partitioned by currency and a scope listing the test connected account; the counting double returns refunds with metadata, serves PaymentIntents, the account, and 403 refusals, requires `Stripe-Version`, honors `Stripe-Account`, and honors the key; `journey.py` checks `observed-by-provider`, the guard refusing a non-test key, and one hostile case per check: a refund above the ratio of `/amount_received`, a currency that does not match the PaymentIntent, the double reporting another account at the lease, the double answering a denied read with 200, a `connect_account` outside the grant, and a refund that exceeds the currency's remaining sum; the README non-claims and the claim ledger are updated; the test-mode command stays the developer's own step (board §0 step 4) | `stripe-refund-journey` is green from the packed wheel, and each hostile case records its code with zero writes; the ledger entry uses §1's claim and non-claim wording | | 8. Consolidation | §12 A's removals and rewrites in one pull request | The profiles and routes are gone; the specs, ADRs, and plan are amended, and `AGENTS.md`'s summary of the boundary plan is checked against the rewrite; the board is updated; CI is green | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 30fe444e2..d44f4427e 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -139,7 +139,7 @@ available to the agent may bypass these gates or substitute caller-controlled transport bytes. An operator commissioning path must satisfy the same effect binding, approval and entry protocol in addition to its commissioning authority. -The application protocol `auths.gateway-observe/3` accepts only local outcome +The application protocol `auths.gateway-observe/4` accepts only local outcome and pre-entry history queries. Obsolete observation schemas and the unapproved `read-back` request are rejected. `auths.gateway-recover/1` supplies a source operation and the bounded `auths.gateway-submit/2` proof/action/approval envelope @@ -902,6 +902,53 @@ Private constructors enforce the local boundary. Entry permits are neither clone Remote permits and multi-executor dispatch are outside this milestone. Do not imply that a Rust type alone prevents a malicious process from bypassing a deployment boundary. +### Signed public history and operator-private audit + +Application outcome queries sign `auths.gateway-outcome/3`. Its closed facts are +`effect-reference`, `recipe-reference`, `record-commitment`, `stage` and +`evaluated-at`, with bounded `http-status` or `refusal` when applicable. Each +reference is lowercase HMAC-SHA256 under the record's existing private immutable +128-bit nonce, the full exact canonical binding and a distinct closed label +(`action`, `recipe` or `journal-record`) under +`auths.gateway-public-commitment/1`. The journal-record seal covers the complete +canonical record including entry/fence/authority/accounting metadata, with the +nonce zeroized in the sealed message. Raw action, recipe, response, evidence, +counter, basis and pre-entry digests or values MUST NOT appear in public history. +A recipe can contain fixed private values, so its public reference is hiding too. + +Public pre-entry history returns only the operation ID, observation count (0–4) +and a hiding record commitment. Protected observation bytes are operator-only. +The app protocol is `/4`; old public outcome and observe formats are rejected. +The signature authenticates the gateway's historical statement; no public +reference, observation or receipt recreates an execution capability. + +An authenticated operator requests `audit-export` on the existing peer-UID-gated +operator socket. One loaded native journal snapshot produces +`auths.gateway-private-audit/1`: operation ID, signed +`auths.gateway-private-outcome/1` and protected pre-entry observation bytes. The +private signed fact set retains the original complete outcome presence predicate +and every existing audit commitment, counter, basis and pre-entry check. It is +not an app route and is not an alternative admission or journal owner. + +Native CLI `audit-export --operation-id ... --out ...` saves one protected export; +`--bundle ... --out ...` completes a current submission inventory using those +same native operator exports. The modes are mutually exclusive. The CLI prints +only success metadata and writes a new 0600 file in an owner-private directory; +it never overwrites a file. Bundle assembly grants no audit verdict. Absent +records remain unverified; failures do not manufacture non-entry, refund or retry. +The offline auditor accepts only the private schema in audit bundle `/3`, under +independently pinned trust and observer identity, preserving its existing checks. +Detailed private bundles/reports MUST NOT return to an app, UI or public artifact. + +The existing limits remain: 4,096 observations bytes each, four protected pre-entry +observations per entry, 4,096 audit entries, 65,536 approval responses and 64 MiB +aggregate audit bytes. Bounded sequence decoders reject excess items before +allocating their payloads. Public times fit JavaScript's exact integer range; +all affected bindings reject duplicate members, noninteger spellings, BOM, +noncanonical base64 and malformed/obsolete schemas. One CLI bundle export is +bounded by the existing 60-second operator session deadline and grants no I/O +capability or provider traffic. + ### 4.5 Canonicalization and privacy Reuse repository canonical codecs and domain-separated commitments. Freeze the selected schema, ordering, optional/absent distinction, integer range, duplicate handling and semantic identities in native fixtures before cutting over callers. No Python/TypeScript hash implementation may become an alternate authority. diff --git a/examples/stripe-refund-approval/README.md b/examples/stripe-refund-approval/README.md index 40a40727e..842d2399c 100644 --- a/examples/stripe-refund-approval/README.md +++ b/examples/stripe-refund-approval/README.md @@ -282,6 +282,9 @@ its own grant (`python refunds.py grant --agent agent-checks --max-count 4`): ```sh python refunds.py export --state "$WORK/state" --out audit-bundle.json +# Trusted operator shell; gateway must still be running. $WORK is owner-private. +auths-gateway audit-export --state-dir "$WORK/gateway" \ + --bundle audit-bundle.json --out "$WORK/private-audit-bundle.json" ``` It holds one entry per operation ID: the first submission, or a later one @@ -300,10 +303,16 @@ lowered-threshold refund's entry is the signed one of its later retry. The bundl response the agent collected (declines included), and the installed recipe and trusted context. +The application export contains redacted public outcomes. The operator command +replaces these with the complete private signed audit facts and protected +pre-entry observations from native retained history. The private bundle is a +new 0600 file in a private directory. Do not return it or its detailed audit +report to the application or publish it as public evidence. + **9. Audit offline.** With the gateway stopped and the network off: ```sh -auths-gateway audit --bundle audit-bundle.json \ +auths-gateway audit --bundle "$WORK/private-audit-bundle.json" \ --trusted-context-sha256 --observer \ --allow-unverified-refusals ``` diff --git a/examples/stripe-refund-approval/journey.py b/examples/stripe-refund-approval/journey.py index 3becefa36..6eff01cc9 100644 --- a/examples/stripe-refund-approval/journey.py +++ b/examples/stripe-refund-approval/journey.py @@ -1302,6 +1302,10 @@ def lose_attempts_and_resubmit() -> Dict[str, Any]: str(bundle_path), ), ) + private_bundle = journey.work / "private-audit-bundle.json" + journey.run(journey.gateway, "audit-export", "--state-dir", str(journey.gateway_state), + "--bundle", str(bundle_path), "--out", str(private_bundle)) + bundle_path = private_bundle journey.stop() # README step 9: the offline audit, with the gateway stopped. The diff --git a/examples/stripe-refund-approval/refunds.py b/examples/stripe-refund-approval/refunds.py index 6765adacc..c212f37ac 100644 --- a/examples/stripe-refund-approval/refunds.py +++ b/examples/stripe-refund-approval/refunds.py @@ -651,7 +651,7 @@ def export(args: argparse.Namespace) -> None: json.loads(line) for line in approvals.read_text().splitlines() if line ] if approvals.exists() else [] bundle = { - "schema": "auths.gateway-audit-bundle/2", + "schema": "auths.gateway-audit-bundle/3", "recipe_b64": _b64(RECIPE.read_bytes()), "profile_lock_b64": _b64(PROFILE_LOCK.read_bytes()), "trusted_context_b64": _b64((state / "trust" / "gateway.context.cbor").read_bytes()), diff --git a/examples/stripe-refund-approval/typescript/journey.ts b/examples/stripe-refund-approval/typescript/journey.ts index a5685b7cd..1aff0bd59 100644 --- a/examples/stripe-refund-approval/typescript/journey.ts +++ b/examples/stripe-refund-approval/typescript/journey.ts @@ -977,10 +977,14 @@ async function main(): Promise { } // README step 8: the audit bundle. - const bundlePath = join(journey.work, "audit-bundle.json"); + let bundlePath = join(journey.work, "audit-bundle.json"); await journey.step("export audit bundle", () => journey.run(process.execPath, [ REFUNDS, "export", "--state", journey.state, "--out", bundlePath, ])); + const privateBundle = join(journey.work, "private-audit-bundle.json"); + journey.run(journey.gateway, ["audit-export", "--state-dir", journey.gatewayState, + "--bundle", bundlePath, "--out", privateBundle]); + bundlePath = privateBundle; const providerRequests = journey.providerEntries(); await journey.stop(); diff --git a/examples/stripe-refund-approval/typescript/refunds.ts b/examples/stripe-refund-approval/typescript/refunds.ts index 7327b0ed9..9f119db33 100644 --- a/examples/stripe-refund-approval/typescript/refunds.ts +++ b/examples/stripe-refund-approval/typescript/refunds.ts @@ -715,7 +715,7 @@ function exportBundle(options: Readonly<{ state: string; out: string }>): void { .map((line) => JSON.parse(line) as unknown) : []; const bundle = { - schema: "auths.gateway-audit-bundle/2", + schema: "auths.gateway-audit-bundle/3", recipe_b64: b64(new Uint8Array(readFileSync(RECIPE))), profile_lock_b64: b64(new Uint8Array(readFileSync(PROFILE_LOCK))), trusted_context_b64: b64(new Uint8Array(readFileSync(join(options.state, "trust", "gateway.context.cbor")))), diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index f8ef9159e..d97aa152e 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "a002dc42725b1e3e5234f8ba11eea3f8ba8141e2e64f052d950182d4f93a2825", + "digest": "5c243bbe3196b6f20772b2d90b397ae43d7545312f1fe07a3b05be795fa471e9", "files": [ { "path": ".cargo/config.toml", @@ -341,7 +341,7 @@ }, { "path": "xtask/src/fuzz.rs", - "sha256": "8de85876a08cb6afa5ea094a0386ae4a9c4916a22fcc7a8909fa87700d61c32f" + "sha256": "25f87f093f4efb89d7818d8dea9d29bb79c55b7dcb80156db5b8b700863e62f8" }, { "path": "xtask/src/kani_harness.rs", diff --git a/product/integrations/auths-custody/src/lib.rs b/product/integrations/auths-custody/src/lib.rs index e304c92ac..337fb7447 100644 --- a/product/integrations/auths-custody/src/lib.rs +++ b/product/integrations/auths-custody/src/lib.rs @@ -858,7 +858,7 @@ mod tests { fn observation(principal: &PrincipalId) -> auths_model::ObservationStatement { auths_model::ObservationStatement::new( principal.clone(), - auths_model::ObservationSchemaId::parse("auths.gateway-outcome/2").unwrap(), + auths_model::ObservationSchemaId::parse("auths.gateway-outcome/3").unwrap(), ResourceId::parse("auths-gateway://ns/operations/op-1").unwrap(), auths_model::Timestamp::new(1), auths_model::ObservationFacts::new(vec![auths_model::ObservationFact::new( diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back index ff67e7a27..1bac3a815 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-read-back @@ -1 +1 @@ -{"schema":"auths.gateway-observe/3","request":{"kind":"read-back","arguments":{"record_id":"recTEST0000000001"}}} \ No newline at end of file +{"schema":"auths.gateway-observe/4","request":{"kind":"read-back","arguments":{"record_id":"recTEST0000000001"}}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 9b21b6968..a08c92b3e 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"2419f81414d005e89e9f917abdd3ecd4f9dd5397ec665139b29d0ba0b0b3bf7b"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"01fc8198e982d0f7e995864bb70880fb14d09750882fdcfdb538899e80d401dd"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"c2b043471d425aff45375540e631d136b81bc18784f4224ca968b63e1d359b81"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"e1b9b99e18f7b4b4f1e1cc88f560d6acd7884caea07ce9bf448d2713702b7191"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"ba1a12ceae08704eb4184955ff39ba2adc088183354e1635ce3f495d8dd9416f"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a80859b9a0834c51ce5ab690aef24b9c7b2f7ee463d5e9635ddf555489ce88c8"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"13a513f42f468f9ff9e1818df4d2656a043e01fa83ef28e7eaf892212e349993"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"edcbce5f8f83db0ef8e68905aa19f845a7bd8a11665715963c29b16082355ae9"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"82ce208eb11f6195047c4ba05448816b877dab8a791ee1b8142ca68f830fb0bf"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"ed3b0028487eb546a3b0a91d115aa8f18bcea324b61620bfe8e35a9e6ab18758"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"92056fb13bc2ff9096defc0a94306ff8b7b275f8eee4cb4b1feca0d90dda6fa9"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"c6ce27caee4e24091cd7c8c699ef3ccb1b1b050ed9cf9a0d4a2a611d6c3c38eb"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"7338c1a0e661a179ba84dc2cd50d3e62e0c2fba109ee59fb0036074360d157c8"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"d23e48ee558709caad9bbab30a051720f05369560af6e492b9510fd4fd22bcd5"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"8ec07b9511b48913af36ac999d2aa0e82924289f6acb23ddaeb9f00f99815166"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"5e1621627dfd9cd2bc09fff08734afbec06aa90b1a152932417127b19fc275ff"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"d97104cd48baed2de13fe5992526db77acd1c54e010d2fd1142f0226e7467fa2"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8887edd3f6eddcd549e2d41ea06072ef30cc34d535f3f4e40fe146682c15f1ce"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"567ecc2aac4de572b9f14eeb240a255cd6432e9bc263bb8fd3ac1e0bec7a5e76"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/admin.rs b/product/runtime/auths-gateway/src/admin.rs index 753bf2673..4c3887c12 100644 --- a/product/runtime/auths-gateway/src/admin.rs +++ b/product/runtime/auths-gateway/src/admin.rs @@ -62,6 +62,11 @@ admin_commands! { /// Read the qualification inputs the operator placed on this host again /// and report the resulting state. QualificationReload("qualification-reload") {}, + /// Export protected audit evidence to an authenticated operator. + AuditExport("audit-export") { + /// Logical operation whose protected evidence to export. + operation_id: String, + }, /// Acquire/refine one recovery read; a native submission follows in frame 2. Recover("recover") { /// Retained source mutation whose contract the read must bind. diff --git a/product/runtime/auths-gateway/src/admin_boundary_tests.rs b/product/runtime/auths-gateway/src/admin_boundary_tests.rs index 25a8c585f..b8953d0bd 100644 --- a/product/runtime/auths-gateway/src/admin_boundary_tests.rs +++ b/product/runtime/auths-gateway/src/admin_boundary_tests.rs @@ -15,6 +15,7 @@ fn request(command: &str) -> Value { | "execution-witness" | "qualification-reload" => {} "rotate-commit" => value["commitment"] = json!("00".repeat(32)), + "audit-export" => value["operation_id"] = json!("original"), "recover" => value["source_operation"] = json!("original"), "recovery-record" => { value["source_operation"] = json!("original"); diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 8c82605ea..7e9961a3e 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -28,7 +28,7 @@ pub use content::{AppDisclosureReception, receive_content_disclosure}; /// Schema of a proof/action submission frame. pub const APP_REQUEST_SCHEMA: &str = "auths.gateway-submit/2"; /// Schema of an observation request frame. -pub const APP_OBSERVE_SCHEMA: &str = "auths.gateway-observe/3"; +pub const APP_OBSERVE_SCHEMA: &str = "auths.gateway-observe/4"; /// Independently approved recovery acquisition and evidence refinement. pub const APP_RECOVERY_SCHEMA: &str = "auths.gateway-recover/1"; /// Largest frame either side accepts. diff --git a/product/runtime/auths-gateway/src/audit.rs b/product/runtime/auths-gateway/src/audit.rs index b36758027..0b7027ba7 100644 --- a/product/runtime/auths-gateway/src/audit.rs +++ b/product/runtime/auths-gateway/src/audit.rs @@ -77,7 +77,7 @@ use sha2::{Digest as _, Sha256}; use std::collections::{BTreeMap, BTreeSet}; /// Schema of an audit bundle. -pub const AUDIT_BUNDLE_SCHEMA: &str = "auths.gateway-audit-bundle/2"; +pub const AUDIT_BUNDLE_SCHEMA: &str = "auths.gateway-audit-bundle/3"; /// Schema of an audit report. pub const AUDIT_REPORT_SCHEMA: &str = "auths.gateway-audit-report/3"; /// Largest audit bundle, in bytes. @@ -267,26 +267,27 @@ impl AuditReport { } } -#[derive(Deserialize)] +#[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct BundleSource { schema: String, recipe_b64: String, profile_lock_b64: String, trusted_context_b64: String, + #[serde(deserialize_with = "export::entries")] entries: Vec, - #[serde(default)] + #[serde(default, deserialize_with = "export::responses")] approval_responses: Vec, } -#[derive(Deserialize)] +#[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct ResponseSource { operation_id: String, response: String, } -#[derive(Deserialize)] +#[derive(Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct EntrySource { operation_id: String, @@ -298,6 +299,25 @@ struct EntrySource { pre_entry_b64: Option>, } +#[path = "audit_export.rs"] +mod export; +pub use export::PrivateAuditBundle; + +fn bundle_source(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_AUDIT_BUNDLE_BYTES { + return Err("audit.bundle-invalid-size"); + } + let source: BundleSource = + serde_json::from_slice(bytes).map_err(|_| "audit.bundle-malformed")?; + if source.schema != AUDIT_BUNDLE_SCHEMA + || source.entries.len() > MAX_AUDIT_ENTRIES + || source.approval_responses.len() > MAX_AUDIT_APPROVAL_RESPONSES + { + return Err("audit.bundle-malformed"); + } + Ok(source) +} + fn decode(text: &str, maximum: usize) -> Option> { if text.len() > maximum.div_ceil(3) * 4 { return None; @@ -391,17 +411,7 @@ fn finding(operation_id: &str, code: &str, evaluated_at: u64) -> Pending { /// recipe that does not compile. Per-entry problems are reported in the /// returned report, never as an error. pub fn audit_bundle(bytes: &[u8], pins: &AuditPins) -> Result { - if bytes.is_empty() || bytes.len() > MAX_AUDIT_BUNDLE_BYTES { - return Err("audit.bundle-invalid-size"); - } - let source: BundleSource = - serde_json::from_slice(bytes).map_err(|_| "audit.bundle-malformed")?; - if source.schema != AUDIT_BUNDLE_SCHEMA - || source.entries.len() > MAX_AUDIT_ENTRIES - || source.approval_responses.len() > MAX_AUDIT_APPROVAL_RESPONSES - { - return Err("audit.bundle-malformed"); - } + let source = bundle_source(bytes)?; let approval_responses = source .approval_responses .iter() diff --git a/product/runtime/auths-gateway/src/audit_export.rs b/product/runtime/auths-gateway/src/audit_export.rs new file mode 100644 index 000000000..9c5f217fd --- /dev/null +++ b/product/runtime/auths-gateway/src/audit_export.rs @@ -0,0 +1,217 @@ +//! Bounded data assembly for operator-private audit exports. No admission or I/O. +use super::{ + BundleSource, MAX_AUDIT_BUNDLE_BYTES, MAX_AUDIT_PRE_ENTRY_OBSERVATIONS, bundle_source, decode, +}; +use base64ct::{Base64UrlUnpadded, Encoding as _}; +use serde::Deserialize; +use std::collections::BTreeMap; +use zeroize::{Zeroize as _, Zeroizing}; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct PrivateEvidence { + schema: String, + operation_id: String, + outcome_b64: String, + #[serde(deserialize_with = "observations")] + pre_entry_b64: Vec, +} + +/// Operator-only assembly of a public submission bundle and protected native +/// evidence. This does not verify authority or manufacture an outcome: the +/// resulting bundle still requires the independent offline auditor and pins. +/// Its contents must remain in operator-private storage. +pub struct PrivateAuditBundle { + source: BundleSource, + entries: BTreeMap, + encoded_bound: usize, +} + +impl std::fmt::Debug for PrivateAuditBundle { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter + .debug_struct("PrivateAuditBundle") + .field("entries", &self.entries.len()) + .finish_non_exhaustive() + } +} + +impl PrivateAuditBundle { + /// Decode the current bounded bundle schema. Discard every supplied outcome + /// and pre-entry value before collecting fresh operator-private evidence. + /// + /// # Errors + /// Refuses malformed/obsolete/oversized bundles, duplicate operation IDs, + /// invalid IDs or noncanonical/oversized proof and action encodings. + pub fn new(bytes: &[u8]) -> Result { + let mut source = bundle_source(bytes)?; + let mut entries = BTreeMap::new(); + for (index, entry) in source.entries.iter_mut().enumerate() { + crate::LogicalOperationId::parse(&entry.operation_id) + .map_err(|_| "audit.entry-malformed")?; + if entries.insert(entry.operation_id.clone(), index).is_some() + || !canonical_base64(&entry.proof_b64, super::MAX_PROOF_BYTES) + || !canonical_base64(&entry.action_b64, super::MAX_ACTION_BYTES) + { + return Err("audit.entry-malformed"); + } + entry.outcome_b64 = None; + entry.pre_entry_b64 = None; + } + Ok(Self { + source, + entries, + encoded_bound: bytes.len(), + }) + } + + /// The finite native operation inventory, in deterministic sorted order. + #[must_use] + pub fn operations(&self) -> Vec { + self.entries.keys().cloned().collect() + } + + /// Attach a current native operator export for the named operation. `None` + /// records only the absence of a protected record, never non-entry or refund. + /// The caller must authenticate the operator socket before obtaining bytes. + /// + /// # Errors + /// Refuses unknown/mismatched operations, obsolete or ambiguous objects, + /// noncanonical/oversized observations and aggregate output over 64 MiB. + pub fn record(&mut self, operation: &str, bytes: Option<&[u8]>) -> Result<(), &'static str> { + let index = *self + .entries + .get(operation) + .ok_or("audit.operation-mismatch")?; + let Some(bytes) = bytes else { + self.source.entries[index].outcome_b64 = None; + self.source.entries[index].pre_entry_b64 = None; + return Ok(()); + }; + let observation_limit = auths_model::MAX_OBSERVATION_BYTES; + // Five signed observations plus JSON keys fit this deliberately finite + // wire bound. The native pre-entry contract permits at most four. + let maximum = + (observation_limit.div_ceil(3) * 4 + 256) * (MAX_AUDIT_PRE_ENTRY_OBSERVATIONS + 1); + if bytes.len() > maximum { + return Err("audit.bundle-invalid-size"); + } + let mut evidence: PrivateEvidence = + serde_json::from_slice(bytes).map_err(|_| "audit.outcome-invalid")?; + if evidence.schema != "auths.gateway-private-audit/1" + || evidence.operation_id != operation + || evidence.pre_entry_b64.len() > MAX_AUDIT_PRE_ENTRY_OBSERVATIONS + || !canonical_base64(&evidence.outcome_b64, observation_limit) + || !evidence + .pre_entry_b64 + .iter() + .all(|value| canonical_base64(value, observation_limit)) + { + return Err("audit.outcome-invalid"); + } + let bound = self + .encoded_bound + .checked_add(bytes.len()) + .ok_or("audit.bundle-invalid-size")?; + if bound > MAX_AUDIT_BUNDLE_BYTES { + return Err("audit.bundle-invalid-size"); + } + self.encoded_bound = bound; + self.source.entries[index].outcome_b64 = Some(std::mem::take(&mut evidence.outcome_b64)); + self.source.entries[index].pre_entry_b64 = + Some(std::mem::take(&mut evidence.pre_entry_b64)); + Ok(()) + } + + /// Serialize the protected bundle. This grants no verified audit status. + /// + /// # Errors + /// Refuses serialization failure or output beyond the shared bundle limit. + pub fn finish(self) -> Result>, &'static str> { + let bytes = + Zeroizing::new(serde_json::to_vec(&self.source).map_err(|_| "audit.bundle-malformed")?); + if bytes.len() > MAX_AUDIT_BUNDLE_BYTES { + return Err("audit.bundle-invalid-size"); + } + Ok(bytes) + } +} + +fn canonical_base64(text: &str, limit: usize) -> bool { + decode(text, limit).is_some_and(|bytes| Base64UrlUnpadded::encode_string(&bytes) == text) +} + +impl Drop for PrivateEvidence { + fn drop(&mut self) { + self.outcome_b64.zeroize(); + for item in &mut self.pre_entry_b64 { + item.zeroize(); + } + } +} + +impl Drop for PrivateAuditBundle { + fn drop(&mut self) { + for entry in &mut self.source.entries { + entry.proof_b64.zeroize(); + entry.action_b64.zeroize(); + if let Some(outcome) = &mut entry.outcome_b64 { + outcome.zeroize(); + } + if let Some(items) = &mut entry.pre_entry_b64 { + for item in items { + item.zeroize(); + } + } + } + } +} + +pub(super) fn entries<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result, D::Error> { + bounded(d, super::MAX_AUDIT_ENTRIES) +} + +pub(super) fn responses<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result, D::Error> { + bounded(d, super::MAX_AUDIT_APPROVAL_RESPONSES) +} + +fn observations<'de, D: serde::Deserializer<'de>>(d: D) -> Result, D::Error> { + bounded(d, MAX_AUDIT_PRE_ENTRY_OBSERVATIONS) +} + +fn bounded<'de, T: Deserialize<'de>, D: serde::Deserializer<'de>>( + d: D, + limit: usize, +) -> Result, D::Error> { + struct Items(usize, std::marker::PhantomData); + impl<'de, T: Deserialize<'de>> serde::de::Visitor<'de> for Items { + type Value = Vec; + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("bounded audit items") + } + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + if seq.size_hint().is_some_and(|size| size > self.0) { + return Err(serde::de::Error::custom("audit item limit exceeded")); + } + let mut values = Vec::new(); + loop { + if values.len() == self.0 { + if seq.next_element::()?.is_some() { + return Err(serde::de::Error::custom("audit item limit exceeded")); + } + break; + } + let Some(value) = seq.next_element()? else { + break; + }; + values.push(value); + } + Ok(values) + } + } + d.deserialize_seq(Items::(limit, std::marker::PhantomData)) +} diff --git a/product/runtime/auths-gateway/src/audit_tests.rs b/product/runtime/auths-gateway/src/audit_tests.rs index e34a582f8..f6e95a5a7 100644 --- a/product/runtime/auths-gateway/src/audit_tests.rs +++ b/product/runtime/auths-gateway/src/audit_tests.rs @@ -6,7 +6,7 @@ //! audit exists to catch a gateway, or a bundle, that says otherwise. use super::*; -use crate::observer::{OutcomeRecord, READ_BACK_SCHEMA, read_back_facts}; +use crate::observer::{OutcomeRecord, PRIVATE_OUTCOME_SCHEMA, READ_BACK_SCHEMA, read_back_facts}; use crate::{AuditPins, AuditReport, AuditStatus, GatewayAttemptStage, pre_entry_digest}; use sha2::{Digest as _, Sha256}; @@ -146,7 +146,7 @@ fn signed_outcome( &LogicalOperationId::parse(operation).expect("operation"), ); let signed = GatewayObserver::from_test_seed(h::OBSERVER_SEED) - .sign(OUTCOME_SCHEMA, &subject, NOW + 1, facts) + .sign(PRIVATE_OUTCOME_SCHEMA, &subject, NOW + 1, facts) .expect("signed outcome"); Base64UrlUnpadded::encode_string(signed.bytes()) } @@ -168,6 +168,80 @@ fn verdicts(report: &AuditReport) -> Vec<(AuditStatus, String)> { .collect() } +#[test] +fn private_export_preserves_inputs_and_rejects_substituted_or_unbounded_evidence() { + let (source, lock, recipe) = ceiling_recipe(); + let harness = Harness::open(recipe.clone(), Backend::File); + let arguments = harness.arguments("private-export", RECORD, &json!({"amount":100})); + let submission = harness.sign(None, &arguments, &[]); + let signed = signed_outcome(&recipe, "private-export", &submission, |record| { + record.relative_basis = Some(1000); + record.relative_basis_digest = Some([0x0b; 32]); + }); + let inventory = entry( + "private-export", + &submission, + Some("untrusted-public-history"), + ); + let (bytes, pins, _) = bundle(&source, &lock, &harness.context, &[inventory.clone()]); + let base = json!({"schema":"auths.gateway-private-audit/1","operation_id":"private-export", + "outcome_b64":signed,"pre_entry_b64":[]}); + let export = || crate::PrivateAuditBundle::new(&bytes).expect("bounded inventory"); + let absent: Value = + serde_json::from_slice(&export().finish().expect("assembled")).expect("JSON"); + assert!(absent["entries"][0]["outcome_b64"].is_null()); + for (field, replacement) in [ + ("schema", json!("auths.gateway-private-audit/0")), + ("operation_id", json!("another-operation")), + ("outcome_b64", json!("AB")), + ("outcome_b64", json!("AQID=")), + ("outcome_b64", json!("A".repeat(6000))), + ("pre_entry_b64", json!(vec!["AQID"; 5])), + ("private_unregistered_field", json!(true)), + ] { + let mut altered = base.clone(); + altered[field] = replacement; + assert!( + export() + .record( + "private-export", + Some(&serde_json::to_vec(&altered).expect("wire")) + ) + .is_err() + ); + } + let text = base.to_string(); + let duplicate = format!( + "{},\"schema\":\"auths.gateway-private-audit/1\"}}", + &text[..text.len() - 1] + ); + assert!( + export() + .record("private-export", Some(duplicate.as_bytes())) + .is_err() + ); + assert!(export().record("another-operation", None).is_err()); + let mut complete = export(); + complete + .record("private-export", Some(text.as_bytes())) + .expect("native private facts"); + let completed = complete.finish().expect("completed private bundle"); + let parsed: Value = serde_json::from_slice(&completed).expect("JSON"); + for field in ["operation_id", "proof_b64", "action_b64"] { + assert!( + parsed["entries"][0][field] == inventory[field], + "original submission field changed" + ); + } + assert_eq!(audit(&completed, &pins).verified, 1); + let mut excessive: Value = serde_json::from_slice(&bytes).expect("inventory"); + excessive["entries"] = json!(vec![inventory; crate::MAX_AUDIT_ENTRIES + 1]); + assert!( + crate::PrivateAuditBundle::new(&serde_json::to_vec(&excessive).expect("oversized items")) + .is_err() + ); +} + /// The audit flags a bundle whose basis does not admit its argument, and one /// whose outcome carries no basis; it shows the provider's status beside the /// verdict, a rejected write included. @@ -361,21 +435,9 @@ async fn audit_checks_the_pre_entry_observations() { ), "{result:?}" ); - let outcome = signed_bytes(harness.outcome("pre-entry", NOW + 31).await); - let GatewayObserveResult::PreEntry { - observations_b64, .. - } = harness - .core - .observe( - &GatewayObserveRequest::PreEntry { - operation_id: "pre-entry".to_owned(), - }, - NOW + 31, - ) - .await - else { - panic!("expected the stored pre-entry observations"); - }; + let private = harness.private_audit("pre-entry", NOW + 31).await; + let outcome = Base64UrlUnpadded::decode_vec(&private.outcome_b64).expect("private outcome"); + let observations_b64 = private.pre_entry_b64; assert_eq!(observations_b64.len(), 1); let base = |pre_entry: Option>, outcome: &[u8]| { let mut value = entry( diff --git a/product/runtime/auths-gateway/src/bin/auths-gateway.rs b/product/runtime/auths-gateway/src/bin/auths-gateway.rs index 6c149394d..bebeb7a22 100644 --- a/product/runtime/auths-gateway/src/bin/auths-gateway.rs +++ b/product/runtime/auths-gateway/src/bin/auths-gateway.rs @@ -753,6 +753,21 @@ mod unix { #[arg(long)] state_dir: PathBuf, }, + /// Operator-only: save protected signed audit evidence to a new 0600 file. + #[command(group(clap::ArgGroup::new("audit-source").required(true).args(["operation_id", "bundle"])))] + AuditExport { + #[arg(long)] + state_dir: PathBuf, + #[arg(long)] + admin_socket: Option, + #[arg(long)] + operation_id: Option, + /// Public submission bundle to complete with private native evidence. + #[arg(long)] + bundle: Option, + #[arg(long)] + out: PathBuf, + }, /// Ask the app socket for one signed observation, or for one /// operation's stored pre-entry observations; never a write. #[command(group(clap::ArgGroup::new("request").required(true).args(["outcome", "pre_entry"])))] @@ -1209,6 +1224,8 @@ mod unix { /// The qualification state a reload derived. #[serde(skip_serializing_if = "Option::is_none")] qualification: Option, + #[serde(skip_serializing_if = "Option::is_none")] + audit: Option, } /// The gate's policy, state, and code. It names no provider and echoes @@ -1245,6 +1262,7 @@ mod unix { recovery: None, commitment: None, qualification: None, + audit: None, } } @@ -2376,6 +2394,9 @@ mod unix { RotateCommit([u8; 32]), Status, ExecutionWitness, + AuditExport { + operation_id: String, + }, Recover { source_operation: String, submission: Box, @@ -2406,6 +2427,11 @@ mod unix { AdminRequestCommand::Status {} => Ok(AdminCommand::Status), AdminRequestCommand::ExecutionWitness {} => Ok(AdminCommand::ExecutionWitness), AdminRequestCommand::QualificationReload {} => Ok(AdminCommand::QualificationReload), + AdminRequestCommand::AuditExport { operation_id } => { + auths_gateway::LogicalOperationId::parse(&operation_id) + .map_err(|_| "gateway.admin.invalid-frame")?; + Ok(AdminCommand::AuditExport { operation_id }) + } AdminRequestCommand::Recover { source_operation } => { let frame = Zeroizing::new(clock.read_frame(stream).await?); let submission: AppSubmission = @@ -2511,6 +2537,16 @@ mod unix { Ok(AdminCommand::QualificationReload) => { reload_admin_qualification(&engine, &state_dir).await } + Ok(AdminCommand::AuditExport { operation_id }) => { + match engine.private_audit(&operation_id).await { + Ok(audit) => AdminResponse { + ok: true, + audit: Some(audit), + ..AdminResponse::refused("gateway.admin.audit-exported") + }, + Err(code) => AdminResponse::refused(code), + } + } Ok(AdminCommand::Recover { source_operation, submission, @@ -2557,6 +2593,7 @@ mod unix { if let Some((mut stream, response)) = Box::pin(clock.complete(stream, change)).await && let Ok(bytes) = serde_json::to_vec(&response) { + let bytes = Zeroizing::new(bytes); let _ = clock.write_frame(&mut stream, &bytes).await; } } @@ -3680,6 +3717,83 @@ mod unix { Action { namespace: String, action: PathBuf }, } + /// One native export is bounded by the existing operator session deadline. + /// Only the authenticated operator client can read this response; no private + /// payload is printed, including when completion fails midway. + async fn audit_export( + state_dir: &Path, + admin_socket: &AdminSocket, + operation_id: Option<&str>, + bundle: Option<&Path>, + out: &Path, + ) -> Result<(), Failure> { + let parent = out.parent().ok_or("gateway.state.invalid-path")?; + check_private_directory(parent) + .map_err(|cause| Failure::at("gateway.audit.unsafe-output", parent, cause))?; + let export = async { + match (operation_id, bundle) { + (Some(operation), None) => { + auths_gateway::LogicalOperationId::parse(operation) + .map_err(|_| "gateway.admin.invalid-frame")?; + private_audit_frame(state_dir, admin_socket, operation) + .await? + .ok_or_else(|| Failure::from("gateway.observer.operation-unknown")) + } + (None, Some(bundle)) => { + let input = Zeroizing::new(read_bounded( + bundle, + auths_gateway::MAX_AUDIT_BUNDLE_BYTES, + )?); + let mut output = auths_gateway::PrivateAuditBundle::new(&input)?; + for operation in output.operations() { + let evidence = + private_audit_frame(state_dir, admin_socket, &operation).await?; + output.record(&operation, evidence.as_deref().map(Vec::as_slice))?; + } + Ok(output.finish()?) + } + _ => Err(Failure::from("gateway.admin.invalid-frame")), + } + }; + let bytes = tokio::time::timeout(ADMIN_SESSION_LIMITS.session, export) + .await + .map_err(|_| "gateway.admin.audit-timeout")??; + private_file(out, &bytes)?; + println!("{{\"ok\":true,\"code\":\"gateway.admin.audit-exported\"}}"); + Ok(()) + } + + async fn private_audit_frame( + state_dir: &Path, + admin_socket: &AdminSocket, + operation: &str, + ) -> Result>>, Failure> { + let response = admin_exchange( + state_dir, + admin_socket, + serde_json::json!({"command":"audit-export", "operation_id":operation}), + None, + ) + .await?; + if response.get("ok").and_then(serde_json::Value::as_bool) != Some(true) { + if response.get("code").and_then(serde_json::Value::as_str) + == Some("gateway.observer.operation-unknown") + { + return Ok(None); + } + return Err("gateway.admin.audit-refused".into()); + } + let bytes = Zeroizing::new( + serde_json::to_vec( + response + .get("audit") + .ok_or("gateway.admin.invalid-response")?, + ) + .map_err(|_| "gateway.admin.invalid-response")?, + ); + Ok(Some(bytes)) + } + /// Sends one admin command. Before anything is written, the admin /// socket must pass the checks `serve` applies, and the listener must /// run as this user or root, so a rotated credential never reaches a @@ -4970,6 +5084,23 @@ mod unix { ) .await } + Command::AuditExport { + state_dir, + admin_socket, + operation_id, + bundle, + out, + } => { + let admin_socket = admin_socket_path(&state_dir, admin_socket); + audit_export( + &state_dir, + &admin_socket, + operation_id.as_deref(), + bundle.as_deref(), + &out, + ) + .await + } Command::ObserverInit { state_dir } => observer_init(&state_dir), Command::ObserverShow { state_dir } => observer_show(&state_dir), Command::AppRecover { diff --git a/product/runtime/auths-gateway/src/bounds_tests.rs b/product/runtime/auths-gateway/src/bounds_tests.rs index 448851446..73b0c8eb8 100644 --- a/product/runtime/auths-gateway/src/bounds_tests.rs +++ b/product/runtime/auths-gateway/src/bounds_tests.rs @@ -884,11 +884,26 @@ async fn journey_bundle(quorum: &RefundQuorum) -> Value { let mut entries = Vec::new(); for (operation, submission) in quorum.journey() { let _ = quorum.harness.submit(&submission, NOW).await; - let outcome = match quorum.harness.outcome(operation, NOW + 1).await { - GatewayObserveResult::Signed { - observation_b64, .. - } => Some(observation_b64), - GatewayObserveResult::PreEntry { .. } | GatewayObserveResult::Refused { .. } => None, + let outcome = if quorum + .harness + .store + .read( + &namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .await + .expect("store") + .is_some() + { + Some( + quorum + .harness + .private_audit(operation, NOW + 1) + .await + .outcome_b64, + ) + } else { + None }; entries.push(json!({ "operation_id": operation, @@ -1398,12 +1413,11 @@ async fn offline_audit_flags_an_over_admission_without_any_order() { verdict(&second.harness.submit(&submission, NOW).await), ("entered", None) ); - let GatewayObserveResult::Signed { - observation_b64, .. - } = second.harness.outcome(operation, NOW + 1).await - else { - panic!("the second gateway signs its outcome"); - }; + let observation_b64 = second + .harness + .private_audit(operation, NOW + 1) + .await + .outcome_b64; bundle["entries"][3]["outcome_b64"] = json!(observation_b64); let report = audit(&bundle, &pins(&first)); assert_eq!( diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 6041b7139..b68d2569a 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -12,7 +12,8 @@ use crate::connection::{ }; use crate::effect::{ApprovedEffect, ExactEffectApproval}; use crate::observer::{ - GatewayObserver, GatewaySignedObservation, OUTCOME_SCHEMA, operation_subject, outcome_facts, + GatewayObserver, GatewaySignedObservation, OUTCOME_SCHEMA, OutcomeRecord, + PRIVATE_OUTCOME_SCHEMA, operation_subject, outcome_facts, }; use crate::recipe::{ENTRY_DEADLINE_SECONDS, GuardChecks}; use crate::submit::{self, SubmitContext, SubmitIo}; @@ -295,11 +296,35 @@ pub enum GatewayObserveRequest { /// Sign the stored record of one logical operation in this /// installation's namespace. No provider is contacted. Outcome { operation_id: String }, - /// Return the signed pre-entry observations stored for one logical - /// operation. Nothing is signed and no provider is contacted. + /// Return redacted pre-entry history for one logical operation. + /// No protected observation bytes are returned or provider contacted. PreEntry { operation_id: String }, } +/// Operator-private audit export from one immutable loaded journal revision. +/// Contains protected facts; callers must enforce operator authentication and +/// persist this only in owner-private storage. It confers no entry authority. +#[derive(Clone, Eq, PartialEq, Serialize)] +pub struct GatewayPrivateAudit { + /// Versioned operator artifact schema. + pub schema: &'static str, + /// Exact logical operation whose protected facts were signed. + pub operation_id: String, + /// Canonical signed private outcome, unpadded base64url. + pub outcome_b64: String, + /// Canonical protected pre-entry observations in pointer order. + pub pre_entry_b64: Vec, +} + +impl std::fmt::Debug for GatewayPrivateAudit { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter + .debug_struct("GatewayPrivateAudit") + .field("private", &"[redacted]") + .finish_non_exhaustive() + } +} + /// Closed application result of an observation request. A signed /// observation asserts only what the gateway saw at `observed_at`. #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] @@ -308,21 +333,92 @@ pub enum GatewayObserveResult { /// A canonical signed observation to attach to the next action with /// `media_type` as its attachment media type. Signed { + #[serde(deserialize_with = "decode_outcome_schema")] schema: String, + #[serde(deserialize_with = "decode_public_subject")] subject: String, + #[serde(deserialize_with = "decode_evidence_time")] observed_at: u64, + #[serde(deserialize_with = "decode_observation_media_type")] media_type: String, + #[serde(deserialize_with = "decode_observation_bytes")] observation_b64: String, }, - /// The signed pre-entry observations stored for `operation_id`, in - /// pointer order, each unpadded base64url; empty when none were - /// recorded. + /// Redacted local history, without observation values or body digests. PreEntry { operation_id: String, - observations_b64: Vec, + #[serde(deserialize_with = "decode_pre_entry_count")] + observations: usize, + #[serde(deserialize_with = "decode_evidence_commitment")] + record_commitment: String, }, /// Nothing was signed. - Refused { code: String }, + Refused { + #[serde(deserialize_with = "decode_refusal_code")] + code: String, + }, +} + +fn decode_refusal_code<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let value = String::deserialize(d)?; + if value.is_empty() || value.len() > 128 { + return Err(serde::de::Error::custom("invalid public refusal code")); + } + Ok(value) +} + +fn decode_outcome_schema<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let value = String::deserialize(d)?; + if value != OUTCOME_SCHEMA { + return Err(serde::de::Error::custom("invalid public outcome schema")); + } + Ok(value) +} + +fn decode_public_subject<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let value = String::deserialize(d)?; + if value.is_empty() || value.len() > 1024 { + return Err(serde::de::Error::custom( + "invalid public observation subject", + )); + } + Ok(value) +} + +fn decode_observation_media_type<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result { + let value = String::deserialize(d)?; + if value != crate::OBSERVATION_MEDIA_TYPE { + return Err(serde::de::Error::custom( + "invalid public observation media type", + )); + } + Ok(value) +} + +fn decode_observation_bytes<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let value = String::deserialize(d)?; + let maximum = auths_model::MAX_OBSERVATION_BYTES; + if value.is_empty() || value.len() > maximum.div_ceil(3) * 4 { + return Err(serde::de::Error::custom("invalid public observation size")); + } + let decoded = Base64UrlUnpadded::decode_vec(&value) + .map_err(|_| serde::de::Error::custom("invalid public observation encoding"))?; + if decoded.len() > maximum || Base64UrlUnpadded::encode_string(&decoded) != value { + return Err(serde::de::Error::custom( + "invalid public observation encoding", + )); + } + Ok(value) +} + +fn decode_pre_entry_count<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let value = usize::deserialize(d)?; + if value > crate::MAX_AUDIT_PRE_ENTRY_OBSERVATIONS { + return Err(serde::de::Error::custom("invalid public pre-entry count")); + } + Ok(value) } impl From for GatewayObserveResult { @@ -2463,6 +2559,36 @@ impl GatewayEngine { .map_err(|_| ()) } + /// Export signed protected audit facts for the authenticated operator. + /// This is not an application protocol operation. Socket integrations must + /// enforce the existing operator peer-UID gate before invoking it. + /// + /// # Errors + /// Refuses malformed or absent operations, unavailable protected state, + /// unavailable clock/key, or facts the native outcome predicate refuses. + pub async fn private_audit( + &self, + operation_id: &str, + ) -> Result { + let observer = self + .observer + .as_ref() + .ok_or("gateway.observer.not-provisioned")?; + let operation = crate::LogicalOperationId::parse(operation_id) + .map_err(|_| "gateway.observer.invalid-operation")?; + let snapshot = self + .attempts + .read(self.recipe.namespace(), &operation) + .await + .map_err(|_| "gateway.observer.store-unavailable")? + .ok_or("gateway.observer.operation-unknown")?; + private_audit( + &snapshot, + observer, + wall_clock_seconds().ok_or("gateway.observer.clock-unavailable")?, + ) + } + /// Projects or signs retained local history for the application. This /// route never leases a credential or contacts a provider. Independently /// authorized provider evidence uses `recover` and its durable acquisition. @@ -3022,11 +3148,57 @@ pub(crate) async fn observe_outcome( facts, ) }) + .and_then(|signed| { + let projection = + crate::observer::verify_public_outcome(signed.bytes(), observer.principal()) + .ok_or(crate::GatewayObserverError::Unrepresentable)?; + if projection.subject != signed.subject() + || projection.observed_at != now + || projection.stage == crate::GatewayAttemptStage::EntryGranted + { + return Err(crate::GatewayObserverError::Unrepresentable); + } + Ok(signed) + }) .map_or_else(|error| refused(error.code()), GatewayObserveResult::from) } -/// Returns the signed pre-entry observations stored for one logical -/// operation. It signs nothing and contacts no provider. +/// A single protected snapshot is used for both outcome facts and observations. +pub(crate) fn private_audit( + snapshot: &crate::GatewayAttemptSnapshot, + observer: &GatewayObserver, + now: u64, +) -> Result { + let signed = OutcomeRecord::from_snapshot(snapshot) + .facts() + .and_then(|facts| { + observer.sign( + PRIVATE_OUTCOME_SCHEMA, + &operation_subject(snapshot.namespace(), snapshot.operation_id()), + now, + facts, + ) + }) + .map_err(|error| error.code())?; + Ok(GatewayPrivateAudit { + schema: "auths.gateway-private-audit/1", + operation_id: snapshot.operation_id().as_str().to_owned(), + outcome_b64: Base64UrlUnpadded::encode_string(signed.bytes()), + pre_entry_b64: snapshot + .pre_entry() + .map(|record| { + record + .observations + .iter() + .map(|bytes| Base64UrlUnpadded::encode_string(bytes)) + .collect() + }) + .unwrap_or_default(), + }) +} + +/// Returns redacted pre-entry history without protected observation bytes. +/// It signs nothing and contacts no provider. pub(crate) async fn observe_pre_entry( attempts: &GatewayAttempts, namespace: &crate::OperatorNamespace, @@ -3042,16 +3214,10 @@ pub(crate) async fn observe_pre_entry( }; GatewayObserveResult::PreEntry { operation_id: operation.as_str().to_owned(), - observations_b64: snapshot + observations: snapshot .pre_entry() - .map(|record| { - record - .observations - .iter() - .map(|bytes| Base64UrlUnpadded::encode_string(bytes)) - .collect() - }) - .unwrap_or_default(), + .map_or(0, |record| record.observations.len()), + record_commitment: hex::encode(snapshot.public_record_commitment()), } } diff --git a/product/runtime/auths-gateway/src/fuzzing.rs b/product/runtime/auths-gateway/src/fuzzing.rs index 4a54f4b56..6515a7b33 100644 --- a/product/runtime/auths-gateway/src/fuzzing.rs +++ b/product/runtime/auths-gateway/src/fuzzing.rs @@ -61,14 +61,12 @@ pub struct VerifiedOutcomeSummary { /// Verifies one outcome under the pinned `observer`. #[must_use] pub fn verify_outcome(bytes: &[u8], observer: &PrincipalId) -> Option { - crate::observer::verify_outcome(bytes, observer) - .ok() - .map(|verified| VerifiedOutcomeSummary { - stage: verified.stage(), - subject: verified.subject.clone(), - observed_at: verified.observed_at, - well_formed: verified.record.well_formed(), - }) + crate::observer::verify_public_outcome(bytes, observer).map(|verified| VerifiedOutcomeSummary { + stage: crate::observer::stage_name(verified.stage), + subject: verified.subject.clone(), + observed_at: verified.observed_at, + well_formed: true, + }) } /// The schema a verified outcome must carry. diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index fe34dbee6..40e6d15d3 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -74,8 +74,8 @@ mod store_testkit; pub use audit::{ AUDIT_BUNDLE_SCHEMA, AUDIT_REPORT_SCHEMA, AuditPins, AuditReport, AuditStatus, AuditedApprovalResponse, AuditedEntry, AuditedPreEntry, MAX_AUDIT_BUNDLE_BYTES, - MAX_AUDIT_ENTRIES, MAX_AUDIT_PRE_ENTRY_OBSERVATIONS, ProviderResult, UnverifiedEntries, - audit_bundle, + MAX_AUDIT_ENTRIES, MAX_AUDIT_PRE_ENTRY_OBSERVATIONS, PrivateAuditBundle, ProviderResult, + UnverifiedEntries, audit_bundle, }; pub use binding::{GatewayConnectionDescriptor, GatewayConnectionError}; pub use bounds::{ @@ -96,8 +96,8 @@ pub use echo_verify::{ }; pub use engine::{ GatewayAdminOutcome, GatewayAdminStatus, GatewayEngine, GatewayEngineConfigurationError, - GatewayEvidenceSummary, GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult, - PUBLIC_EVIDENCE_SCHEMA, SLOT_SWEEP_INTERVAL_SECONDS, SLOT_SWEEP_LIMIT, + GatewayEvidenceSummary, GatewayObserveRequest, GatewayObserveResult, GatewayPrivateAudit, + GatewaySubmitResult, PUBLIC_EVIDENCE_SCHEMA, SLOT_SWEEP_INTERVAL_SECONDS, SLOT_SWEEP_LIMIT, gateway_verifier_configuration, }; pub use generation_floor::GenerationFloor; diff --git a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs index e1140d415..46c865fda 100644 --- a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs +++ b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs @@ -34,6 +34,7 @@ fn history(backend: Backend) -> (Value, Vec, String) { case.store.reopen(), controls(true), )); + let engine = engine.with_observer(crate::GatewayObserver::from_test_seed(0x33)); engine .activate_effect_configuration( engine @@ -91,12 +92,21 @@ fn history(backend: Backend) -> (Value, Vec, String) { .expect("action digest"), ) .expect("digest"); + let recipe_digest = + hex::decode(original["recipe_digest"].as_str().expect("recipe digest")).expect("digest"); let (proof, action_bytes, approval) = input(&case.setup.installation.root, SOURCE); let first = runtime.block_on(engine.submit(&proof, &action_bytes, approval.clone())); let public = serde_json::to_vec(&first).expect("public mutation result"); private_values_absent( &public, - &[CONTENT, &body, &digest, &action, echo.as_bytes()], + &[ + CONTENT, + &body, + &digest, + &action, + &recipe_digest, + echo.as_bytes(), + ], ); private_values_absent( format!("{:?}", recovered.source).as_bytes(), @@ -120,6 +130,103 @@ fn history(backend: Backend) -> (Value, Vec, String) { assert_ne!(commitment, hex::encode(digest)); assert!(value["evidence"].get("echo").is_none()); assert!(value["evidence"].get("evidence_digest").is_none()); + let observed = runtime.block_on(engine.observe(&crate::GatewayObserveRequest::Outcome { + operation_id: SOURCE.to_owned(), + })); + let crate::GatewayObserveResult::Signed { + schema, + observation_b64, + .. + } = observed + else { + panic!("configured native observer must sign"); + }; + assert_eq!(schema, "auths.gateway-outcome/3"); + use base64ct::{Base64UrlUnpadded, Encoding as _}; + let signed_bytes = + Base64UrlUnpadded::decode_vec(&observation_b64).expect("canonical signature"); + private_values_absent( + &signed_bytes, + &[ + CONTENT, + &body, + &digest, + &action, + &recipe_digest, + echo.as_bytes(), + ], + ); + let signed = crate::observer::verify_signed( + &signed_bytes, + crate::GatewayObserver::from_test_seed(0x33).principal(), + crate::OUTCOME_SCHEMA, + ) + .expect("signature verified"); + let names: Vec<_> = signed + .statement() + .facts() + .as_slice() + .iter() + .map(|fact| fact.name().as_str()) + .collect(); + assert_eq!( + names, + [ + "effect-reference", + "evaluated-at", + "recipe-reference", + "record-commitment", + "stage" + ] + ); + let private = runtime + .block_on(engine.private_audit(SOURCE)) + .expect("operator audit"); + let private_bytes = + Base64UrlUnpadded::decode_vec(&private.outcome_b64).expect("private signature"); + let verified = crate::observer::verify_outcome( + &private_bytes, + crate::GatewayObserver::from_test_seed(0x33).principal(), + ) + .expect("private audit signature"); + assert_eq!(verified.record.evidence_digest, Some(digest)); + assert_eq!(verified.commitment(), hex::encode(&action)); + assert!( + crate::observer::verify_outcome( + &signed_bytes, + crate::GatewayObserver::from_test_seed(0x33).principal() + ) + .is_err() + ); + private_values_absent( + format!("{private:?}").as_bytes(), + &[CONTENT, &digest, &action, echo.as_bytes()], + ); + let redacted = runtime.block_on(engine.observe(&crate::GatewayObserveRequest::PreEntry { + operation_id: SOURCE.to_owned(), + })); + let redacted_bytes = serde_json::to_vec(&redacted).expect("public history"); + private_values_absent( + &redacted_bytes, + &[ + CONTENT, + &body, + &digest, + &action, + &recipe_digest, + echo.as_bytes(), + ], + ); + let crate::GatewayObserveResult::PreEntry { + observations, + record_commitment, + .. + } = redacted + else { + panic!("redacted pre-entry"); + }; + assert_eq!(observations, private.pre_entry_b64.len()); + assert_eq!(record_commitment.len(), 64); let witness = engine.execution_witness(); let (reopened, _) = runtime.block_on(load_controlled_engine( &case.setup.installation, @@ -216,6 +323,208 @@ fn wire_cases() -> Value { json!(output) } +fn history_wire_case(kind: &str, name: &str, bytes: String, accepted: bool) -> Value { + assert_eq!( + serde_json::from_str::(&bytes).is_ok(), + accepted, + "{name}" + ); + json!({"kind":kind,"case":name,"response":bytes,"accepted":accepted}) +} + +#[allow( + clippy::too_many_lines, + reason = "finite native wire corpus pins every affected public decoder boundary" +)] +fn history_wire_cases() -> Value { + use base64ct::{Base64UrlUnpadded, Encoding as _}; + let pre = json!({"outcome":"pre-entry","operation_id":"step-1","observations":1,"record_commitment":"ab".repeat(32)}); + // These are data-decoding vectors, not authenticated observations. Actual + // configured native signatures and private facts are checked in history(). + let signed = json!({"outcome":"signed","schema":crate::OUTCOME_SCHEMA,"subject":"public-subject", + "observed_at":NOW,"media_type":crate::OBSERVATION_MEDIA_TYPE,"observation_b64":"AQID"}); + let mut cases = vec![ + history_wire_case("pre-entry", "valid", pre.to_string(), true), + history_wire_case("signed", "valid", signed.to_string(), true), + ]; + for (kind, name, field, replacement, accepted) in [ + ("pre-entry", "zero", "observations", json!(0), true), + ("pre-entry", "limit", "observations", json!(4), true), + ( + "pre-entry", + "limit-plus-one", + "observations", + json!(5), + false, + ), + ("pre-entry", "negative", "observations", json!(-1), false), + ("pre-entry", "boolean", "observations", json!(true), false), + ( + "pre-entry", + "short-commitment", + "record_commitment", + json!("00"), + false, + ), + ( + "pre-entry", + "uppercase-commitment", + "record_commitment", + json!("AB".repeat(32)), + false, + ), + ( + "pre-entry", + "newline-commitment", + "record_commitment", + json!(format!("{}\n", "ab".repeat(32))), + false, + ), + ( + "pre-entry", + "private-observations", + "observations_b64", + json!(["AQID"]), + false, + ), + ( + "signed", + "old-public-schema", + "schema", + json!("auths.gateway-outcome/2"), + false, + ), + ( + "signed", + "private-schema", + "schema", + json!("auths.gateway-private-outcome/1"), + false, + ), + ( + "signed", + "wrong-media", + "media_type", + json!("application/cbor"), + false, + ), + ("signed", "empty-subject", "subject", json!(""), false), + ( + "signed", + "subject-limit", + "subject", + json!("é".repeat(512)), + true, + ), + ( + "signed", + "subject-limit-plus-one", + "subject", + json!("é".repeat(513)), + false, + ), + ( + "signed", + "time-limit", + "observed_at", + json!((1_u64 << 53) - 1), + true, + ), + ( + "signed", + "unsafe-time", + "observed_at", + json!(1_u64 << 53), + false, + ), + ("signed", "negative-time", "observed_at", json!(-1), false), + ("signed", "boolean-time", "observed_at", json!(true), false), + ("signed", "empty-bytes", "observation_b64", json!(""), false), + ( + "signed", + "padded-bytes", + "observation_b64", + json!("AQID="), + false, + ), + ( + "signed", + "noncanonical-pad-bits", + "observation_b64", + json!("AB"), + false, + ), + ( + "signed", + "bytes-limit", + "observation_b64", + json!(Base64UrlUnpadded::encode_string(&vec![1; 4096])), + true, + ), + ( + "signed", + "bytes-limit-plus-one", + "observation_b64", + json!(Base64UrlUnpadded::encode_string(&vec![1; 4097])), + false, + ), + ( + "signed", + "private-facts", + "pre_entry_b64", + json!(["AQID"]), + false, + ), + ] { + let mut value = if kind == "signed" { + signed.clone() + } else { + pre.clone() + }; + value[field] = replacement; + cases.push(history_wire_case(kind, name, value.to_string(), accepted)); + } + for (kind, base) in [("signed", signed), ("pre-entry", pre)] { + let text = base.to_string(); + let field = if kind == "signed" { + "schema" + } else { + "record_commitment" + }; + let duplicate = format!("{},\"{field}\":{}}}", &text[..text.len() - 1], base[field]); + cases.push(history_wire_case( + kind, + "duplicate-member", + duplicate, + false, + )); + cases.push(history_wire_case( + kind, + "bom", + format!("\u{feff}{text}"), + false, + )); + let fractional = if kind == "signed" { + text.replace(&format!("\"observed_at\":{NOW}"), "\"observed_at\":1.0") + } else { + text.replace("\"observations\":1", "\"observations\":1.0") + }; + cases.push(history_wire_case( + kind, + "fractional-number", + fractional.clone(), + false, + )); + cases.push(history_wire_case( + kind, + "exponent-number", + fractional.replace("1.0", "1e0"), + false, + )); + } + json!(cases) +} + fn matrix(backend: Backend) { let (first, first_body, first_commitment) = history(backend); let (second, second_body, second_commitment) = history(backend); @@ -227,8 +536,9 @@ fn matrix(backend: Backend) { assert_eq!(first, second); let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-public-mutation-evidence/1","adapter":backend.label(), "scope":"native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", - "excluded":["signed outcome/pre-entry observation projection hardening", "live provider and hostile OS qualification"], - "public_result":first,"wire_cases":wire_cases(),"same_private_bytes_have_distinct_record_scoped_commitments":true,"reopen_and_replay_preserve_commitment_without_io":true, + "excluded":["live provider and hostile OS qualification"], + "public_result":first,"wire_cases":wire_cases(),"history_wire_cases":history_wire_cases(),"same_private_bytes_have_distinct_record_scoped_commitments":true,"reopen_and_replay_preserve_commitment_without_io":true, + "configured_signed_public_history_excludes_private_facts":true,"operator_private_signature_preserves_full_audit_facts":true, "private_complete_evidence_and_original_binding_preserved":true,"public_and_debug_exclude_raw_body_digest_echo_and_action_digest":true})).expect("artifact"); let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( "../../../bindings/fixtures/gateway/native-public-mutation-evidence-{}.json", diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index ac24cdb48..26db56131 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -9,8 +9,8 @@ //! engine. use crate::engine::{ - GatewayObserveRequest, GatewayObserveResult, GatewaySubmitResult, - gateway_verifier_configuration, not_entered, observe_outcome, observe_read_back, + GatewayObserveResult, GatewaySubmitResult, gateway_verifier_configuration, not_entered, + observe_outcome, observe_read_back, }; use crate::harness::{ self as h, ANCHOR, ASSURANCE, Delivery, NAMESPACE, OTHER_RECORD, RECORD, Signer, @@ -158,7 +158,7 @@ fn outcome_requirement() -> ObservationRequirement { ), ), ObservationCondition::new( - name("commitment"), + name("effect-reference"), ConditionTest::EqAction(name("depends_on_commitment")), ), ], @@ -445,6 +445,19 @@ impl Harness { signed_bytes(self.core.reference_read_back(&arguments, at).await) } + async fn private_audit(&self, operation: &str, at: u64) -> crate::GatewayPrivateAudit { + let snapshot = self + .store + .read( + &namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .await + .expect("store") + .expect("record"); + crate::engine::private_audit(&snapshot, &self.observer, at).expect("private audit") + } + async fn outcome(&self, operation: &str, at: u64) -> GatewayObserveResult { observe_outcome(&self.store, &namespace(), &self.observer, operation, at).await } @@ -663,6 +676,22 @@ async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backe GatewaySubmitResult::Unknown ); let unknown = signed_bytes(harness.outcome("step-1", NOW + 10).await); + let decoded = auths_codec::decode_signed_observation(&unknown, &VerifierLimits::default()) + .expect("outcome"); + let commitment = decoded + .statement() + .facts() + .as_slice() + .iter() + .find_map(|item| { + if item.name().as_str() == "effect-reference" { + if let FactValue::Text(value) = item.value() { + return Some(value.as_str().to_owned()); + } + } + None + }) + .expect("native hiding effect reference"); assert_eq!(stage_of(&unknown), "unknown"); assert_eq!( harness diff --git a/product/runtime/auths-gateway/src/observer.rs b/product/runtime/auths-gateway/src/observer.rs index facb21daf..3dd1f948a 100644 --- a/product/runtime/auths-gateway/src/observer.rs +++ b/product/runtime/auths-gateway/src/observer.rs @@ -22,7 +22,10 @@ //! - `auths.gateway-readback/1`, subject the closed observation URL with the //! observed JSON pointer as fragment, facts `value` and, when the recipe //! declares an echo field and the record carries one, `echo`; -//! - `auths.gateway-outcome/2`, subject +//! - `auths.gateway-private-outcome/1` is operator-only and preserves the complete +//! existing audit presence contract below. Public `auths.gateway-outcome/3` +//! carries hiding effect/record references, stage, time, recipe and bounded status. +//! The private schema has subject //! `auths-gateway:///operations/`, whose facts //! are the stored attempt's commitment, stage (a stored `entry-granted` is //! reported as `unknown`), evaluation time, and recipe digest, and, as the @@ -58,7 +61,9 @@ use zeroize::Zeroizing; /// Schema of an observation of a provider record the gateway read. pub const READ_BACK_SCHEMA: &str = "auths.gateway-readback/1"; /// Schema of an observation of the gateway's own stored attempt record. -pub const OUTCOME_SCHEMA: &str = "auths.gateway-outcome/2"; +pub const OUTCOME_SCHEMA: &str = "auths.gateway-outcome/3"; +/// Operator-private signed audit facts. Never returned on the application socket. +pub const PRIVATE_OUTCOME_SCHEMA: &str = "auths.gateway-private-outcome/1"; /// Domain of the counter-set digest an outcome carries. const COUNTER_SET_DOMAIN: &[u8] = b"auths.gateway-counter-set/1\0"; /// Largest integer a JSON reader represents exactly. @@ -543,7 +548,7 @@ const fn kernel_stage(stage: GatewayAttemptStage) -> Stage { } } -fn stage_name(stage: GatewayAttemptStage) -> &'static str { +pub(crate) fn stage_name(stage: GatewayAttemptStage) -> &'static str { match stage { GatewayAttemptStage::NotEntered => "not-entered", GatewayAttemptStage::Reserved => "reserved", @@ -811,7 +816,113 @@ fn lower_hex_digest(value: &str) -> bool { pub(crate) fn outcome_facts( snapshot: &GatewayAttemptSnapshot, ) -> Result, GatewayObserverError> { - OutcomeRecord::from_snapshot(snapshot).facts() + let record = OutcomeRecord::from_snapshot(snapshot); + if !record.well_formed() { + return Err(GatewayObserverError::Unrepresentable); + } + let mut facts = vec![ + fact( + "effect-reference", + text(&hex::encode(snapshot.public_effect_reference()))?, + )?, + fact( + "record-commitment", + text(&hex::encode(snapshot.public_record_commitment()))?, + )?, + fact("stage", text(stage_name(record.stage))?)?, + fact("evaluated-at", FactValue::Uint(record.evaluated_at))?, + fact( + "recipe-reference", + text(&hex::encode(snapshot.public_recipe_reference()))?, + )?, + ]; + if let Some(status) = record.http_status { + facts.push(fact("http-status", FactValue::Uint(u64::from(status)))?); + } + if let Some(refusal) = record.refusal { + facts.push(fact("refusal", text(&refusal)?)?); + } + Ok(facts) +} + +/// Verified public projection. Hiding references do not expose the underlying +/// action, response, counters, pre-entry values or relative-ceiling basis. +pub(crate) struct PublicOutcome { + pub(crate) subject: String, + pub(crate) observed_at: u64, + pub(crate) stage: GatewayAttemptStage, +} + +/// Strict public schema verification; private audit has a separate closed schema. +pub(crate) fn verify_public_outcome(bytes: &[u8], observer: &PrincipalId) -> Option { + let signed = verify_signed(bytes, observer, OUTCOME_SCHEMA)?; + let statement = signed.statement(); + if statement.observed_at().get() > MAX_JSON_INTEGER { + return None; + } + let mut fields = std::collections::BTreeMap::new(); + for item in statement.facts().as_slice() { + if !matches!( + item.name().as_str(), + "effect-reference" + | "record-commitment" + | "stage" + | "evaluated-at" + | "recipe-reference" + | "http-status" + | "refusal" + ) || fields.insert(item.name().as_str(), item.value()).is_some() + { + return None; + } + } + let text = |name| match fields.get(name)? { + FactValue::Text(value) => Some(value.as_str()), + _ => None, + }; + for name in ["effect-reference", "record-commitment", "recipe-reference"] { + if !lower_hex_digest(text(name)?) { + return None; + } + } + let stage = parse_stage(text("stage")?)?; + if stage == GatewayAttemptStage::EntryGranted { + return None; + } + let FactValue::Uint(evaluated) = fields.get("evaluated-at")? else { + return None; + }; + if *evaluated > MAX_JSON_INTEGER { + return None; + } + if stage == GatewayAttemptStage::NotEntered { + let refusal = text("refusal")?; + if refusal.is_empty() || refusal.len() > MAX_REFUSAL_BYTES { + return None; + } + } else if fields.contains_key("refusal") { + return None; + } + if let Some(status) = fields.get("http-status") { + let FactValue::Uint(status) = status else { + return None; + }; + if !(100..=599).contains(status) + || !matches!( + stage, + GatewayAttemptStage::ResponseRecorded + | GatewayAttemptStage::Observed + | GatewayAttemptStage::ObservedByProvider + ) + { + return None; + } + } + Some(PublicOutcome { + subject: statement.subject().as_str().to_owned(), + observed_at: statement.observed_at().get(), + stage, + }) } /// A signed outcome observation whose signature verified under a pinned @@ -888,7 +999,7 @@ pub(crate) fn verify_signed( Some(signed) } -/// Verifies one `auths.gateway-outcome/2` observation offline: a valid +/// Verifies one operator-private `auths.gateway-private-outcome/1` observation offline: a valid /// signature of the pinned observer (see [`verify_signed`]) over a fact set /// the presence rule accepts, with every value in its bound. /// @@ -900,7 +1011,7 @@ pub(crate) fn verify_outcome( observer: &PrincipalId, ) -> Result { let invalid = "audit.outcome-invalid"; - let signed = verify_signed(bytes, observer, OUTCOME_SCHEMA).ok_or(invalid)?; + let signed = verify_signed(bytes, observer, PRIVATE_OUTCOME_SCHEMA).ok_or(invalid)?; let statement = signed.statement(); let record = OutcomeRecord::from_facts(statement.facts().as_slice()).ok_or(invalid)?; Ok(VerifiedOutcome { diff --git a/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs b/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs index 486be3bef..ce258ab6b 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs @@ -1,4 +1,4 @@ -//! Signed outcome `/2` vectors: for each stage and fact combination, the +//! Operator-private outcome `/1` vectors: for each stage and fact combination, the //! canonical observation signed by a fixed test observer and its expected //! facts, plus refused vectors that break the presence rule, the schema, or //! the signer. @@ -31,9 +31,9 @@ use base64ct::{Base64, Base64UrlUnpadded, Encoding as _}; use serde_json::{Map, Value, json}; use sha2::{Digest as _, Sha256}; -pub(super) const FILE: &str = "outcome-v2.json"; +pub(super) const FILE: &str = "private-outcome-v1.json"; const SCHEMA: &str = "auths.gateway-outcome-vectors/1"; -const OUTCOME_V2: &str = "auths.gateway-outcome/2"; +const PRIVATE_OUTCOME: &str = "auths.gateway-private-outcome/1"; const OBSERVER_SEED: u8 = 0x5a; const OTHER_SEED: u8 = 0x5b; const OBSERVED_AT: u64 = NOW + 5; @@ -247,37 +247,37 @@ fn refused() -> Vec { ), ( "http-status-without-response-digest", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[HTTP_200]), ), ( "refusal-on-response-recorded", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[HTTP_200, RESPONSE, refusal("gateway.transport.not-entered")]), ), ( "not-entered-without-refusal", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, facts("not-entered", &[]), ), ( "observation-on-response-recorded", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[HTTP_200, RESPONSE, ("observation", Fact::Text("match"))]), ), ( "observed-without-observation", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, facts("observed", &[HTTP_200, RESPONSE]), ), ( "evidence-digest-on-observed", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, facts( "observed", @@ -291,7 +291,7 @@ fn refused() -> Vec { ), ( "relative-basis-2-pow-53", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[ HTTP_200, @@ -302,25 +302,25 @@ fn refused() -> Vec { ), ( "relative-basis-digest-without-basis", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[HTTP_200, RESPONSE, BASIS_DIGEST]), ), ( "http-status-99", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[("http-status", Fact::Uint(99)), RESPONSE]), ), ( "stage-attempting", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, facts("attempting", &[]), ), ( "unregistered-fact", - OUTCOME_V2, + PRIVATE_OUTCOME, OBSERVER_SEED, recorded(&[ HTTP_200, @@ -330,7 +330,7 @@ fn refused() -> Vec { ), ( "other-signer", - OUTCOME_V2, + PRIVATE_OUTCOME, OTHER_SEED, recorded(&[HTTP_200, RESPONSE]), ), @@ -390,7 +390,7 @@ fn packaged_registries(use_registries: impl FnOnce(&ImmutableRegistries<'_>) /// Trust compiled as the SDKs compile it, pinned to the packaged /// configuration and bound to the verdict clock, whose observer anchor for /// the vector observer covers both vector namespaces. -fn verdict_context(root: &Signer, observer: &GatewayObserver) -> Vec { +fn verdict_context(root: &Signer, observer: &GatewayObserver, schema: &str) -> Vec { #[allow( clippy::redundant_closure_for_method_calls, reason = "the method path cannot name the registries' own lifetime" @@ -417,7 +417,7 @@ fn verdict_context(root: &Signer, observer: &GatewayObserver) -> Vec { ObserverAnchorId::parse(h::ANCHOR).expect("anchor ID"), observer.principal().clone(), vec![PrincipalMethodId::parse(auths_raw_key::RAW_KEY_V1).expect("method")], - vec![ObservationSchemaId::parse(OUTCOME_V2).expect("schema")], + vec![ObservationSchemaId::parse(schema).expect("schema")], ["stripe-refunds", "airtable-demo"] .iter() .map(|namespace| { @@ -474,10 +474,10 @@ fn verdict_context(root: &Signer, observer: &GatewayObserver) -> Vec { /// The grant requirement every verdict case carries: the outcome of /// `subject`, at most an hour old, in stage `observed-by-provider`. -fn stage_requirement(subject: &str) -> ObservationRequirement { +fn stage_requirement(subject: &str, schema: &str) -> ObservationRequirement { ObservationRequirement::new( ObserverAnchorId::parse(h::ANCHOR).expect("anchor"), - ObservationSchemaId::parse(OUTCOME_V2).expect("schema"), + ObservationSchemaId::parse(schema).expect("schema"), ObservationSubject::Resource(ResourceId::parse(subject).expect("subject")), 3_600, vec![ObservationCondition::new( @@ -496,7 +496,7 @@ fn stage_requirement(subject: &str) -> ObservationRequirement { /// One verdict case over the vector `entry`: its exact observation bytes /// attached to an action whose grant requires its subject's outcome in stage /// `observed-by-provider`. -fn verdict(entry: &Value, context: &[u8], root: &Signer, agent: &Signer) -> Value { +fn verdict(entry: &Value, context: &[u8], root: &Signer, agent: &Signer, schema: &str) -> Value { let id = entry["id"].as_str().expect("id"); let subject = entry["subject"].as_str().expect("subject"); let observation = @@ -504,7 +504,7 @@ fn verdict(entry: &Value, context: &[u8], root: &Signer, agent: &Signer) -> Valu let grant = h::grant( root, &agent.principal, - Some(stage_requirement(subject)), + Some(stage_requirement(subject, schema)), NOW, ) .expect("grant"); @@ -543,7 +543,7 @@ fn document() -> Value { let accepted: Vec = [not_entered_and_unknown(), recorded_and_observed()] .concat() .iter() - .map(|(id, namespace, facts)| signed(OBSERVER_SEED, OUTCOME_V2, namespace, id, facts)) + .map(|(id, namespace, facts)| signed(OBSERVER_SEED, PRIVATE_OUTCOME, namespace, id, facts)) .collect(); let refused: Vec = refused() .iter() @@ -555,7 +555,7 @@ fn document() -> Value { .collect(); let root = Signer::new(ROOT_SEED); let agent = Signer::new(AGENT_SEED); - let context = verdict_context(&root, &observer); + let context = verdict_context(&root, &observer, PRIVATE_OUTCOME); let verdicts: Vec = accepted .iter() .chain(refused.iter().filter(|entry| { @@ -564,11 +564,11 @@ fn document() -> Value { Some("other-signer" | "outcome-v1-schema") ) })) - .map(|entry| verdict(entry, &context, &root, &agent)) + .map(|entry| verdict(entry, &context, &root, &agent, PRIVATE_OUTCOME)) .collect(); json!({ "schema": SCHEMA, - "outcome_schema": OUTCOME_V2, + "outcome_schema": PRIVATE_OUTCOME, "observer": {"seed_byte": OBSERVER_SEED, "principal": observer.principal().as_str()}, "observed_at": OBSERVED_AT, "accepted": accepted, @@ -579,7 +579,7 @@ fn document() -> Value { } #[test] -fn outcome_v2_vectors_are_current() { +fn private_outcome_v1_vectors_are_current() { require_current(FILE, &document()); } @@ -611,7 +611,7 @@ fn outcome_verifier_accepts_every_vector_with_its_facts_and_refuses_the_rest() { assert_eq!(Value::Object(facts), entry["facts"], "{}", entry["id"]); let signed = crate::observer::OutcomeRecord::facts(&verified.record).expect("facts"); let resigned = GatewayObserver::from_test_seed(OBSERVER_SEED) - .sign(OUTCOME_V2, &verified.subject, OBSERVED_AT, signed) + .sign(PRIVATE_OUTCOME, &verified.subject, OBSERVED_AT, signed) .expect("re-signed"); assert_eq!(resigned.bytes(), bytes.as_slice(), "{}", entry["id"]); } @@ -647,3 +647,132 @@ fn outcome_verdicts_follow_the_stage_condition() { ); } } + +/// Public projection vectors retain stage and exact scoped hiding references; +/// the full private presence corpus above remains an independent audit oracle. +fn public_document() -> Value { + let schema = crate::OUTCOME_SCHEMA; + let observer = GatewayObserver::from_test_seed(OBSERVER_SEED); + let project = |raw: &Facts| -> Facts { + let mut projected: Facts = vec![ + ( + "effect-reference", + Fact::DigestHex("public-effect-reference"), + ), + ( + "record-commitment", + Fact::DigestHex("public-record-commitment"), + ), + ( + "recipe-reference", + Fact::DigestHex("public-recipe-reference"), + ), + ]; + projected.extend(raw.iter().copied().filter(|(name, _)| { + matches!(*name, "stage" | "evaluated-at" | "http-status" | "refusal") + })); + projected + }; + let accepted: Vec<_> = [not_entered_and_unknown(), recorded_and_observed()] + .concat() + .iter() + .map(|(id, namespace, facts)| signed(OBSERVER_SEED, schema, namespace, id, &project(facts))) + .collect(); + let mut refused = vec![]; + let base = project(&facts("unknown", &[])); + for (id, signing_schema, seed, fields) in [ + ( + "outcome-v1-schema", + "auths.gateway-outcome/1", + OBSERVER_SEED, + base.clone(), + ), + ( + "outcome-v2-schema", + "auths.gateway-outcome/2", + OBSERVER_SEED, + base.clone(), + ), + ( + "private-outcome-schema", + PRIVATE_OUTCOME, + OBSERVER_SEED, + base.clone(), + ), + ("other-signer", schema, OTHER_SEED, base.clone()), + ("private-evidence-digest", schema, OBSERVER_SEED, { + let mut fields = base.clone(); + fields.push(EVIDENCE); + fields + }), + ("private-relative-basis", schema, OBSERVER_SEED, { + let mut fields = base.clone(); + fields.push(BASIS); + fields + }), + ( + "missing-record-commitment", + schema, + OBSERVER_SEED, + base.iter() + .copied() + .filter(|(name, _)| *name != "record-commitment") + .collect(), + ), + ("raw-action-commitment", schema, OBSERVER_SEED, { + let mut fields = base.clone(); + fields.push(("commitment", COMMITMENT)); + fields + }), + ] { + let mut value = signed(seed, signing_schema, "stripe-refunds", id, &fields); + value["code"] = json!("audit.outcome-invalid"); + refused.push(value); + } + let root = Signer::new(ROOT_SEED); + let agent = Signer::new(AGENT_SEED); + let context = verdict_context(&root, &observer, schema); + let verdicts: Vec<_> = accepted + .iter() + .chain(refused.iter().filter(|entry| { + matches!( + entry["id"].as_str(), + Some( + "other-signer" + | "outcome-v1-schema" + | "outcome-v2-schema" + | "private-outcome-schema" + ) + ) + })) + .map(|entry| verdict(entry, &context, &root, &agent, schema)) + .collect(); + json!({"schema":SCHEMA,"outcome_schema":schema, + "observer":{"seed_byte":OBSERVER_SEED,"principal":observer.principal().as_str()}, + "observed_at":OBSERVED_AT,"accepted":accepted,"refused":refused, + "verdict_trusted_context_b64":Base64UrlUnpadded::encode_string(&context),"verdicts":verdicts}) +} + +#[test] +fn public_outcome_v3_vectors_are_current() { + let document = public_document(); + let observer = pinned_observer(&document); + for entry in document["accepted"].as_array().expect("accepted") { + let bytes = + Base64::decode_vec(entry["observation_b64"].as_str().expect("bytes")).expect("base64"); + let verified = + crate::observer::verify_public_outcome(&bytes, &observer).expect("public signature"); + assert_eq!(verified.subject, entry["subject"]); + assert_eq!(verified.observed_at, OBSERVED_AT); + } + for entry in document["refused"].as_array().expect("refused") { + let bytes = + Base64::decode_vec(entry["observation_b64"].as_str().expect("bytes")).expect("base64"); + assert!( + crate::observer::verify_public_outcome(&bytes, &observer).is_none(), + "{}", + entry["id"] + ); + } + require_current("outcome-v3.json", &document); +} diff --git a/product/runtime/auths-gateway/src/property_tests.rs b/product/runtime/auths-gateway/src/property_tests.rs index 9ec82796e..2e15da440 100644 --- a/product/runtime/auths-gateway/src/property_tests.rs +++ b/product/runtime/auths-gateway/src/property_tests.rs @@ -2,7 +2,7 @@ //! relative ceiling, audit recount, signed outcomes, and attempt store. use crate::audit::{count_bound_violations, sum_bound_violations}; -use crate::observer::{OUTCOME_SCHEMA, OutcomeRecord, verify_outcome}; +use crate::observer::{OutcomeRecord, PRIVATE_OUTCOME_SCHEMA, verify_outcome}; use crate::{ CompiledRecipe, FileGatewayAttemptStore, GatewayAttemptError, GatewayAttemptStage, GatewayAttempts, GatewayObserver, LogicalOperationId, OperatorNamespace, echo_token, @@ -277,7 +277,7 @@ proptest! { let observer = GatewayObserver::from_test_seed(0x5a); let facts = record.facts().expect("an accepted record has facts"); let signed = observer - .sign(OUTCOME_SCHEMA, "auths-gateway://ns/operations/op-1", 1_790_000_000, facts) + .sign(PRIVATE_OUTCOME_SCHEMA, "auths-gateway://ns/operations/op-1", 1_790_000_000, facts) .expect("signed"); let verified = verify_outcome(signed.bytes(), observer.principal()).expect("verified"); prop_assert_eq!(verified.record, record); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 04089049a..a56f46164 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "93ef3b915cc48f0c0d4c0d4de7e03d0ed394e83526fbdfdc2ad19443dec5ec20"; + "899847a8307da6574f1b83a8fa9d85e9d4d54fa4f94c2952f696dafacb2e8a07"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 30b7b62a3..ebfee033c 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -33,6 +33,7 @@ use std::{ }; use tempfile::NamedTempFile; use thiserror::Error; +use zeroize::Zeroizing; pub use auths_stores::GatewayRecordKind; @@ -209,7 +210,7 @@ pub enum GatewayCounterKind { } /// One counter slot reserved with the claim. -#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] +#[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] pub struct GatewayCounterEntry { /// The counter kind. pub kind: GatewayCounterKind, @@ -220,7 +221,7 @@ pub struct GatewayCounterEntry { } /// The relative-ceiling basis the gateway read after the lease. -#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[derive(Clone, Copy, Eq, PartialEq)] pub struct GatewayRelativeBasis { /// The basis value. pub value: u64, @@ -232,7 +233,7 @@ pub struct GatewayRelativeBasis { /// What was read after the lease and before the write: the signed pre-entry /// observations, in pointer order, and the relative-ceiling basis. -#[derive(Clone, Debug, Default, Eq, PartialEq)] +#[derive(Clone, Default, Eq, PartialEq)] pub struct GatewayPreEntry { /// Canonical signed `auths.gateway-readback/1` observations. pub observations: Vec>, @@ -240,6 +241,31 @@ pub struct GatewayPreEntry { pub basis: Option, } +impl std::fmt::Debug for GatewayCounterEntry { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("GatewayCounterEntry") + .field("kind", &self.kind) + .finish_non_exhaustive() + } +} + +impl std::fmt::Debug for GatewayRelativeBasis { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("GatewayRelativeBasis") + .field("private", &"[redacted]") + .finish_non_exhaustive() + } +} + +impl std::fmt::Debug for GatewayPreEntry { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("GatewayPreEntry") + .field("observations", &self.observations.len()) + .field("basis_recorded", &self.basis.is_some()) + .finish_non_exhaustive() + } +} + impl GatewayPreEntry { /// Whether nothing was read. #[must_use] @@ -291,6 +317,9 @@ pub struct GatewayAttemptSnapshot { observation_fact: Option, provider_evidence: Option, public_evidence_commitment: Option<[u8; 32]>, + public_effect_reference: [u8; 32], + public_recipe_reference: [u8; 32], + public_record_commitment: [u8; 32], pre_entry: Option, recovery_evidence: Option, } @@ -307,6 +336,18 @@ impl std::fmt::Debug for GatewayAttemptSnapshot { } impl GatewayAttemptSnapshot { + pub(crate) const fn public_effect_reference(&self) -> &[u8; 32] { + &self.public_effect_reference + } + + pub(crate) const fn public_recipe_reference(&self) -> &[u8; 32] { + &self.public_recipe_reference + } + + pub(crate) const fn public_record_commitment(&self) -> &[u8; 32] { + &self.public_record_commitment + } + pub(crate) const fn public_evidence_commitment(&self) -> Option<&[u8; 32]> { self.public_evidence_commitment.as_ref() } @@ -1145,6 +1186,9 @@ impl Record { observation_fact: self.state.observation_fact, provider_evidence, public_evidence_commitment, + public_effect_reference: self.public_commitment(b"action", &action_commitment)?, + public_recipe_reference: self.public_commitment(b"recipe", &recipe_digest)?, + public_record_commitment: self.record_commitment()?, pre_entry, recovery_evidence: self.state.recovery_evidence.clone(), }) @@ -3124,6 +3168,16 @@ impl ObservableGatewayAttempt { } } +impl Record { + fn record_commitment(&self) -> Result<[u8; 32], GatewayAttemptError> { + use zeroize::Zeroize as _; + let mut message = self.clone(); + message.nonce.zeroize(); + let bytes = Zeroizing::new(encode(&message)?); + self.public_commitment(b"journal-record", &Sha256::digest(&bytes).into()) + } +} + fn encode(record: &Record) -> Result, GatewayAttemptError> { let record = record.clone(); let wire = record.map_state(|state| Ok(state.wrap()))?; diff --git a/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs index e4fded622..c7b00a115 100644 --- a/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs +++ b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs @@ -1,7 +1,8 @@ //! Actual application interfaces; distinct UID mode additionally tests Linux DAC. use super::*; use auths_gateway::{admin, app}; -use sha2::{Digest as _, Sha256}; +use sha2::Digest as _; +use sha2::Sha256; use std::collections::BTreeSet; fn no_canaries(bytes: &[u8], secret: &[u8]) { @@ -170,6 +171,56 @@ fn probe(mut payload: Value, secret: &[u8]) -> Value { .expect("case") .remove("after_ready_b64"); value["post_ready_control_frames"] = json!(count); + if value["response"]["outcome"] == "signed" { + let response = &value["response"]; + assert_eq!(response["schema"], "auths.gateway-outcome/3"); + let bytes = Base64UrlUnpadded::decode_vec( + response["observation_b64"].as_str().expect("signature"), + ) + .expect("base64"); + no_canaries(&bytes, secret); + let signed = auths_codec::decode_signed_observation( + &bytes, + &auths_model::VerifierLimits::default(), + ) + .expect("native canonical signature"); + assert_eq!( + signed.statement().schema().as_str(), + auths_gateway::OUTCOME_SCHEMA + ); + let names: Vec<_> = signed + .statement() + .facts() + .as_slice() + .iter() + .map(|fact| fact.name().as_str()) + .collect(); + assert_eq!( + names, + [ + "effect-reference", + "evaluated-at", + "http-status", + "recipe-reference", + "record-commitment", + "stage" + ] + ); + value["response"] = json!({"outcome":"signed", "schema":auths_gateway::OUTCOME_SCHEMA, "native_canonical_public_projection_checked":true}); + } + if value["response"]["outcome"] == "pre-entry" { + let commitment = value["response"]["record_commitment"] + .as_str() + .expect("hiding commitment"); + assert_eq!(commitment.len(), 64); + assert!( + commitment + .bytes() + .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) + ); + assert!(value["response"].get("observations_b64").is_none()); + value["response"]["record_commitment"] = json!("native-hiding-value-checked"); + } } for value in result["private_cli"].as_array_mut().expect("private CLI") { for field in ["stdout_b64", "stderr_b64"] { @@ -273,6 +324,41 @@ fn run(distinct: bool) -> Value { no_canaries(&installed.stdout, &secret); no_canaries(&installed.stderr, &secret); assert!(installed.status.success(), "native install"); + success(cli( + "observer-init", + &[("--state-dir", path(&state))], + &[], + None, + )); + let configuration = checked( + &cli( + "effect-configuration-review", + &[("--state-dir", path(&state))], + &[], + None, + ), + &secret, + ); + success(cli( + "effect-configuration-activate", + &[ + ("--state-dir", path(&state)), + ( + "--expected-revision", + configuration["previous_revision_hex"] + .as_str() + .expect("configuration revision"), + ), + ( + "--expected-candidate", + configuration["candidate_hex"] + .as_str() + .expect("configuration candidate"), + ), + ], + &[], + None, + )); let arguments = root.join("resource.json"); private( &arguments, @@ -305,10 +391,98 @@ fn run(distinct: bool) -> Value { &secret, ); assert_eq!( - acquired["history"]["snapshot"]["content_projection"]["kind"], - "ready" + acquired["history"]["snapshot"]["content_projection"]["kind"], "ready", + "native acquisition result: {acquired}" ); assert_eq!(provider.calls().len(), 1); + let write_call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + json!({"operation_id":"write", "operator_namespace":recipe.namespace().as_str(), + "recipe_digest":recipe.digest_hex(), "record_id":RECORD, "replacement":"Approved"}) + .as_object() + .expect("arguments") + .clone(), + ) + .expect("mutation call"); + let write = approve(&state, &write_call, "write", now, &reviewer, &[], &[]); + assert_eq!( + checked(&write.execute("submit", &socket, &[], &[], None), &secret)["outcome"], + "response-recorded" + ); + let public_bundle = admin_directory.join("submission-bundle.json"); + private(&public_bundle, &serde_json::to_vec(&json!({"schema":auths_gateway::AUDIT_BUNDLE_SCHEMA, + "recipe_b64":Base64UrlUnpadded::encode_string(&std::fs::read(root.join("recipe")).expect("recipe")), + "profile_lock_b64":Base64UrlUnpadded::encode_string(&std::fs::read(root.join("lock")).expect("lock")), + "trusted_context_b64":Base64UrlUnpadded::encode_string(&std::fs::read(root.join("trust")).expect("trust")), + "entries":[{"operation_id":"write", "proof_b64":Base64UrlUnpadded::encode_string(&std::fs::read(&write.proof).expect("proof")), + "action_b64":Base64UrlUnpadded::encode_string(&std::fs::read(&write.action).expect("action")), "outcome_b64":null}] + })).expect("submission inventory")); + let private_audit = admin_directory.join("private-audit.json"); + let exported = cli( + "audit-export", + &[ + ("--state-dir", path(&state)), + ("--admin-socket", path(&admin_socket)), + ("--bundle", path(&public_bundle)), + ("--out", path(&private_audit)), + ], + &[], + None, + ); + checked(&exported, &secret); + assert_eq!( + std::fs::metadata(&private_audit) + .expect("private audit") + .permissions() + .mode() + & 0o777, + 0o600 + ); + let observer = checked( + &cli("observer-show", &[("--state-dir", path(&state))], &[], None), + &secret, + ); + let trust_digest = hex::encode(sha2::Sha256::digest( + std::fs::read(root.join("trust")).expect("trust"), + )); + let audited = cli( + "audit", + &[ + ("--bundle", path(&private_audit)), + ("--trusted-context-sha256", &trust_digest), + ( + "--observer", + observer["observer_anchor"]["principal"] + .as_str() + .expect("observer"), + ), + ], + &[], + None, + ); + // This operator-only report intentionally contains protected audit facts. + assert!(audited.status.success(), "operator private audit refused"); + let audited: Value = serde_json::from_slice(&audited.stdout).expect("audit report"); + assert_eq!(audited["verified"], 1); + assert_eq!(audited["inconsistent"], 0); + let repeated = cli( + "audit-export", + &[ + ("--state-dir", path(&state)), + ("--admin-socket", path(&admin_socket)), + ("--operation-id", "write"), + ("--out", path(&private_audit)), + ], + &[], + None, + ); + assert!( + !repeated.status.success(), + "private export must never overwrite an existing artifact" + ); + no_canaries(&repeated.stdout, &secret); + no_canaries(&repeated.stderr, &secret); let uid = rustix::process::geteuid().as_raw(); let target = root.join("target.json"); private( @@ -360,11 +534,11 @@ fn run(distinct: bool) -> Value { ), case( "observe-outcome", - &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"outcome","operation_id":"read"}}), + &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"outcome","operation_id":"write"}}), ), case( "observe-pre-entry", - &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"pre-entry","operation_id":"read"}}), + &json!({"schema":app::APP_OBSERVE_SCHEMA,"request":{"kind":"pre-entry","operation_id":"write"}}), ), case( "forged-ack", @@ -457,7 +631,7 @@ fn run(distinct: bool) -> Value { let payload = json!({"distinct_uid":distinct,"gateway_uid":uid,"gateway_pid":daemon.0.id(),"socket":socket,"state":state,"admin_socket":admin_socket,"provider_port":provider.port,"private_paths":private_paths(&root),"cases":calls,"admin_frames":admin_frames,"cli_commands":commands}); let first = probe(payload.clone(), &secret); assert_eq!(witness(&state, &admin_socket, &secret), before); - assert_eq!(provider.calls().len(), 1); + assert_eq!(provider.calls().len(), 2); assert_eq!(provider.denied.load(Ordering::SeqCst), 2); assert!( source_before == std::fs::read(&source_path).expect("source"), @@ -506,18 +680,19 @@ fn run(distinct: bool) -> Value { replay_payload["admin_frames"] = json!([]); replay_payload["cli_commands"] = json!([]); let replay = probe(replay_payload, &secret); - assert_eq!(provider.calls().len(), 1); + assert_eq!(provider.calls().len(), 2); assert_eq!(provider.denied.load(Ordering::SeqCst), 4); assert_eq!(witness(&state, &admin_socket, &secret), before); assert_eq!(history(&socket, "release"), acknowledged); no_canaries(&daemon.finish_logs(), &secret); json!({"schema":"auths.managed-interface-probe/1","distinct_uid":distinct, "scope":"real native daemon, fresh runtime credential, actual local HTTP, all native application schemas, all operator commands injected on the application channel and every CLI help entry", - "excluded":["hostile OS or root", "provider or production custody qualification", "all privileged CLI execution paths", "positive signed mutation outcome privacy"], - "first":first,"replay":replay,"private_source_journal_unchanged":true,"provider_authorized_calls":1, + "excluded":["hostile OS or root", "provider or production custody qualification", "all privileged CLI execution paths", "live-provider qualification"], + "first":first,"replay":replay,"private_source_journal_unchanged":true,"provider_authorized_calls":2, "direct_provider_refusals":4,"no_new_custody_or_provider_entries":true, "recipient_key_and_uid_guard_precede_content":true,"trusted_recipient_positive_control":true, - "public_channels_exclude_plaintext_encodings_and_raw_digests":true}) + "public_channels_exclude_plaintext_encodings_and_raw_digests":true, + "operator_private_export_mode":384, "operator_private_audit_verified_entries":1, "private_export_refuses_overwrite":true}) } #[test] diff --git a/product/runtime/auths-gateway/tests/managed_interface_probe.py b/product/runtime/auths-gateway/tests/managed_interface_probe.py index 4e5ec4998..1e8d96c37 100644 --- a/product/runtime/auths-gateway/tests/managed_interface_probe.py +++ b/product/runtime/auths-gateway/tests/managed_interface_probe.py @@ -117,6 +117,7 @@ def send(stream, value): ['status', '--state-dir', data['state'], '--admin-socket', data['admin_socket']], ['execution-witness', '--state-dir', data['state'], '--admin-socket', data['admin_socket']], ['readiness-probe', '--state-dir', data['state']], + ['audit-export', '--state-dir', data['state'], '--admin-socket', data['admin_socket'], '--operation-id', 'forbidden', '--out', data['state'] + '/forbidden-audit.json'], ): result = subprocess.run([data['binary']] + arguments, capture_output=True, timeout=10) assert result.returncode != 0, 'application used a private native CLI route' diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index b4ceb8b5a..862acdc90 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 426 +freeze_version = 427 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -19,7 +19,7 @@ freeze_version = 426 "auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 61 "auths.frozen-bytes/formal/qualification/aeneas/generated" = 20 "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 17 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 105 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 106 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -45,26 +45,26 @@ freeze_version = 426 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 169 +"auths.identity.protocol" = 170 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 127 +"auths.portable-abi-bindings" = 128 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 "auths.product.development-composition" = 13 "auths.product.error-recovery-contract" = 18 -"auths.product.external-custody" = 6 +"auths.product.external-custody" = 7 "auths.product.facade" = 26 "auths.product.github-issue-address-v2" = 4 "auths.product.lifecycle" = 17 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 165 +"auths.product.public-sdk-contract" = 166 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 -"auths.product.vocabulary" = 29 +"auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 -"auths.release.evolution-contract" = 83 -"auths.release.public-surface" = 426 +"auths.release.evolution-contract" = 84 +"auths.release.public-surface" = 427 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 73b57b150..41414fc2f 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 426, + "freezeVersion": 427, "publicSurface": { "rustRoots": [ "auths", @@ -238,7 +238,7 @@ }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 105, + "version": 106, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "a9a3872b798dce65bcb9e8517f3cc7016d2f0417a8d402a6affaa51c68a98160" + "sha256": "f3bac9ca9f07df2bfadb453bab0d538b455fdec197dc07ed95cab47fb0db99ee" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 169, + "version": 170, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "ff3d37b94be1b597d05269351d38541ac15f620e2e03160d04b8b7fa0d07d1d8" + "sha256": "64e2932da7ae8fd7350cb83f29a9d92818ad1e705953485915fc11218b35dae1" }, { "id": "auths.modular-components", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 127, + "version": 128, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "4a990d5571644c10c3aeaf4de8c4cc6e2aaa0fe4104feec58cbe066c3151c4e8" + "sha256": "5fc4c1adbdffc4fff4b85de1c85dedf9defb67e6509873da3a19f5e5639a3509" }, { "id": "auths.product.bounded-domains", @@ -728,7 +728,7 @@ }, { "id": "auths.product.external-custody", - "version": 6, + "version": 7, "classification": "frozen-meaning", "categories": [ "transaction-bound-signing", @@ -748,7 +748,7 @@ "product/integrations/auths-custody-pkcs11/src", "product/integrations/auths-custody/src" ], - "sha256": "db42e22edfd14fdc686044d2e0b33bb2a3bcac4f1be986d86384e01cd90beb45" + "sha256": "f6a5517e1708886dcab658a2b43acf37f053bc11e3f30e3b69af1dc580628f18" }, { "id": "auths.product.facade", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 165, + "version": 166, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "e486c1f9120125227647dc750715c9203a7db3610ad2b193099a70eec0eaefdb" + "sha256": "79808494f670c200965d763898a3557f830d0b3aa9561dbf5b0f42457707cab9" }, { "id": "auths.product.receipts", @@ -947,7 +947,7 @@ }, { "id": "auths.product.vocabulary", - "version": 29, + "version": 30, "classification": "frozen-meaning", "categories": [ "customer-vocabulary", @@ -965,7 +965,7 @@ "product/sdk/auths-sdk/Cargo.toml", "xtask/src/sdk_vocabulary.rs" ], - "sha256": "29800f15631e40abde0ca107543eec3be23d40f693e36ec388fe9e109d40325c" + "sha256": "a7191aeda4afd67e32cb877ebb3e3fea09d77c93c92a5bf12af2ce50636d767c" }, { "id": "auths.release.benchmark-contract", @@ -986,7 +986,7 @@ }, { "id": "auths.release.evolution-contract", - "version": 83, + "version": 84, "classification": "frozen-meaning", "categories": [ "version-axes", @@ -1007,11 +1007,11 @@ "release/fixtures/evolution", "xtask/src/evolution_policy.rs" ], - "sha256": "567cd42cc4ab9e7e392afff8480ccb08a5f37f99f80851401a1512b8b52dcbbf" + "sha256": "0a1cfb099edab1797a2a813321ac4aa1025aeaa141d4dbb150b46670432b1a35" }, { "id": "auths.release.public-surface", - "version": 426, + "version": 427, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "4880ecf3d1ab628844824ea9e532794d0e2915630017ee3cabf37f7b6bd10195" + "sha256": "1436aa97a500fe5e9a644c4efa29b41f9322023b230a08cb70ebaca24dc17654" } ] } diff --git a/xtask/src/fuzz.rs b/xtask/src/fuzz.rs index 769895fc4..2923a53e4 100644 --- a/xtask/src/fuzz.rs +++ b/xtask/src/fuzz.rs @@ -814,12 +814,12 @@ fn gateway_seeds(kind: GatewaySeeds) -> Result>, String> { } } GatewaySeeds::Attempt => { - for name in ["attempt-scenarios-v3.json", "outcome-v2.json", "codes.json"] { + for name in ["attempt-scenarios-v3.json", "outcome-v3.json", "codes.json"] { seeds.push(read_gateway_fixture(name)?); } } GatewaySeeds::Outcome | GatewaySeeds::AppFrame => { - let vectors = gateway_fixture_json("outcome-v2.json")?; + let vectors = gateway_fixture_json("outcome-v3.json")?; let entries = ["accepted", "refused"] .iter() .filter_map(|list| vectors[*list].as_array()) @@ -842,7 +842,7 @@ fn gateway_seeds(kind: GatewaySeeds) -> Result>, String> { for kind in ["outcome", "pre-entry"] { seeds.push( serde_json::json!({ - "schema": "auths.gateway-observe/3", + "schema": "auths.gateway-observe/4", "request": {"kind": kind, "operation_id": operation}, }) .to_string() From 6c93e933d1d133a850eb40c2ec6cc6f7db913ddf Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:29:01 +0900 Subject: [PATCH 120/136] test(gateway): measure native path and recovery inventory costs --- .github/workflows/postgres-lifecycle.yml | 17 + docs/plans/0074-implementation-status.md | 27 + docs/plans/0074-native-cost-evidence.md | 62 +++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/native_cost_store.rs | 191 +++++++ .../auths-gateway/src/native_cost_tests.rs | 475 ++++++++++++++++++ .../src/native_recovery_actor_tests.rs | 2 + .../auths-gateway/src/semantic_closure.rs | 2 +- 8 files changed, 776 insertions(+), 2 deletions(-) create mode 100644 docs/plans/0074-native-cost-evidence.md create mode 100644 product/runtime/auths-gateway/src/native_cost_store.rs create mode 100644 product/runtime/auths-gateway/src/native_cost_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index b393ab507..119ef4e0e 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -100,6 +100,23 @@ jobs: cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::privacy_tests::postgres_native_public_mutation_evidence_fixture_is_current cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres } 2>&1 | tee target/ap074-native-adapter-evidence.log + - name: Measure native managed paths and bounded recovery inventory + env: + AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require + AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt + AUTHS_POSTGRES_SERVER_NAME: localhost + AUTHS_AP074_COST_DIRECTORY: target/ap074-native-cost + AUTHS_EVIDENCE_SOURCE_REVISION: ${{ github.event.pull_request.head.sha || github.sha }} + run: | + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::cost_tests::native_file_cost_measurements + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::cost_tests::postgres_native_cost_measurements + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + if: always() + with: + name: ap074-native-cost-${{ github.run_id }}-${{ github.run_attempt }} + path: target/ap074-native-cost/ + if-no-files-found: error + retention-days: 30 - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 with: python-version: "3.12" diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 245b8472f..8510716bd 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3841,3 +3841,30 @@ or deployment claim is made by AP074 source work. checked-state flags. A recursive public-artifact scan checks raw, hex and base64 provider/body-derived digests against retained private evidence. These final Python changes await hosted execution. + +## Native bounded-cost evidence producer — 5 November 2026 + +Added a test-only pass-through measurement cohort over the maintained file and +TLS PostgreSQL adapters. Each backend executes eight real native mutation, +independent recovery, acquisition and authenticated disclosure/ACK operations. +The harness measures native verification against installed trust, compilation, +exact approval verification, execution, every actual adapter call and native +fenced callback, buffer sizes and increasing native inventory/decode costs. +It asserts real HTTP/recipient counts, outcomes and existing per-buffer/fence +limits. Linux RSS observations are process-wide; adapter elapsed includes waiting +and I/O and is only an upper bound on the lock-held interval. No shipping decision, +retry, storage acknowledgement or security deadline changes. + +The PostgreSQL workflow preserves the 48-selector differential evidence log and +adds a separate two-selector cost step/artifact containing exact source and +checkout revisions plus source closure. Full measurement scope and limitations +are in [the native cost evidence plan](0074-native-cost-evidence.md). Actual cost +runs await hosted CI; no performance result or completed P4 gate is claimed. + +Required source-closure construction passed (1 passed / 0 ignored, 0.08 s) and +its rebuilt non-update check passed (1 passed / 0 ignored, 0.07 s). Final closure +is `0581155d4d8b1b9ebb10fa4cd294e7f72e7440ba6482d30d45ae6ed38eef496e`. +The semantic metadata constructor passed with no release identity changes: +this batch changes testkit/evidence sources rather than the public contract. +No local benchmark, broad suite, lint, formal or CI inspection was performed by +main. CI publication and holistic repairs remain with the existing subagent. diff --git a/docs/plans/0074-native-cost-evidence.md b/docs/plans/0074-native-cost-evidence.md new file mode 100644 index 000000000..711c6665e --- /dev/null +++ b/docs/plans/0074-native-cost-evidence.md @@ -0,0 +1,62 @@ +# AP074 native cost evidence + +AP074 §11 requires measurements as well as finite work bounds. The native test +cohort in `native_recovery_actor_tests::cost_tests` executes eight separately +authorized operations per path on each maintained adapter. Its four paths are +Airtable mutation with a lost response, independently authorized linked recovery, +bounded content acquisition, and separately approved authenticated disclosure +with a real recipient ACK. It uses actual local HTTP and Unix transport and +checks external call counts, received bytes and recorded native outcomes. + +The PostgreSQL lifecycle workflow runs both exact selectors after the existing +adapter histories and uploads `ap074-native-cost--`. It preserves +the original 48-selector differential log. The artifact contains +`native-cost-file.json` and `native-cost-postgres.json`, each with the exact PR +source revision, checkout revision and native semantic source closure. This is +an additional evidence producer; existing fault, differential and formal gates +remain required. + +Each sample records: + +- Native verification time against the engine's actual installed trust context. +- Native installed compilation time, including its own verification and durable + configuration reads; it is not a subtraction-based compiler estimate. +- Exact approval verification time, followed by ordinary runtime execution that + independently repeats its required admission and final-entry validation. +- Every pass-through adapter call's elapsed time, input/output byte counts and + successful/error result. Each real fenced callback also records decision time, + number of snapshot records and aggregate snapshot bytes. Instrumentation + forwards the original callback, bytes, result and durability acknowledgement; + it does not choose authority, re-run a decision or add a retry. +- Proof, action, context, binding, review and approval byte sizes. Actual binding, + review, approval and fenced snapshot bounds are asserted against native + constants. Only sizes and timings are exported; private bytes stay private. +- Linux process RSS and cumulative high-water RSS when available. These include + the test runtime, native engine and local provider task. They are not allocator + accounting or an independent peak allocation for each path. +- Native inventory enumeration **and record decoding** over increasing real + retained histories: 3–17 mutation/recovery attempts and 2–16 acquisition/release + attempts, with the production 4,096-entry inventory limit. + +Adapter elapsed time includes lock/pool waiting, reads, callback, persistence and +unlock. It is a measured conservative upper bound on the lock-held interval, +not an isolated lock-hold measurement. The callback time measures native work +while the real adapter holds its writer fence. No network/provider or custody +operation runs inside that callback. Filesystem blocking and database server +scheduling remain operating-system/deployment assumptions. + +The source bounds remain: 262,144 bytes per opaque record, 64 records per batch +or fence, two-second lock wait and fence deadlines, at most eight crash-batch +recovery rounds, 16,384 scanned file directory entries and 4,096 retained +inventory keys. A file recovery batch is bounded by +`MAX_GATEWAY_RECORD_BYTES * 2 * MAX_GATEWAY_BATCH_ENTRIES` encoded bytes. +These bound particular owned buffers/work units; they do not claim a total +process heap cap. Native proof/action/context bounds and each recipe's response +and content ceilings remain separately enforced. + +Eight small test-profile samples characterize these representative paths, not +production p95 latency, maximum-population scan cost or worst-case heap usage. +The raw distribution must remain available; no latency optimization may weaken +native dependency verification, fresh fence validation or durability. Exact-head +hosted execution and its actual measured values are still pending. These source +changes alone close no acceptance row and do not establish complete P4 closure. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index a08c92b3e..73b40cca3 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8887edd3f6eddcd549e2d41ea06072ef30cc34d535f3f4e40fe146682c15f1ce"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"567ecc2aac4de572b9f14eeb240a255cd6432e9bc263bb8fd3ac1e0bec7a5e76"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"0013fbd927257a38b82f903d963ba81fe6137df5aea7a1c9761f977b66d6c01c"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8887edd3f6eddcd549e2d41ea06072ef30cc34d535f3f4e40fe146682c15f1ce"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"567ecc2aac4de572b9f14eeb240a255cd6432e9bc263bb8fd3ac1e0bec7a5e76"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_cost_store.rs b/product/runtime/auths-gateway/src/native_cost_store.rs new file mode 100644 index 000000000..9e07783fd --- /dev/null +++ b/product/runtime/auths-gateway/src/native_cost_store.rs @@ -0,0 +1,191 @@ +//! Test-only pass-through timing at the real adapter boundary. No decision, +//! bytes, acknowledgement, retry or runtime deadline is changed. +use crate::store::GatewayFenceDecision; +use crate::{ + GatewayAttemptError, GatewayAttemptKey, GatewayAttemptStore, GatewayInsert, GatewayRecordEntry, + GatewayRecordKind, +}; +use serde::Serialize; +use std::{ + sync::{Arc, Mutex}, + time::Instant, +}; + +#[derive(Default, Serialize)] +pub(super) struct AdapterCosts { + pub(super) calls: Vec, +} + +#[derive(Serialize)] +pub(super) struct Call { + operation: &'static str, + /// Includes wait, load, decision, persistence and unlock. This is a + /// conservative observed upper bound, never an isolated lock-hold time. + adapter_elapsed_ns: u64, + decision_elapsed_ns: Option, + snapshot_bytes: usize, + snapshot_records: usize, + input_bytes: usize, + output_bytes: usize, + succeeded: bool, +} + +pub(super) struct MeteredStore { + pub(super) inner: Arc, + pub(super) costs: Arc>, +} + +pub(super) fn nanos(started: Instant) -> u64 { + u64::try_from(started.elapsed().as_nanos()).expect("bounded measurement") +} + +impl MeteredStore { + fn call( + &self, + operation: &'static str, + input_bytes: usize, + work: impl FnOnce() -> Result, + output_size: impl FnOnce(&T) -> usize, + ) -> Result { + let started = Instant::now(); + let result = work(); + let elapsed = nanos(started); + let output_bytes = result.as_ref().map_or(0, output_size); + self.costs.lock().expect("cost recorder").calls.push(Call { + operation, + adapter_elapsed_ns: elapsed, + decision_elapsed_ns: None, + snapshot_bytes: 0, + snapshot_records: 0, + input_bytes, + output_bytes, + succeeded: result.is_ok(), + }); + result + } + + fn fenced( + &self, + operation: &'static str, + input_bytes: usize, + decide: &mut GatewayFenceDecision<'_>, + work: impl FnOnce(&mut GatewayFenceDecision<'_>) -> Result, + ) -> Result { + let mut decision_elapsed_ns = None; + let mut snapshot_bytes = 0; + let mut snapshot_records = 0; + let mut output_bytes = 0; + let started = Instant::now(); + let result = work(&mut |snapshot| { + assert!(decision_elapsed_ns.is_none(), "adapter calls decision once"); + snapshot_records = snapshot.len(); + snapshot_bytes = snapshot.iter().flatten().map(Vec::len).sum(); + assert!(snapshot_records <= auths_stores::MAX_GATEWAY_FENCE_RECORDS); + assert!( + snapshot + .iter() + .flatten() + .all(|bytes| bytes.len() <= auths_stores::MAX_GATEWAY_RECORD_BYTES) + ); + let decision_started = Instant::now(); + let result = decide(snapshot); + decision_elapsed_ns = Some(nanos(decision_started)); + output_bytes = result.as_ref().map_or(0, Vec::len); + result + }); + let elapsed = nanos(started); + self.costs.lock().expect("cost recorder").calls.push(Call { + operation, + adapter_elapsed_ns: elapsed, + decision_elapsed_ns, + snapshot_bytes, + snapshot_records, + input_bytes, + output_bytes, + succeeded: result.is_ok(), + }); + result + } +} + +impl GatewayAttemptStore for MeteredStore { + fn fenced_insert_all( + &self, + entries: &[GatewayRecordEntry], + dependencies: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result { + self.fenced( + "fenced-insert", + entries.iter().map(|entry| entry.record.len()).sum(), + decide, + |decision| { + self.inner + .fenced_insert_all(entries, dependencies, decision) + }, + ) + } + + fn fenced_replace( + &self, + keys: &[(GatewayRecordKind, GatewayAttemptKey)], + decide: &mut GatewayFenceDecision<'_>, + ) -> Result<(), GatewayAttemptError> { + self.fenced("fenced-replace", 0, decide, |decision| { + self.inner.fenced_replace(keys, decision) + }) + } + + fn insert_all( + &self, + entries: &[GatewayRecordEntry], + ) -> Result { + self.call( + "insert", + entries.iter().map(|entry| entry.record.len()).sum(), + || self.inner.insert_all(entries), + |_| 0, + ) + } + + fn load( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + ) -> Result>, GatewayAttemptError> { + self.call( + "load", + 0, + || self.inner.load(kind, key), + |value| value.as_ref().map_or(0, Vec::len), + ) + } + + fn replace( + &self, + kind: GatewayRecordKind, + key: &GatewayAttemptKey, + current: &[u8], + next: &[u8], + ) -> Result<(), GatewayAttemptError> { + self.call( + "replace", + current.len() + next.len(), + || self.inner.replace(kind, key, current, next), + |_| 0, + ) + } + + fn sweep_expired(&self, now: u64, limit: usize) -> Result { + self.call("sweep", 0, || self.inner.sweep_expired(now, limit), |_| 0) + } + + fn attempt_keys(&self, limit: usize) -> Result, GatewayAttemptError> { + self.call( + "inventory", + 0, + || self.inner.attempt_keys(limit), + |keys| keys.len() * size_of::(), + ) + } +} diff --git a/product/runtime/auths-gateway/src/native_cost_tests.rs b/product/runtime/auths-gateway/src/native_cost_tests.rs new file mode 100644 index 000000000..0b53ddba5 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_cost_tests.rs @@ -0,0 +1,475 @@ +//! Measured native paths over the maintained adapters and real local HTTP/Unix +//! transport. Timings are observations, not release SLOs or durability proofs. +use super::{Case, Outcome, ReadResponse, author, controls}; +use crate::effect::{BoundEffect, EffectBinding, ExactEffectApproval, UnixDisclosurePolicy}; +use crate::harness::authoring::{ToolFixture, tool_fixture_until, tools_context}; +use crate::native_process_tests::{ + CONTENT, EngineControls, NOW, Provider, Setup, load_controlled_engine, runtime, +}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{GatewayAttempts, GatewaySubmitResult, SharedConnection}; +use auths_profile_mcp::McpToolCall; +use ed25519_dalek::SigningKey; +use serde_json::{Value, json}; +use std::{ + future::Future, + os::unix::fs::{MetadataExt as _, PermissionsExt as _}, + sync::{Arc, Mutex, atomic::Ordering}, + time::Instant, +}; + +#[path = "native_cost_store.rs"] +mod meter; +use meter::{AdapterCosts, MeteredStore, nanos}; + +const SAMPLES: usize = 8; + +fn metered(store: &TestAttempts) -> (GatewayAttempts, Arc>) { + let costs = Arc::new(Mutex::new(AdapterCosts::default())); + let attempts = GatewayAttempts::new( + Arc::new(MeteredStore { + inner: store.raw(), + costs: Arc::clone(&costs), + }), + crate::effect::fixture_policy().expect("policy"), + ) + .expect("native attempts"); + (attempts, costs) +} + +fn take(costs: &Mutex) -> AdapterCosts { + std::mem::take(&mut *costs.lock().expect("cost recorder")) +} + +async fn prepare( + signed: &ToolFixture, + installed_trust: &[u8], + now: u64, + compilation: impl Future>, + costs: &Mutex, +) -> (EffectBinding, ExactEffectApproval, Value) { + take(costs); + let context = auths_codec::decode_verifier_context(installed_trust).expect("installed trust"); + let started = Instant::now(); + crate::engine::verify_native(&context, now, &signed.proof, &signed.action) + .expect("real native verification"); + let verification_ns = nanos(started); + let started = Instant::now(); + let effect = compilation.await.expect("native compilation"); + let compilation_ns = nanos(started); + let binding = effect.binding().clone(); + let binding_bytes = binding.to_private_bytes().expect("private binding").len(); + let review_bytes = effect + .private_review() + .expect("review") + .to_private_bytes() + .expect("review encoding") + .len(); + let approval = author::approval(&effect, now); + let approval_bytes = approval.to_private_bytes().expect("approval bytes").len(); + assert!(binding_bytes <= crate::effect::MAX_EFFECT_BYTES); + assert!(review_bytes <= crate::effect::MAX_PRIVATE_EFFECT_REVIEW_BYTES); + assert!(approval_bytes <= crate::effect::MAX_EFFECT_APPROVAL_BYTES); + let started = Instant::now(); + effect + .approve( + approval.clone(), + crate::effect::fixture_policy().expect("policy").approver(), + now, + ) + .expect("exact approval verification"); + let approval_ns = nanos(started); + let result = json!({ + "verification_ns":verification_ns, "compilation_including_verification_ns":compilation_ns, + "approval_verification_ns":approval_ns, "proof_bytes":signed.proof.len(), + "action_bytes":signed.action.len(), "context_bytes":installed_trust.len(), + "binding_bytes":binding_bytes, "private_review_bytes":review_bytes, + "approval_bytes":approval_bytes, "compilation_adapter":take(costs), + }); + (binding, approval, result) +} + +fn executed(sample: &mut Value, started: Instant, costs: &Mutex) { + sample["execution_ns"] = json!(nanos(started)); + sample["execution_adapter"] = serde_json::to_value(take(costs)).expect("timings"); + sample["process_memory"] = process_memory(); + let calls = sample["execution_adapter"]["calls"] + .as_array() + .expect("actual adapter calls"); + assert!( + calls + .iter() + .any(|call| call["operation"] == "fenced-insert") + ); + assert!( + calls + .iter() + .any(|call| call["operation"] == "fenced-replace") + ); + let decisions: Vec<_> = calls + .iter() + .filter_map(|call| call["decision_elapsed_ns"].as_u64()) + .collect(); + assert!( + decisions.len() >= 2, + "actual admission and final-entry decisions" + ); + assert!(decisions.iter().all(|ns| *ns > 0)); + assert!( + calls + .iter() + .all(|call| call["snapshot_records"].as_u64().expect("count") + <= auths_stores::MAX_GATEWAY_FENCE_RECORDS as u64) + ); +} + +/// Linux process observations include the test runtime and provider task. They +/// are not allocator accounting or an independent peak for each path. +fn process_memory() -> Value { + let Ok(status) = std::fs::read_to_string("/proc/self/status") else { + return json!({"source":"unavailable","rss_kib":null,"cohort_peak_rss_kib":null}); + }; + let kib = |name: &str| { + status.lines().find_map(|line| { + line.strip_prefix(name)? + .split_whitespace() + .next()? + .parse::() + .ok() + }) + }; + json!({"source":"linux-proc-self-status","rss_kib":kib("VmRSS:"), + "cohort_peak_rss_kib":kib("VmHWM:")}) +} + +async fn scan(attempts: &GatewayAttempts, costs: &Mutex, expected: usize) -> Value { + take(costs); + let started = Instant::now(); + let stages = attempts + .stages(4096) + .await + .expect("bounded native inventory decode"); + let elapsed = nanos(started); + assert_eq!(stages.len(), expected); + json!({"attempts":stages.len(),"limit":4096,"inventory_and_native_decode_ns":elapsed, + "adapter":take(costs),"process_memory":process_memory()}) +} + +#[allow( + clippy::too_many_lines, + reason = "one measured native write/read cohort retains its real transport counters" +)] +fn mutation_and_recovery(backend: Backend) -> (Vec, Vec, Vec) { + let case = Case::start(backend, Outcome::LostEcho); + let runtime = runtime(); + let (attempts, costs) = metered(&case.store); + let (writer, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "cost-writer", + attempts.clone(), + controls(false), + )); + let mut mutations = Vec::new(); + let mut recoveries = Vec::new(); + let mut scans = Vec::new(); + for index in 0..SAMPLES { + writer + .activate_effect_configuration( + writer.effect_configuration_revision().expect("revision"), + ) + .expect("writer configuration"); + let operation = format!("cost-write-{index}"); + let signed = author::signed(&author::write_call(&operation), false); + let (_, approval, mut measurement) = runtime.block_on(prepare( + &signed, + &author::trust(true), + NOW, + writer.compile_effect(&signed.proof, &signed.action), + &costs, + )); + let started = Instant::now(); + assert_eq!( + runtime.block_on(writer.submit(&signed.proof, &signed.action, approval)), + GatewaySubmitResult::Unknown + ); + executed(&mut measurement, started, &costs); + mutations.push(measurement); + let body = case + .provider + .requests + .lock() + .expect("request capture") + .last() + .expect("actual mutation request") + .body + .clone(); + *case.provider.read_response.lock().expect("response") = Some(ReadResponse { + status: 200, + declared_length: body.len(), + body, + }); + let (reader, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + &format!("cost-reader-{index}"), + attempts.clone(), + controls(true), + )); + reader + .activate_effect_configuration( + reader.effect_configuration_revision().expect("revision"), + ) + .expect("independent reader configuration"); + let read = format!("cost-recovery-{index}"); + let call = runtime + .block_on(reader.recovery_authorization_call(&operation, &read)) + .expect("native bounded recovery call"); + let signed = author::signed(&call, true); + let (_, approval, mut measurement) = runtime.block_on(prepare( + &signed, + &author::trust(false), + NOW + 1, + reader.compile_recovery_effect(&operation, &signed.proof, &signed.action), + &costs, + )); + let started = Instant::now(); + let recovered = runtime + .block_on(Box::pin(reader.recover( + &operation, + &signed.proof, + &signed.action, + approval, + ))) + .expect("independently authorized read"); + assert_eq!( + recovered.source.stage(), + crate::GatewayAttemptStage::ObservedByProvider + ); + executed(&mut measurement, started, &costs); + recoveries.push(measurement); + scans.push(runtime.block_on(scan(&attempts, &costs, 1 + 2 * (index + 1)))); + } + let requests = case + .provider + .requests + .lock() + .expect("real provider counter"); + assert_eq!( + requests + .iter() + .filter(|request| request.line.starts_with("PATCH ")) + .count(), + SAMPLES + 1 + ); + assert_eq!( + requests + .iter() + .filter(|request| request.line.starts_with("GET ")) + .count(), + SAMPLES + ); + (mutations, recoveries, scans) +} + +#[allow( + clippy::too_many_lines, + reason = "one measured acquisition/recipient cohort retains exact native ACK and HTTP counters" +)] +fn content_and_disclosure(backend: Backend) -> (Vec, Vec, Vec) { + let directory = tempfile::tempdir().expect("owned directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::controlled(None); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }; + let recipe = crate::native_process_tests::recipe(); + let calls = [ + crate::effect::CONTENT_READ_TOOL, + crate::effect::DISCLOSURE_TOOL, + ] + .map(|tool| { + McpToolCall::new(recipe.review().service(), tool, serde_json::Map::new()).expect("tool") + }); + let mut controls = EngineControls::baseline(); + let installed_trust = tools_context(&calls, NOW).expect("native trust"); + controls.trust = Some(installed_trust.clone()); + let (attempts, costs) = metered(&store); + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "cost-content", + attempts.clone(), + controls, + )); + runtime + .block_on( + SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ) + .insert(&connection), + ) + .expect("connection"); + engine + .initialize_effect_configuration() + .expect("configuration"); + let uid = std::fs::metadata(&setup.root).expect("owner").uid(); + let channel = UnixDisclosurePolicy::new(uid, uid, [57; 32]); + let recipient = SigningKey::from_bytes(&[47; 32]); + let mut acquisitions = Vec::new(); + let mut disclosures = Vec::new(); + let mut scans = Vec::new(); + for index in 0..SAMPLES { + let source = format!("cost-acquire-{index}"); + let call = runtime + .block_on( + engine.content_authorization_call(br#"{"record_id":"recTEST0000000001"}"#, &source), + ) + .expect("native content call"); + let signed = tool_fixture_until(&call, NOW, NOW + 3600).expect("native signed authority"); + let (_, approval, mut measurement) = runtime.block_on(prepare( + &signed, + &installed_trust, + NOW, + engine.compile_content_action(&signed.proof, &signed.action), + &costs, + )); + let started = Instant::now(); + let snapshot = runtime + .block_on(engine.acquire_content_action(&signed.proof, &signed.action, approval)) + .expect("real bounded HTTP acquisition"); + assert_eq!(snapshot.stage, crate::AcquisitionStage::ResponseRecorded); + executed(&mut measurement, started, &costs); + acquisitions.push(measurement); + let target = runtime + .block_on(engine.disclosure_target( + &source, + recipient.verifying_key().to_bytes(), + channel.commitment().expect("channel"), + [u8::try_from(index + 1).expect("bounded instance"); 32], + )) + .expect("retained source"); + let call = target + .authorization_call( + &recipe, + &crate::LogicalOperationId::parse(&format!("cost-release-{index}")) + .expect("operation"), + ) + .expect("separate disclosure call"); + let signed = + tool_fixture_until(&call, NOW, NOW + 3600).expect("native disclosure authority"); + let (binding, approval, mut measurement) = runtime.block_on(prepare( + &signed, + &installed_trust, + NOW, + engine.compile_disclosure_effect(&target, &signed.proof, &signed.action), + &costs, + )); + let started = Instant::now(); + let (delivered, received) = runtime.block_on(async { + let (server, client) = tokio::net::UnixStream::pair().expect("real local channel"); + let receiver = async { + let received = crate::disclosure_transport::receive_disclosure( + crate::disclosure_transport::DisclosureConnection::new(client, channel.clone()), + &binding, + CONTENT.len() as u64, + &recipient, + ) + .await + .expect("authenticated recipient"); + assert_eq!(received.content(), CONTENT); + received + .acknowledge(&recipient) + .await + .expect("exact native ACK"); + CONTENT.len() + }; + tokio::join!( + engine.disclose( + &target, + &signed.proof, + &signed.action, + approval, + crate::disclosure_transport::DisclosureConnection::new(server, channel.clone()) + ), + receiver + ) + }); + assert_eq!( + delivered.expect("native disclosure").stage, + crate::DisclosureStage::Acknowledged + ); + assert_eq!(received, CONTENT.len()); + executed(&mut measurement, started, &costs); + disclosures.push(measurement); + scans.push(runtime.block_on(scan(&attempts, &costs, 2 * (index + 1)))); + } + assert_eq!(provider.calls.load(Ordering::SeqCst), SAMPLES); + (acquisitions, disclosures, scans) +} + +fn run(backend: Backend) { + let (mutation, recovery, mutation_scans) = mutation_and_recovery(backend); + let (acquisition, disclosure, information_scans) = content_and_disclosure(backend); + let revision = std::process::Command::new("git") + .args(["rev-parse", "HEAD"]) + .current_dir(env!("CARGO_MANIFEST_DIR")) + .output() + .expect("source revision"); + assert!(revision.status.success()); + let checkout_revision = String::from_utf8(revision.stdout).expect("revision"); + let source_revision = std::env::var("AUTHS_EVIDENCE_SOURCE_REVISION") + .unwrap_or_else(|_| checkout_revision.trim().to_owned()); + assert!( + source_revision.len() == 40 && source_revision.bytes().all(|byte| byte.is_ascii_hexdigit()), + "exact source revision" + ); + let report = json!({ + "schema":"auths.ap074-native-cost/1", "source_revision":source_revision, + "checkout_revision":checkout_revision.trim(), + "gateway_source_closure":crate::semantic_closure::GATEWAY_SEMANTIC_CLOSURE_SHA256, + "backend":backend.label(), "samples_per_path":SAMPLES, + "build":"test-profile; no release latency claim", "clock":"std-monotonic-instant", + "paths":{"mutation":mutation,"recovery":recovery,"acquisition":acquisition,"disclosure":disclosure}, + "scans":{"mutation_recovery":mutation_scans,"acquisition_disclosure":information_scans}, + "enforced_bounds":{"record_bytes":auths_stores::MAX_GATEWAY_RECORD_BYTES, + "fence_records":auths_stores::MAX_GATEWAY_FENCE_RECORDS, + "batch_records":auths_stores::MAX_GATEWAY_BATCH_ENTRIES, + "lock_wait_ms":auths_stores::GATEWAY_LOCK_TIMEOUT.as_millis(), + "fence_deadline_ms":auths_stores::GATEWAY_FENCE_DEADLINE.as_millis(), + "inventory_limit":4096}, + "limitations":["eight small local-fixture samples per path; no production latency SLO", + "adapter elapsed includes waits and I/O; an upper bound on lock holding, not exact lock duration", + "fenced decision timing includes native validation and encoding; no provider or custody I/O", + "buffer sizes are boundary observations, not allocator accounting", + "Linux RSS and cumulative high-water observations include the entire test process", + "no power-loss, hostile OS or live-provider qualification"] + }); + if let Some(directory) = std::env::var_os("AUTHS_AP074_COST_DIRECTORY") { + let directory = std::path::PathBuf::from(directory); + std::fs::create_dir_all(&directory).expect("cost artifact directory"); + std::fs::write( + directory.join(format!("native-cost-{}.json", backend.label())), + serde_json::to_vec_pretty(&report).expect("cost artifact"), + ) + .expect("write artifact"); + } +} + +#[test] +fn native_file_cost_measurements() { + run(Backend::File); +} + +#[test] +#[ignore = "requires the maintained TLS PostgreSQL fixture"] +fn postgres_native_cost_measurements() { + assert!(postgres_configured(), "TLS PostgreSQL fixture is required"); + run(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index 74014ea88..2bb82e326 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -37,6 +37,8 @@ mod history_tests; mod limits_tests; #[path = "native_public_evidence_tests.rs"] mod privacy_tests; +#[path = "native_cost_tests.rs"] +mod cost_tests; #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index a56f46164..fa4a454b5 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "899847a8307da6574f1b83a8fa9d85e9d4d54fa4f94c2952f696dafacb2e8a07"; + "0581155d4d8b1b9ebb10fa4cd294e7f72e7440ba6482d30d45ae6ed38eef496e"; #[cfg(test)] mod tests { From 49cfcec4154ac7b0b0f72a23fb52f059d86c488e Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:39:43 +0900 Subject: [PATCH 121/136] fix(gateway): align all public result decoder boundaries --- .../native-public-mutation-evidence-file.json | 797 ++++++++++++++++++ ...ive-public-mutation-evidence-postgres.json | 797 ++++++++++++++++++ bindings/python/python/auths/gateway.py | 2 +- bindings/python/tests/test_gateway_client.py | 14 + .../test/unit/gateway-client.test.js | 13 + docs/plans/0074-implementation-status.md | 31 + ...ound-effects-and-recovery-state-machine.md | 8 + .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/engine.rs | 55 +- .../src/native_public_evidence_tests.rs | 5 +- .../src/native_result_wire_cases.rs | 200 +++++ .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 6 +- release/semantic-freeze.json | 10 +- 14 files changed, 1925 insertions(+), 17 deletions(-) create mode 100644 product/runtime/auths-gateway/src/native_result_wire_cases.rs diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-file.json b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json index 0f9674845..5933a78ec 100644 --- a/bindings/fixtures/gateway/native-public-mutation-evidence-file.json +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-file.json @@ -92,6 +92,803 @@ "accepted": false } ], + "result_wire_cases": [ + { + "case": "denied-valid", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": true + }, + { + "case": "denied-missing-outcome", + "response": "{\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-duplicate-outcome", + "response": "{\"outcome\":\"denied\",\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-missing-code", + "response": "{\"outcome\":\"denied\"}", + "accepted": false + }, + { + "case": "denied-duplicate-code", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-unknown-field", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "denied-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"denied\",\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-bom", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "indeterminate-valid", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": true + }, + { + "case": "indeterminate-missing-outcome", + "response": "{\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-duplicate-outcome", + "response": "{\"outcome\":\"indeterminate\",\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-missing-code", + "response": "{\"outcome\":\"indeterminate\"}", + "accepted": false + }, + { + "case": "indeterminate-duplicate-code", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-unknown-field", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "indeterminate-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"indeterminate\",\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-bom", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "not-entered-valid", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": true + }, + { + "case": "not-entered-missing-outcome", + "response": "{\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-duplicate-outcome", + "response": "{\"outcome\":\"not-entered\",\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-missing-code", + "response": "{\"outcome\":\"not-entered\"}", + "accepted": false + }, + { + "case": "not-entered-duplicate-code", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-unknown-field", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "not-entered-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"not-entered\",\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-bom", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "reserved-valid", + "response": "{\"outcome\":\"reserved\",\"revision\":1}", + "accepted": true + }, + { + "case": "reserved-missing-outcome", + "response": "{\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-duplicate-outcome", + "response": "{\"outcome\":\"reserved\",\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-missing-revision", + "response": "{\"outcome\":\"reserved\"}", + "accepted": false + }, + { + "case": "reserved-duplicate-revision", + "response": "{\"outcome\":\"reserved\",\"revision\":1,\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-unknown-field", + "response": "{\"outcome\":\"reserved\",\"revision\":1,\"provider_success\":true}", + "accepted": false + }, + { + "case": "reserved-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"reserved\",\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-bom", + "response": "{\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "unknown-valid", + "response": "{\"outcome\":\"unknown\"}", + "accepted": true + }, + { + "case": "unknown-missing-outcome", + "response": "{}", + "accepted": false + }, + { + "case": "unknown-duplicate-outcome", + "response": "{\"outcome\":\"unknown\",\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "unknown-unknown-field", + "response": "{\"outcome\":\"unknown\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "unknown-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"unknown\",\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "unknown-bom", + "response": "{\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "response-recorded-valid", + "response": "{\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": true + }, + { + "case": "response-recorded-missing-outcome", + "response": "{\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-duplicate-outcome", + "response": "{\"outcome\":\"response-recorded\",\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-missing-status", + "response": "{\"outcome\":\"response-recorded\"}", + "accepted": false + }, + { + "case": "response-recorded-duplicate-status", + "response": "{\"outcome\":\"response-recorded\",\"status\":200,\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-unknown-field", + "response": "{\"outcome\":\"response-recorded\",\"status\":200,\"provider_success\":true}", + "accepted": false + }, + { + "case": "response-recorded-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"response-recorded\",\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-bom", + "response": "{\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-status-minimum", + "response": "{\"outcome\":\"response-recorded\",\"status\":100}", + "accepted": true + }, + { + "case": "response-recorded-status-maximum", + "response": "{\"outcome\":\"response-recorded\",\"status\":599}", + "accepted": true + }, + { + "case": "response-recorded-status-below", + "response": "{\"outcome\":\"response-recorded\",\"status\":99}", + "accepted": false + }, + { + "case": "response-recorded-status-above", + "response": "{\"outcome\":\"response-recorded\",\"status\":600}", + "accepted": false + }, + { + "case": "response-recorded-status-u16-maximum", + "response": "{\"outcome\":\"response-recorded\",\"status\":65535}", + "accepted": false + }, + { + "case": "response-recorded-status-negative", + "response": "{\"outcome\":\"response-recorded\",\"status\":-1}", + "accepted": false + }, + { + "case": "response-recorded-status-boolean", + "response": "{\"outcome\":\"response-recorded\",\"status\":true}", + "accepted": false + }, + { + "case": "response-recorded-status-string", + "response": "{\"outcome\":\"response-recorded\",\"status\":\"200\"}", + "accepted": false + }, + { + "case": "response-recorded-status-null", + "response": "{\"outcome\":\"response-recorded\",\"status\":null}", + "accepted": false + }, + { + "case": "response-recorded-status-200.0", + "response": "{\"outcome\":\"response-recorded\",\"status\":200.0}", + "accepted": false + }, + { + "case": "response-recorded-status-2e2", + "response": "{\"outcome\":\"response-recorded\",\"status\":2e2}", + "accepted": false + }, + { + "case": "observed-valid", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-missing-outcome", + "response": "{\"matched\":true,\"status\":200}", + "accepted": false + }, + { + "case": "observed-duplicate-outcome", + "response": "{\"outcome\":\"observed\",\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-missing-status", + "response": "{\"outcome\":\"observed\",\"matched\":true}", + "accepted": false + }, + { + "case": "observed-duplicate-status", + "response": "{\"outcome\":\"observed\",\"status\":200,\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-missing-matched", + "response": "{\"outcome\":\"observed\",\"status\":200}", + "accepted": false + }, + { + "case": "observed-duplicate-matched", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-unknown-field", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true,\"provider_success\":true}", + "accepted": false + }, + { + "case": "observed-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"observed\",\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-bom", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-minimum", + "response": "{\"outcome\":\"observed\",\"status\":100,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-status-maximum", + "response": "{\"outcome\":\"observed\",\"status\":599,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-status-below", + "response": "{\"outcome\":\"observed\",\"status\":99,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-above", + "response": "{\"outcome\":\"observed\",\"status\":600,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-u16-maximum", + "response": "{\"outcome\":\"observed\",\"status\":65535,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-negative", + "response": "{\"outcome\":\"observed\",\"status\":-1,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-boolean", + "response": "{\"outcome\":\"observed\",\"status\":true,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-string", + "response": "{\"outcome\":\"observed\",\"status\":\"200\",\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-null", + "response": "{\"outcome\":\"observed\",\"status\":null,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-200.0", + "response": "{\"outcome\":\"observed\",\"status\":200.0,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-2e2", + "response": "{\"outcome\":\"observed\",\"status\":2e2,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-by-provider-valid", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-missing-outcome", + "response": "{\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"status\":200}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-outcome", + "response": "{\"outcome\":\"observed-by-provider\",\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-missing-status", + "response": "{\"outcome\":\"observed-by-provider\",\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-status", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-missing-evidence", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-evidence", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-unknown-field", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"provider_success\":true}", + "accepted": false + }, + { + "case": "observed-by-provider-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"observed-by-provider\",\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-bom", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-minimum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":100,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-maximum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":599,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-below", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":99,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-above", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":600,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-u16-maximum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":65535,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-negative", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":-1,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-boolean", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":true,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-string", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":\"200\",\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-null", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":null,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-200.0", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200.0,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-2e2", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":2e2,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "denied-code-one-byte", + "response": "{\"outcome\":\"denied\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "denied-code-ascii-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "denied-code-utf8-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "denied-code-astral-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "denied-code-ascii-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "denied-code-utf8-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "denied-code-astral-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "denied-code-empty", + "response": "{\"outcome\":\"denied\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "denied-code-null", + "response": "{\"outcome\":\"denied\",\"code\":null}", + "accepted": false + }, + { + "case": "denied-code-number", + "response": "{\"outcome\":\"denied\",\"code\":7}", + "accepted": false + }, + { + "case": "denied-code-boolean", + "response": "{\"outcome\":\"denied\",\"code\":false}", + "accepted": false + }, + { + "case": "denied-unpaired-\\ud800", + "response": "{\"outcome\":\"denied\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "denied-unpaired-\\udc00", + "response": "{\"outcome\":\"denied\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "denied-unpaired-\\ud800x", + "response": "{\"outcome\":\"denied\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "indeterminate-code-one-byte", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "indeterminate-code-ascii-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "indeterminate-code-utf8-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "indeterminate-code-astral-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "indeterminate-code-ascii-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "indeterminate-code-utf8-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "indeterminate-code-astral-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "indeterminate-code-empty", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "indeterminate-code-null", + "response": "{\"outcome\":\"indeterminate\",\"code\":null}", + "accepted": false + }, + { + "case": "indeterminate-code-number", + "response": "{\"outcome\":\"indeterminate\",\"code\":7}", + "accepted": false + }, + { + "case": "indeterminate-code-boolean", + "response": "{\"outcome\":\"indeterminate\",\"code\":false}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\ud800", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\udc00", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\ud800x", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "not-entered-code-one-byte", + "response": "{\"outcome\":\"not-entered\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "not-entered-code-ascii-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "not-entered-code-utf8-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "not-entered-code-astral-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "not-entered-code-ascii-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "not-entered-code-utf8-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "not-entered-code-astral-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "not-entered-code-empty", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "not-entered-code-null", + "response": "{\"outcome\":\"not-entered\",\"code\":null}", + "accepted": false + }, + { + "case": "not-entered-code-number", + "response": "{\"outcome\":\"not-entered\",\"code\":7}", + "accepted": false + }, + { + "case": "not-entered-code-boolean", + "response": "{\"outcome\":\"not-entered\",\"code\":false}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\ud800", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\udc00", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\ud800x", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "reserved-revision-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":9007199254740991}", + "accepted": true + }, + { + "case": "reserved-revision-above-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":9007199254740992}", + "accepted": false + }, + { + "case": "reserved-revision-u64-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":18446744073709551615}", + "accepted": false + }, + { + "case": "reserved-revision-zero", + "response": "{\"outcome\":\"reserved\",\"revision\":0}", + "accepted": false + }, + { + "case": "reserved-revision-negative", + "response": "{\"outcome\":\"reserved\",\"revision\":-1}", + "accepted": false + }, + { + "case": "reserved-revision-boolean", + "response": "{\"outcome\":\"reserved\",\"revision\":true}", + "accepted": false + }, + { + "case": "reserved-revision-string", + "response": "{\"outcome\":\"reserved\",\"revision\":\"1\"}", + "accepted": false + }, + { + "case": "reserved-revision-null", + "response": "{\"outcome\":\"reserved\",\"revision\":null}", + "accepted": false + }, + { + "case": "reserved-revision-1.0", + "response": "{\"outcome\":\"reserved\",\"revision\":1.0}", + "accepted": false + }, + { + "case": "reserved-revision-1e0", + "response": "{\"outcome\":\"reserved\",\"revision\":1e0}", + "accepted": false + }, + { + "case": "observed-matched-false", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":false}", + "accepted": true + }, + { + "case": "observed-matched-number", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":1}", + "accepted": false + }, + { + "case": "observed-matched-string", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":\"true\"}", + "accepted": false + }, + { + "case": "observed-matched-null", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":null}", + "accepted": false + }, + { + "case": "array", + "response": "[]", + "accepted": false + }, + { + "case": "null", + "response": "null", + "accepted": false + }, + { + "case": "string", + "response": "\"unknown\"", + "accepted": false + }, + { + "case": "obsolete-outcome", + "response": "{\"outcome\":\"success\"}", + "accepted": false + } + ], "history_wire_cases": [ { "kind": "pre-entry", diff --git a/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json index 597d94980..f2823736e 100644 --- a/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json +++ b/bindings/fixtures/gateway/native-public-mutation-evidence-postgres.json @@ -92,6 +92,803 @@ "accepted": false } ], + "result_wire_cases": [ + { + "case": "denied-valid", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": true + }, + { + "case": "denied-missing-outcome", + "response": "{\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-duplicate-outcome", + "response": "{\"outcome\":\"denied\",\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-missing-code", + "response": "{\"outcome\":\"denied\"}", + "accepted": false + }, + { + "case": "denied-duplicate-code", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-unknown-field", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "denied-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"denied\",\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "denied-bom", + "response": "{\"outcome\":\"denied\",\"code\":\"native.denied\"}", + "accepted": false + }, + { + "case": "indeterminate-valid", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": true + }, + { + "case": "indeterminate-missing-outcome", + "response": "{\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-duplicate-outcome", + "response": "{\"outcome\":\"indeterminate\",\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-missing-code", + "response": "{\"outcome\":\"indeterminate\"}", + "accepted": false + }, + { + "case": "indeterminate-duplicate-code", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-unknown-field", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "indeterminate-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"indeterminate\",\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "indeterminate-bom", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"native.unavailable\"}", + "accepted": false + }, + { + "case": "not-entered-valid", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": true + }, + { + "case": "not-entered-missing-outcome", + "response": "{\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-duplicate-outcome", + "response": "{\"outcome\":\"not-entered\",\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-missing-code", + "response": "{\"outcome\":\"not-entered\"}", + "accepted": false + }, + { + "case": "not-entered-duplicate-code", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-unknown-field", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "not-entered-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"not-entered\",\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "not-entered-bom", + "response": "{\"outcome\":\"not-entered\",\"code\":\"native.refused\"}", + "accepted": false + }, + { + "case": "reserved-valid", + "response": "{\"outcome\":\"reserved\",\"revision\":1}", + "accepted": true + }, + { + "case": "reserved-missing-outcome", + "response": "{\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-duplicate-outcome", + "response": "{\"outcome\":\"reserved\",\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-missing-revision", + "response": "{\"outcome\":\"reserved\"}", + "accepted": false + }, + { + "case": "reserved-duplicate-revision", + "response": "{\"outcome\":\"reserved\",\"revision\":1,\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-unknown-field", + "response": "{\"outcome\":\"reserved\",\"revision\":1,\"provider_success\":true}", + "accepted": false + }, + { + "case": "reserved-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"reserved\",\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "reserved-bom", + "response": "{\"outcome\":\"reserved\",\"revision\":1}", + "accepted": false + }, + { + "case": "unknown-valid", + "response": "{\"outcome\":\"unknown\"}", + "accepted": true + }, + { + "case": "unknown-missing-outcome", + "response": "{}", + "accepted": false + }, + { + "case": "unknown-duplicate-outcome", + "response": "{\"outcome\":\"unknown\",\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "unknown-unknown-field", + "response": "{\"outcome\":\"unknown\",\"provider_success\":true}", + "accepted": false + }, + { + "case": "unknown-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"unknown\",\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "unknown-bom", + "response": "{\"outcome\":\"unknown\"}", + "accepted": false + }, + { + "case": "response-recorded-valid", + "response": "{\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": true + }, + { + "case": "response-recorded-missing-outcome", + "response": "{\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-duplicate-outcome", + "response": "{\"outcome\":\"response-recorded\",\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-missing-status", + "response": "{\"outcome\":\"response-recorded\"}", + "accepted": false + }, + { + "case": "response-recorded-duplicate-status", + "response": "{\"outcome\":\"response-recorded\",\"status\":200,\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-unknown-field", + "response": "{\"outcome\":\"response-recorded\",\"status\":200,\"provider_success\":true}", + "accepted": false + }, + { + "case": "response-recorded-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"response-recorded\",\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-bom", + "response": "{\"outcome\":\"response-recorded\",\"status\":200}", + "accepted": false + }, + { + "case": "response-recorded-status-minimum", + "response": "{\"outcome\":\"response-recorded\",\"status\":100}", + "accepted": true + }, + { + "case": "response-recorded-status-maximum", + "response": "{\"outcome\":\"response-recorded\",\"status\":599}", + "accepted": true + }, + { + "case": "response-recorded-status-below", + "response": "{\"outcome\":\"response-recorded\",\"status\":99}", + "accepted": false + }, + { + "case": "response-recorded-status-above", + "response": "{\"outcome\":\"response-recorded\",\"status\":600}", + "accepted": false + }, + { + "case": "response-recorded-status-u16-maximum", + "response": "{\"outcome\":\"response-recorded\",\"status\":65535}", + "accepted": false + }, + { + "case": "response-recorded-status-negative", + "response": "{\"outcome\":\"response-recorded\",\"status\":-1}", + "accepted": false + }, + { + "case": "response-recorded-status-boolean", + "response": "{\"outcome\":\"response-recorded\",\"status\":true}", + "accepted": false + }, + { + "case": "response-recorded-status-string", + "response": "{\"outcome\":\"response-recorded\",\"status\":\"200\"}", + "accepted": false + }, + { + "case": "response-recorded-status-null", + "response": "{\"outcome\":\"response-recorded\",\"status\":null}", + "accepted": false + }, + { + "case": "response-recorded-status-200.0", + "response": "{\"outcome\":\"response-recorded\",\"status\":200.0}", + "accepted": false + }, + { + "case": "response-recorded-status-2e2", + "response": "{\"outcome\":\"response-recorded\",\"status\":2e2}", + "accepted": false + }, + { + "case": "observed-valid", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-missing-outcome", + "response": "{\"matched\":true,\"status\":200}", + "accepted": false + }, + { + "case": "observed-duplicate-outcome", + "response": "{\"outcome\":\"observed\",\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-missing-status", + "response": "{\"outcome\":\"observed\",\"matched\":true}", + "accepted": false + }, + { + "case": "observed-duplicate-status", + "response": "{\"outcome\":\"observed\",\"status\":200,\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-missing-matched", + "response": "{\"outcome\":\"observed\",\"status\":200}", + "accepted": false + }, + { + "case": "observed-duplicate-matched", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-unknown-field", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true,\"provider_success\":true}", + "accepted": false + }, + { + "case": "observed-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"observed\",\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-bom", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-minimum", + "response": "{\"outcome\":\"observed\",\"status\":100,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-status-maximum", + "response": "{\"outcome\":\"observed\",\"status\":599,\"matched\":true}", + "accepted": true + }, + { + "case": "observed-status-below", + "response": "{\"outcome\":\"observed\",\"status\":99,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-above", + "response": "{\"outcome\":\"observed\",\"status\":600,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-u16-maximum", + "response": "{\"outcome\":\"observed\",\"status\":65535,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-negative", + "response": "{\"outcome\":\"observed\",\"status\":-1,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-boolean", + "response": "{\"outcome\":\"observed\",\"status\":true,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-string", + "response": "{\"outcome\":\"observed\",\"status\":\"200\",\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-null", + "response": "{\"outcome\":\"observed\",\"status\":null,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-200.0", + "response": "{\"outcome\":\"observed\",\"status\":200.0,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-status-2e2", + "response": "{\"outcome\":\"observed\",\"status\":2e2,\"matched\":true}", + "accepted": false + }, + { + "case": "observed-by-provider-valid", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-missing-outcome", + "response": "{\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"status\":200}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-outcome", + "response": "{\"outcome\":\"observed-by-provider\",\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-missing-status", + "response": "{\"outcome\":\"observed-by-provider\",\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-status", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-missing-evidence", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200}", + "accepted": false + }, + { + "case": "observed-by-provider-duplicate-evidence", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-unknown-field", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000},\"provider_success\":true}", + "accepted": false + }, + { + "case": "observed-by-provider-escaped-duplicate-outcome", + "response": "{\"outc\\u006fme\":\"observed-by-provider\",\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-bom", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-minimum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":100,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-maximum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":599,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-below", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":99,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-above", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":600,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-u16-maximum", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":65535,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-negative", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":-1,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-boolean", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":true,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-string", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":\"200\",\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-null", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":null,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": true + }, + { + "case": "observed-by-provider-status-200.0", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":200.0,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "observed-by-provider-status-2e2", + "response": "{\"outcome\":\"observed-by-provider\",\"status\":2e2,\"evidence\":{\"schema\":\"auths.gateway-public-evidence/1\",\"channel\":\"read-back\",\"evidence_commitment\":\"abababababababababababababababababababababababababababababababab\",\"observed_at\":1790000000}}", + "accepted": false + }, + { + "case": "denied-code-one-byte", + "response": "{\"outcome\":\"denied\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "denied-code-ascii-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "denied-code-utf8-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "denied-code-astral-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "denied-code-ascii-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "denied-code-utf8-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "denied-code-astral-over-limit", + "response": "{\"outcome\":\"denied\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "denied-code-empty", + "response": "{\"outcome\":\"denied\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "denied-code-null", + "response": "{\"outcome\":\"denied\",\"code\":null}", + "accepted": false + }, + { + "case": "denied-code-number", + "response": "{\"outcome\":\"denied\",\"code\":7}", + "accepted": false + }, + { + "case": "denied-code-boolean", + "response": "{\"outcome\":\"denied\",\"code\":false}", + "accepted": false + }, + { + "case": "denied-unpaired-\\ud800", + "response": "{\"outcome\":\"denied\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "denied-unpaired-\\udc00", + "response": "{\"outcome\":\"denied\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "denied-unpaired-\\ud800x", + "response": "{\"outcome\":\"denied\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "indeterminate-code-one-byte", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "indeterminate-code-ascii-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "indeterminate-code-utf8-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "indeterminate-code-astral-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "indeterminate-code-ascii-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "indeterminate-code-utf8-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "indeterminate-code-astral-over-limit", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "indeterminate-code-empty", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "indeterminate-code-null", + "response": "{\"outcome\":\"indeterminate\",\"code\":null}", + "accepted": false + }, + { + "case": "indeterminate-code-number", + "response": "{\"outcome\":\"indeterminate\",\"code\":7}", + "accepted": false + }, + { + "case": "indeterminate-code-boolean", + "response": "{\"outcome\":\"indeterminate\",\"code\":false}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\ud800", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\udc00", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "indeterminate-unpaired-\\ud800x", + "response": "{\"outcome\":\"indeterminate\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "not-entered-code-one-byte", + "response": "{\"outcome\":\"not-entered\",\"code\":\"a\"}", + "accepted": true + }, + { + "case": "not-entered-code-ascii-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": true + }, + { + "case": "not-entered-code-utf8-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": true + }, + { + "case": "not-entered-code-astral-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": true + }, + { + "case": "not-entered-code-ascii-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", + "accepted": false + }, + { + "case": "not-entered-code-utf8-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"ééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé\"}", + "accepted": false + }, + { + "case": "not-entered-code-astral-over-limit", + "response": "{\"outcome\":\"not-entered\",\"code\":\"🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\"}", + "accepted": false + }, + { + "case": "not-entered-code-empty", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\"}", + "accepted": false + }, + { + "case": "not-entered-code-null", + "response": "{\"outcome\":\"not-entered\",\"code\":null}", + "accepted": false + }, + { + "case": "not-entered-code-number", + "response": "{\"outcome\":\"not-entered\",\"code\":7}", + "accepted": false + }, + { + "case": "not-entered-code-boolean", + "response": "{\"outcome\":\"not-entered\",\"code\":false}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\ud800", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\ud800\"}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\udc00", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\udc00\"}", + "accepted": false + }, + { + "case": "not-entered-unpaired-\\ud800x", + "response": "{\"outcome\":\"not-entered\",\"code\":\"\\ud800x\"}", + "accepted": false + }, + { + "case": "reserved-revision-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":9007199254740991}", + "accepted": true + }, + { + "case": "reserved-revision-above-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":9007199254740992}", + "accepted": false + }, + { + "case": "reserved-revision-u64-maximum", + "response": "{\"outcome\":\"reserved\",\"revision\":18446744073709551615}", + "accepted": false + }, + { + "case": "reserved-revision-zero", + "response": "{\"outcome\":\"reserved\",\"revision\":0}", + "accepted": false + }, + { + "case": "reserved-revision-negative", + "response": "{\"outcome\":\"reserved\",\"revision\":-1}", + "accepted": false + }, + { + "case": "reserved-revision-boolean", + "response": "{\"outcome\":\"reserved\",\"revision\":true}", + "accepted": false + }, + { + "case": "reserved-revision-string", + "response": "{\"outcome\":\"reserved\",\"revision\":\"1\"}", + "accepted": false + }, + { + "case": "reserved-revision-null", + "response": "{\"outcome\":\"reserved\",\"revision\":null}", + "accepted": false + }, + { + "case": "reserved-revision-1.0", + "response": "{\"outcome\":\"reserved\",\"revision\":1.0}", + "accepted": false + }, + { + "case": "reserved-revision-1e0", + "response": "{\"outcome\":\"reserved\",\"revision\":1e0}", + "accepted": false + }, + { + "case": "observed-matched-false", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":false}", + "accepted": true + }, + { + "case": "observed-matched-number", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":1}", + "accepted": false + }, + { + "case": "observed-matched-string", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":\"true\"}", + "accepted": false + }, + { + "case": "observed-matched-null", + "response": "{\"outcome\":\"observed\",\"status\":200,\"matched\":null}", + "accepted": false + }, + { + "case": "array", + "response": "[]", + "accepted": false + }, + { + "case": "null", + "response": "null", + "accepted": false + }, + { + "case": "string", + "response": "\"unknown\"", + "accepted": false + }, + { + "case": "obsolete-outcome", + "response": "{\"outcome\":\"success\"}", + "accepted": false + } + ], "history_wire_cases": [ { "kind": "pre-entry", diff --git a/bindings/python/python/auths/gateway.py b/bindings/python/python/auths/gateway.py index 6c9568a23..d1948d849 100644 --- a/bindings/python/python/auths/gateway.py +++ b/bindings/python/python/auths/gateway.py @@ -245,7 +245,7 @@ def _parse_result(raw: bytes) -> GatewayResult: code = value.get("code") if set(value) != {"outcome", "code"} or not isinstance(code, str): raise GatewayProtocolError("gateway returned invalid refusal") - if not 1 <= len(code) <= 128: + if not 1 <= len(code.encode("utf-8")) <= 128: raise GatewayProtocolError("gateway returned invalid code") if outcome == "denied": return GatewayDenied(code) diff --git a/bindings/python/tests/test_gateway_client.py b/bindings/python/tests/test_gateway_client.py index e483d8980..cf296cc2c 100644 --- a/bindings/python/tests/test_gateway_client.py +++ b/bindings/python/tests/test_gateway_client.py @@ -160,6 +160,20 @@ def test_result_parser_matches_native_public_evidence_corpus() -> None: _parse_result(case["response"].encode()) +def test_all_result_variants_match_native_wire_corpus() -> None: + from auths.gateway import _parse_result + + fixture = Path(__file__).resolve().parents[2] / "fixtures/gateway/native-public-mutation-evidence-file.json" + corpus = json.loads(fixture.read_text()) + for case in corpus["result_wire_cases"]: + if case["accepted"]: + result = _parse_result(case["response"].encode()) + assert result.outcome == json.loads(case["response"])["outcome"], case["case"] + else: + with pytest.raises(GatewayProtocolError): + _parse_result(case["response"].encode()) + + def test_result_parser_exposes_observed_by_provider_without_evidence_bytes() -> None: from auths.gateway import _parse_result diff --git a/bindings/typescript/test/unit/gateway-client.test.js b/bindings/typescript/test/unit/gateway-client.test.js index 656cbac20..41295756f 100644 --- a/bindings/typescript/test/unit/gateway-client.test.js +++ b/bindings/typescript/test/unit/gateway-client.test.js @@ -137,6 +137,19 @@ test("gateway public evidence matches the native corpus", { skip: process.platfo } }); +test("all gateway result variants match the native wire corpus", { skip: process.platform === "win32" }, async () => { + const path = new URL("../../../fixtures/gateway/native-public-mutation-evidence-file.json", import.meta.url); + const corpus = JSON.parse(await readFile(path, "utf8")); + for (const item of corpus.result_wire_cases) { + if (item.accepted) { + const result = await replyOnce(item.response); + assert.equal(result.outcome, JSON.parse(item.response).outcome, item.case); + } else { + await assert.rejects(replyOnce(item.response), GatewayProtocolError, item.case); + } + } +}); + test("gateway client exposes observed-by-provider without evidence bytes", { skip: process.platform === "win32" }, async () => { const evidence = { schema: "auths.gateway-public-evidence/1", channel: "read-back", evidenceCommitment: DIGEST, observedAt: 1790000000 }; assert.deepEqual(await replyOnce(providerResult()), { outcome: "observed-by-provider", status: 200, evidence }); diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 8510716bd..f25cc986f 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3868,3 +3868,34 @@ The semantic metadata constructor passed with no release identity changes: this batch changes testkit/evidence sources rather than the public contract. No local benchmark, broad suite, lint, formal or CI inspection was performed by main. CI publication and holistic repairs remain with the existing subagent. + +## Closed submission-result decoding and complete variant corpus + +A direct A18 source audit found native decoders accepted invalid HTTP statuses, +unbounded refusal strings and an omitted optional status that SDKs reject. +Python counted refusal characters rather than UTF-8 bytes. Native results now +use the existing bounded refusal decoder, HTTP status 100–599 and a mandatory +nullable provider-linked status. A unit-variant Serde regression also accepted +extra fields on Unknown despite enum-level deny_unknown_fields. An empty-map +native decoder closes that loophole without changing the Rust variant or its +serialized representation. No authorization, transition or recovery rule changes. + +Both maintained adapter artifacts now contain 159 additional native-decoded +vectors over all eight result variants, with 29 accepted and 130 refused cases. +They cover every required field, duplicates/escaped aliases, unknown members, +UTF-8 and astral-byte boundaries, invalid surrogate sequences, safe revision +limits, HTTP boundaries, boolean/null/type substitutions, fractional/exponent +numbers and BOM. The existing 15 evidence and 35 history vectors remain intact: +209 shared cases are now consumed by both SDK suites. SDK execution awaits CI. + +Required artifact construction passed the exact native file and TLS PostgreSQL +selectors (1 passed / 0 ignored each, 0.76 s / 0.86 s). The initial constructor +correctly caught the Unknown extra-field discrepancy before its native fix. +Source-closure construction passed (1 passed / 0 ignored, 0.07 s); its final hash +is `e6112e97c83f4e4b422f62828b3840fa3db9a9a7a9421a0f090a401613e06f81`. +Rebuilt closure and semantic metadata results are recorded before publication. +These constructors do not close all A18 or establish installed package parity. +Rebuilt non-update source closure passed (1 passed / 0 ignored, 0.07 s). +Semantic metadata construction passed at freeze428, portable ABI129 and public +surface428; no other semantic identity increment was required. Main did not run +SDK, lint, broad test or formal gates and did not inspect CI. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index d44f4427e..109a2267e 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -902,6 +902,14 @@ Private constructors enforce the local boundary. Entry permits are neither clone Remote permits and multi-executor dispatch are outside this milestone. Do not imply that a Rust type alone prevents a malicious process from bypassing a deployment boundary. +Public submission-result objects have a closed field inventory for every variant, +including `unknown`. Refusal codes contain 1–128 UTF-8 bytes; journal revisions +are integers in 1–2^53−1; HTTP statuses are integers in 100–599. A provider-linked +result always includes `status`, using explicit null if no write response was +recorded. Missing fields, duplicate or escaped-alias members, unknown fields, +invalid Unicode, boolean/fractional/exponent numeric spellings and limit-plus-one +values are refused consistently by Rust and the affected public bindings. + ### Signed public history and operator-private audit Application outcome queries sign `auths.gateway-outcome/3`. Its closed facts are diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 73b40cca3..be865f17e 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"8887edd3f6eddcd549e2d41ea06072ef30cc34d535f3f4e40fe146682c15f1ce"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"567ecc2aac4de572b9f14eeb240a255cd6432e9bc263bb8fd3ac1e0bec7a5e76"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"49a61cda5da9d2bdea6d18ee8fbdf88334f3e313bc561bf42e84e64a7c5489d7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"9bf4a62e789a29d1ce82fcb0c2a3882775ecf4fb0e1116960cb3a61dc7efe018"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index b68d2569a..36f9bc90c 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -92,11 +92,20 @@ pub enum GatewayEngineConfigurationError { #[serde(tag = "outcome", rename_all = "kebab-case", deny_unknown_fields)] pub enum GatewaySubmitResult { /// Native proof verification denied the action. - Denied { code: String }, + Denied { + #[serde(deserialize_with = "decode_refusal_code")] + code: String, + }, /// Native verification or required durable state is unavailable/indeterminate. - Indeterminate { code: String }, + Indeterminate { + #[serde(deserialize_with = "decode_refusal_code")] + code: String, + }, /// Proof was authorized but this operation did not enter write transport. - NotEntered { code: String }, + NotEntered { + #[serde(deserialize_with = "decode_refusal_code")] + code: String, + }, /// A durable reservation exists without an entry grant. Continuing requires /// fresh native authority, exact approval and a new single-winner grant. Reserved { @@ -104,21 +113,57 @@ pub enum GatewaySubmitResult { revision: u64, }, /// Write entry/effect is ambiguous; no automatic retry is permitted. + #[serde(deserialize_with = "decode_empty_result")] Unknown, /// A complete bounded HTTP response exists, but no read-back was recorded. - ResponseRecorded { status: u16 }, + ResponseRecorded { + #[serde(deserialize_with = "decode_http_status")] + status: u16, + }, /// A separately completed read-back compared exact state; not causation. - Observed { status: u16, matched: bool }, + Observed { + #[serde(deserialize_with = "decode_http_status")] + status: u16, + matched: bool, + }, /// A read-back over the pinned origin returned exactly this attempt's echo /// token and the verified value. `status` is absent when the write itself /// was `unknown`. The link holds only while no other party with write /// access to that provider field wrote the same token. ObservedByProvider { + #[serde(deserialize_with = "decode_optional_http_status")] status: Option, evidence: GatewayEvidenceSummary, }, } +fn decode_empty_result<'de, D: serde::Deserializer<'de>>(d: D) -> Result<(), D::Error> { + // Serde's internally tagged unit variant otherwise discards remaining + // members, even with enum-level deny_unknown_fields. + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct EmptyResult {} + EmptyResult::deserialize(d).map(|_| ()) +} + +fn decode_http_status<'de, D: serde::Deserializer<'de>>(d: D) -> Result { + let status = u16::deserialize(d)?; + if !(100..=599).contains(&status) { + return Err(serde::de::Error::custom("invalid public HTTP status")); + } + Ok(status) +} + +fn decode_optional_http_status<'de, D: serde::Deserializer<'de>>( + d: D, +) -> Result, D::Error> { + let status = Option::::deserialize(d)?; + if status.is_some_and(|value| !(100..=599).contains(&value)) { + return Err(serde::de::Error::custom("invalid public HTTP status")); + } + Ok(status) +} + fn decode_journal_revision<'de, D: serde::Deserializer<'de>>( deserializer: D, ) -> Result { diff --git a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs index 46c865fda..2213f278b 100644 --- a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs +++ b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs @@ -4,6 +4,9 @@ use sha2::{Digest as _, Sha256}; const CONTENT: &[u8] = b"private-mutation-evidence-canary"; +#[path = "native_result_wire_cases.rs"] +mod result_wires; + fn private_values_absent(bytes: &[u8], values: &[&[u8]]) { use base64ct::{Base64, Base64UrlUnpadded, Encoding as _}; for value in values { @@ -537,7 +540,7 @@ fn matrix(backend: Backend) { let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-public-mutation-evidence/1","adapter":backend.label(), "scope":"native writer/read proofs and exact approvals, actual HTTP, protected complete evidence and public original-writer replay after withdrawal", "excluded":["live provider and hostile OS qualification"], - "public_result":first,"wire_cases":wire_cases(),"history_wire_cases":history_wire_cases(),"same_private_bytes_have_distinct_record_scoped_commitments":true,"reopen_and_replay_preserve_commitment_without_io":true, + "public_result":first,"wire_cases":wire_cases(),"result_wire_cases":result_wires::cases(),"history_wire_cases":history_wire_cases(),"same_private_bytes_have_distinct_record_scoped_commitments":true,"reopen_and_replay_preserve_commitment_without_io":true, "configured_signed_public_history_excludes_private_facts":true,"operator_private_signature_preserves_full_audit_facts":true, "private_complete_evidence_and_original_binding_preserved":true,"public_and_debug_exclude_raw_body_digest_echo_and_action_digest":true})).expect("artifact"); let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( diff --git a/product/runtime/auths-gateway/src/native_result_wire_cases.rs b/product/runtime/auths-gateway/src/native_result_wire_cases.rs new file mode 100644 index 000000000..e91d7c7cf --- /dev/null +++ b/product/runtime/auths-gateway/src/native_result_wire_cases.rs @@ -0,0 +1,200 @@ +//! Data-only decoding parity for every public submission-result variant. +//! Real native transport and signed evidence are established by the parent. +use crate::GatewaySubmitResult; +use serde_json::{Value, json}; + +fn wire(output: &mut Vec, name: &str, response: &str, accepted: bool) { + assert_eq!( + serde_json::from_str::(response).is_ok(), + accepted, + "{name}" + ); + output.push(json!({"case":name,"response":response,"accepted":accepted})); +} + +fn value(output: &mut Vec, name: &str, response: &Value, accepted: bool) { + wire(output, name, &response.to_string(), accepted); +} + +fn status_cases(output: &mut Vec, base: &Value) { + let outcome = base["outcome"].as_str().expect("variant"); + for (name, status, accepted) in [ + ("minimum", json!(100), true), + ("maximum", json!(599), true), + ("below", json!(99), false), + ("above", json!(600), false), + ("u16-maximum", json!(65535), false), + ("negative", json!(-1), false), + ("boolean", json!(true), false), + ("string", json!("200"), false), + ("null", Value::Null, outcome == "observed-by-provider"), + ] { + let mut changed = base.clone(); + changed["status"] = status; + value( + output, + &format!("{outcome}-status-{name}"), + &changed, + accepted, + ); + } + for number in ["200.0", "2e2"] { + wire( + output, + &format!("{outcome}-status-{number}"), + &base + .to_string() + .replace("\"status\":200", &format!("\"status\":{number}")), + false, + ); + } +} + +fn refusal_cases(output: &mut Vec, outcome: &str) { + for (name, code, accepted) in [ + ("one-byte", json!("a"), true), + ("ascii-limit", json!("a".repeat(128)), true), + ("utf8-limit", json!("é".repeat(64)), true), + ("astral-limit", json!("🟢".repeat(32)), true), + ("ascii-over-limit", json!("a".repeat(129)), false), + ("utf8-over-limit", json!("é".repeat(65)), false), + ("astral-over-limit", json!("🟢".repeat(33)), false), + ("empty", json!(""), false), + ("null", Value::Null, false), + ("number", json!(7), false), + ("boolean", json!(false), false), + ] { + value( + output, + &format!("{outcome}-code-{name}"), + &json!({"outcome":outcome,"code":code}), + accepted, + ); + } + for escaped in [r"\ud800", r"\udc00", r"\ud800x"] { + wire( + output, + &format!("{outcome}-unpaired-{escaped}"), + &format!(r#"{{"outcome":"{outcome}","code":"{escaped}"}}"#), + false, + ); + } +} + +fn shape_cases(output: &mut Vec, base: &Value) { + let outcome = base["outcome"].as_str().expect("variant"); + value(output, &format!("{outcome}-valid"), base, true); + for field in base.as_object().expect("object").keys() { + let mut missing = base.clone(); + missing.as_object_mut().expect("object").remove(field); + value( + output, + &format!("{outcome}-missing-{field}"), + &missing, + false, + ); + let encoded_key = serde_json::to_string(field).expect("key"); + let encoded_value = serde_json::to_string(&base[field]).expect("value"); + wire( + output, + &format!("{outcome}-duplicate-{field}"), + &base.to_string().replacen( + &format!("{encoded_key}:"), + &format!("{encoded_key}:{encoded_value},{encoded_key}:"), + 1, + ), + false, + ); + } + let mut extra = base.clone(); + extra["provider_success"] = json!(true); + value(output, &format!("{outcome}-unknown-field"), &extra, false); + wire( + output, + &format!("{outcome}-escaped-duplicate-outcome"), + &base.to_string().replacen( + "\"outcome\":", + &format!("\"outc\\u006fme\":\"{outcome}\",\"outcome\":"), + 1, + ), + false, + ); + wire( + output, + &format!("{outcome}-bom"), + &format!("\u{feff}{base}"), + false, + ); +} + +pub(super) fn cases() -> Value { + let bases = [ + json!({"outcome":"denied","code":"native.denied"}), + json!({"outcome":"indeterminate","code":"native.unavailable"}), + json!({"outcome":"not-entered","code":"native.refused"}), + json!({"outcome":"reserved","revision":1}), + json!({"outcome":"unknown"}), + json!({"outcome":"response-recorded","status":200}), + json!({"outcome":"observed","status":200,"matched":true}), + json!({"outcome":"observed-by-provider","status":200, + "evidence":{"schema":crate::PUBLIC_EVIDENCE_SCHEMA,"channel":"read-back", + "evidence_commitment":"ab".repeat(32),"observed_at":1790000000}}), + ]; + let mut output = Vec::new(); + for base in &bases { + shape_cases(&mut output, base); + if base.get("status").is_some() { + status_cases(&mut output, base); + } + } + for outcome in ["denied", "indeterminate", "not-entered"] { + refusal_cases(&mut output, outcome); + } + for (name, revision, accepted) in [ + ("maximum", json!(9_007_199_254_740_991_u64), true), + ("above-maximum", json!(9_007_199_254_740_992_u64), false), + ("u64-maximum", json!(u64::MAX), false), + ("zero", json!(0), false), + ("negative", json!(-1), false), + ("boolean", json!(true), false), + ("string", json!("1"), false), + ("null", Value::Null, false), + ] { + value( + &mut output, + &format!("reserved-revision-{name}"), + &json!({"outcome":"reserved","revision":revision}), + accepted, + ); + } + for number in ["1.0", "1e0"] { + wire( + &mut output, + &format!("reserved-revision-{number}"), + &format!("{{\"outcome\":\"reserved\",\"revision\":{number}}}"), + false, + ); + } + for (name, matched, accepted) in [ + ("false", json!(false), true), + ("number", json!(1), false), + ("string", json!("true"), false), + ("null", Value::Null, false), + ] { + value( + &mut output, + &format!("observed-matched-{name}"), + &json!({"outcome":"observed","status":200,"matched":matched}), + accepted, + ); + } + for (name, response) in [ + ("array", json!([])), + ("null", Value::Null), + ("string", json!("unknown")), + ("obsolete-outcome", json!({"outcome":"success"})), + ] { + value(&mut output, name, &response, false); + } + json!(output) +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index fa4a454b5..e800269f9 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0581155d4d8b1b9ebb10fa4cd294e7f72e7440ba6482d30d45ae6ed38eef496e"; + "e6112e97c83f4e4b422f62828b3840fa3db9a9a7a9421a0f090a401613e06f81"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 862acdc90..9138477e6 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 427 +freeze_version = 428 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -47,7 +47,7 @@ freeze_version = 427 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 "auths.identity.protocol" = 170 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 128 +"auths.portable-abi-bindings" = 129 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -67,4 +67,4 @@ freeze_version = 427 "auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 84 -"auths.release.public-surface" = 427 +"auths.release.public-surface" = 428 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 41414fc2f..f5485dcd0 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 427, + "freezeVersion": 428, "publicSurface": { "rustRoots": [ "auths", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 128, + "version": 129, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "5fc4c1adbdffc4fff4b85de1c85dedf9defb67e6509873da3a19f5e5639a3509" + "sha256": "80ef7f579a1b4eb516e9d9f3d91dbc11e079b90a042e336f614e4823084062ac" }, { "id": "auths.product.bounded-domains", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 427, + "version": 428, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "1436aa97a500fe5e9a644c4efa29b41f9322023b230a08cb70ebaca24dc17654" + "sha256": "dccc969ee724a18d8cd647f9a1d7b9235e280227fa5f110c89fa2c5db048fdf8" } ] } From 14cdc0f7681e06c63c5a1775697883db6d1ef459 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:37:28 +0900 Subject: [PATCH 122/136] fix(ci): preserve private audit journeys and refresh pinned evidence --- ...ependent-mutation-differential-report.json | 2 +- ...ive-independent-mutation-differential.json | 20 ++-- .../stripe-refund-approval/README.md.tmpl | 1 + .../lib/selftest.py.tmpl | 1 + examples/stripe-refund-approval/README.md | 5 + examples/stripe-refund-approval/journey.py | 48 +++++---- .../typescript/journey.ts | 30 ++++-- .../runtime/auths-gateway/src/audit_tests.rs | 7 +- product/runtime/auths-gateway/src/engine.rs | 2 +- .../src/native_public_evidence_tests.rs | 21 ++-- .../auths-gateway/src/observed_tests.rs | 36 ++++--- .../tests/content_journey/interface_tests.rs | 101 +++++++++--------- .../stripe-platform-refund-v1/contract.json | 2 +- .../corpus-manifest.json | 2 +- 14 files changed, 159 insertions(+), 119 deletions(-) diff --git a/bindings/fixtures/gateway/independent-mutation-differential-report.json b/bindings/fixtures/gateway/independent-mutation-differential-report.json index cecfe9037..a38c71544 100644 --- a/bindings/fixtures/gateway/independent-mutation-differential-report.json +++ b/bindings/fixtures/gateway/independent-mutation-differential-report.json @@ -460,7 +460,7 @@ ] } ], - "native_corpus_sha256": "5a77da8180e7b57644038325ab32813f49e3b1de9561d167c079c01695c9d0c6", + "native_corpus_sha256": "8143260b965a731f3f46a3aef5d642cb1bd82ab12729ff35c5c82b3bac60b926", "schema": "auths.ap074-independent-mutation-differential/1", "scope": "test-only native verified compilation and response classification compared with retained independent references; no admission, provider I/O, production qualification or AP070 guarantee", "source_sha256": { diff --git a/bindings/fixtures/gateway/native-independent-mutation-differential.json b/bindings/fixtures/gateway/native-independent-mutation-differential.json index 95ac3eb1b..e718d20da 100644 --- a/bindings/fixtures/gateway/native-independent-mutation-differential.json +++ b/bindings/fixtures/gateway/native-independent-mutation-differential.json @@ -30,7 +30,7 @@ }, "native_accepted": true, "action_commitment": "66f58a580076258123d0aed9be63ebe8087fa1687b45822f54b2ee620906a87f", - "effect_id": "5f98943a2e3228a3e4917c9b78f1083f9a0b5999844e80075a8f605171c6c71d", + "effect_id": "13c7e586ca460e607265afc62a8dd75b48af517ff4dc7e70af1709fde54a9f0e", "request": { "method": "PATCH", "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", @@ -52,7 +52,7 @@ }, "native_accepted": true, "action_commitment": "39e92faea5b0ab1b149d3960897bcd767e7609229a9699bd05b7c0a9e89cba81", - "effect_id": "1402dec6c48b0566e052a45b4d57b76900468a6a1013186e866fdf536a0ac5fb", + "effect_id": "ff47b214691f1f3348075656d5af56d931dbc73467bcb115035c682aa7aa0935", "request": { "method": "PATCH", "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", @@ -155,7 +155,7 @@ }, "native_accepted": true, "action_commitment": "242d5ec4433731ba499ce0817cd313059a151268be3441fb29d37e886518ca53", - "effect_id": "a3d84a833afcd6dbd2360777ba94100bcbfa822f7c9022c89ce683a1246d2852", + "effect_id": "911171aa618f12d14a327af800bc7e0ba20904eb38379d548ea8e922c97bf607", "request": { "method": "PATCH", "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recTEST0000000001", @@ -209,7 +209,7 @@ }, "native_accepted": true, "action_commitment": "00a098319fe0bd89dfcc0a0b59f35e66e10bce49646a5b8194f083b4a359f65e", - "effect_id": "5d5324a5aa20adcfcda73d4943f4bca88bb40b0c917f3f2dbf402284eb499436", + "effect_id": "0b3294dfcf8a99fba86a0de5a4571301f3fcd9a62a4ff5a065d728b53bd37881", "request": { "method": "PATCH", "url": "https://api.airtable.com/v0/appQD3Qf0YFBCW9bV/tblBx2jwe0IsPYRKT/recOTHER000000001", @@ -361,7 +361,7 @@ }, "native_accepted": true, "action_commitment": "a48e849c7bf68005ca5ddae4f85e4606edf94ecb84b06b59d29aedae31bb2eb6", - "effect_id": "0f98ac340142839f4f75718ce23cace9d794382ecd20774096ad6100c10da5b6", + "effect_id": "7096d2e809b2dc858f85e16559aa3dda39d8a9c3b0ed7f45a33699f90a789bac", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", @@ -393,7 +393,7 @@ }, "native_accepted": true, "action_commitment": "28a7460889975f09f92c7b70270433b895fd71347868d2491fc1d1c6ab8fc9d1", - "effect_id": "ddf1e8f9ad3fb48dabfea3d09254cb9624277762fb8e41d7c7f3c6a6a1711aa1", + "effect_id": "6bdabe26c35ad0ac20093399a5b43774bec15543749e9d94d9fcbba5711feee5", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", @@ -511,7 +511,7 @@ }, "native_accepted": true, "action_commitment": "2e112296fad14010df8203d13a6947493c2fbcebfd1857180558671ff435048b", - "effect_id": "9cde1e05aea4849c8b57aa2bcc88b8ec130e595cede5f70449f604352efa332c", + "effect_id": "6953184820c91dd6f0f0d2891e0bdf9ce1dd8c5caa7993e87dfd064d0805feaf", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", @@ -543,7 +543,7 @@ }, "native_accepted": true, "action_commitment": "d6b9319f1bca77084049edd604e007786362b2b9321193dd6dd82eec2bceb19f", - "effect_id": "b7dc642d7e76d0486ead39a2f7320d1b851d2d2e07cea3b6acb84c1ea1e869a4", + "effect_id": "9fff22ed5b0ac89ebc1f256da7f541dabaab71eb5e16e86c73fc1de6b17f7448", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", @@ -575,7 +575,7 @@ }, "native_accepted": true, "action_commitment": "7d20d9a26aca455a9533ce4d7638fef508cec323578db89772d05641edc3a1fa", - "effect_id": "51f5b71f4d573dfbbb4cd5955cae945461b5818930fb70261f121bbdae22afee", + "effect_id": "3509a6d2f9df99434c80753891507d339490a746242852271f985cf355a2f250", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", @@ -675,7 +675,7 @@ }, "native_accepted": true, "action_commitment": "37175b71d9b0df38bf46ebf96ecdd5b761295b7d08f5a24e6ee3d7ee6706aa67", - "effect_id": "74de469548c6e5a3ebb5b1598a977a8d33e079203f879b2e91b255adf6c261dc", + "effect_id": "fcc892e5890a280a48f514a916c3a9c1f090ca6fbd916653c796b5629553f287", "request": { "method": "POST", "url": "https://api.stripe.com/v1/refunds", diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl index cc8225b8e..a6eecb74f 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/README.md.tmpl @@ -169,6 +169,7 @@ gateway is running: ```sh /path/to/auths-gateway audit-export --state-dir enforcement/gateway \ + --admin-socket run/admin.sock \ --bundle audit/bundle.json --out audit/private-bundle.json ``` diff --git a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl index f48650db8..ba019b5d7 100644 --- a/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl +++ b/bindings/python/python/auths/_templates/stripe-refund-approval/lib/selftest.py.tmpl @@ -947,6 +947,7 @@ def _run(config: Dict[str, Any], report: Dict[str, Any], key_file: Path, started status, exported, stderr = commands.run("export") expect(status == 0, f"bin/export: {exported} {stderr}") gateway_json(config, "audit-export", "--state-dir", str(STATE), + "--admin-socket", str(RUN / "admin.sock"), "--bundle", str(AUDIT / "bundle.json"), "--out", str(AUDIT / "private-bundle.json")) bundle = read_json(AUDIT / "private-bundle.json") unrecorded = {entry["operation_id"] for entry in bundle["entries"] if entry.get("outcome_b64") is None} diff --git a/examples/stripe-refund-approval/README.md b/examples/stripe-refund-approval/README.md index 842d2399c..b17eb1f6c 100644 --- a/examples/stripe-refund-approval/README.md +++ b/examples/stripe-refund-approval/README.md @@ -287,6 +287,11 @@ auths-gateway audit-export --state-dir "$WORK/gateway" \ --bundle audit-bundle.json --out "$WORK/private-audit-bundle.json" ``` +The automated journeys capture this private snapshot before their deliberate +old-backup restoration. Their later offline audit checks that retained signed +snapshot. A separate export after restoration must contain only the operation +actually retained or resubmitted; missing journal evidence is never recreated. + It holds one entry per operation ID: the first submission, or a later one that the gateway recorded in place of a first one it did not. Resubmissions of an operation ID are not in the bundle; the gateway's attempt store is the diff --git a/examples/stripe-refund-approval/journey.py b/examples/stripe-refund-approval/journey.py index 6eff01cc9..08bb4a4c4 100644 --- a/examples/stripe-refund-approval/journey.py +++ b/examples/stripe-refund-approval/journey.py @@ -1193,6 +1193,26 @@ def checked(operation: str, amount: int, control: Dict[str, Any], **extra: str) for case in ("refund-1-replay", "refund-8-reuse", "refund-2-retry", "refund-9-precheck"): expect(results[case]["provider_requests"] == 0, f"{case} reached the provider") + # Preserve operator-private signed evidence before the deliberate rollback. + # The later offline audit evaluates this historical snapshot, not the restored store. + bundle_path = journey.work / "audit-bundle.json" + journey.step( + "export audit bundle", + lambda: journey.run( + PYTHON, + "refunds.py", + "export", + "--state", + str(journey.state), + "--out", + str(bundle_path), + ), + ) + private_bundle = journey.work / "private-audit-bundle.json" + journey.run(journey.gateway, "audit-export", "--state-dir", str(journey.gateway_state), + "--bundle", str(bundle_path), "--out", str(private_bundle)) + bundle_path = private_bundle + state_loss: Optional[Dict[str, Any]] = None if not live: for operation in before_lease: @@ -1287,25 +1307,17 @@ def lose_attempts_and_resubmit() -> Dict[str, Any]: ) refunds_created = {entry["refund"] for entry in writes if entry["refund"]} expect(len(refunds_created) == 1, f"expected 1 refund, saw {sorted(refunds_created)}") + restored_bundle = journey.work / "restored-private-audit-bundle.json" + journey.run(journey.gateway, "audit-export", "--state-dir", str(journey.gateway_state), + "--bundle", str(bundle_path), "--out", str(restored_bundle)) + restored = json.loads(restored_bundle.read_text()) + retained = {entry["operation_id"] for entry in restored["entries"] + if entry.get("outcome_b64") is not None} + expect(retained == {"refund-1"}, "restored store manufactured lost audit evidence") + state_loss["retained_audit_operations"] = sorted(retained) + state_loss["historical_audit_export_preserved"] = True + - # README step 8: the audit bundle. - bundle_path = journey.work / "audit-bundle.json" - journey.step( - "export audit bundle", - lambda: journey.run( - PYTHON, - "refunds.py", - "export", - "--state", - str(journey.state), - "--out", - str(bundle_path), - ), - ) - private_bundle = journey.work / "private-audit-bundle.json" - journey.run(journey.gateway, "audit-export", "--state-dir", str(journey.gateway_state), - "--bundle", str(bundle_path), "--out", str(private_bundle)) - bundle_path = private_bundle journey.stop() # README step 9: the offline audit, with the gateway stopped. The diff --git a/examples/stripe-refund-approval/typescript/journey.ts b/examples/stripe-refund-approval/typescript/journey.ts index 1aff0bd59..79b9b578b 100644 --- a/examples/stripe-refund-approval/typescript/journey.ts +++ b/examples/stripe-refund-approval/typescript/journey.ts @@ -887,6 +887,17 @@ async function main(): Promise { expect(results[case_]!.provider_requests === 0, `${case_} reached the provider`); } + // Preserve private signed evidence before deliberate rollback. The offline + // auditor evaluates this historical snapshot, not the restored store. + let bundlePath = join(journey.work, "audit-bundle.json"); + await journey.step("export audit bundle", () => journey.run(process.execPath, [ + REFUNDS, "export", "--state", journey.state, "--out", bundlePath, + ])); + const privateBundle = join(journey.work, "private-audit-bundle.json"); + journey.run(journey.gateway, ["audit-export", "--state-dir", journey.gatewayState, + "--bundle", bundlePath, "--out", privateBundle]); + bundlePath = privateBundle; + let stateLoss: Json | null = null; if (!live) { for (const operation of Object.keys(beforeLease)) { @@ -974,17 +985,18 @@ async function main(): Promise { `resubmitted refund-1 was not de-duplicated: ${JSON.stringify(writes[2])}`); const created = new Set(writes.map((entry) => entry.refund).filter((refund) => refund)); expect(created.size === 1, `expected 1 refund, saw ${JSON.stringify([...created])}`); + const restoredBundle = join(journey.work, "restored-private-audit-bundle.json"); + journey.run(journey.gateway, ["audit-export", "--state-dir", journey.gatewayState, + "--bundle", bundlePath, "--out", restoredBundle]); + const restored = JSON.parse(readFileSync(restoredBundle, "utf8")) as { entries: Json[] }; + const retained = restored.entries.filter((entry) => entry.outcome_b64 != null) + .map((entry) => entry.operation_id as string).sort(); + expect(same(retained, ["refund-1"]), "restored store manufactured lost audit evidence"); + stateLoss.retained_audit_operations = retained; + stateLoss.historical_audit_export_preserved = true; + } - // README step 8: the audit bundle. - let bundlePath = join(journey.work, "audit-bundle.json"); - await journey.step("export audit bundle", () => journey.run(process.execPath, [ - REFUNDS, "export", "--state", journey.state, "--out", bundlePath, - ])); - const privateBundle = join(journey.work, "private-audit-bundle.json"); - journey.run(journey.gateway, ["audit-export", "--state-dir", journey.gatewayState, - "--bundle", bundlePath, "--out", privateBundle]); - bundlePath = privateBundle; const providerRequests = journey.providerEntries(); await journey.stop(); diff --git a/product/runtime/auths-gateway/src/audit_tests.rs b/product/runtime/auths-gateway/src/audit_tests.rs index f6e95a5a7..acb7b97c4 100644 --- a/product/runtime/auths-gateway/src/audit_tests.rs +++ b/product/runtime/auths-gateway/src/audit_tests.rs @@ -183,7 +183,12 @@ fn private_export_preserves_inputs_and_rejects_substituted_or_unbounded_evidence &submission, Some("untrusted-public-history"), ); - let (bytes, pins, _) = bundle(&source, &lock, &harness.context, &[inventory.clone()]); + let (bytes, pins, _) = bundle( + &source, + &lock, + &harness.context, + std::slice::from_ref(&inventory), + ); let base = json!({"schema":"auths.gateway-private-audit/1","operation_id":"private-export", "outcome_b64":signed,"pre_entry_b64":[]}); let export = || crate::PrivateAuditBundle::new(&bytes).expect("bounded inventory"); diff --git a/product/runtime/auths-gateway/src/engine.rs b/product/runtime/auths-gateway/src/engine.rs index 36f9bc90c..942545e1f 100644 --- a/product/runtime/auths-gateway/src/engine.rs +++ b/product/runtime/auths-gateway/src/engine.rs @@ -3224,7 +3224,7 @@ pub(crate) fn private_audit( facts, ) }) - .map_err(|error| error.code())?; + .map_err(crate::observer::GatewayObserverError::code)?; Ok(GatewayPrivateAudit { schema: "auths.gateway-private-audit/1", operation_id: snapshot.operation_id().as_str().to_owned(), diff --git a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs index 2213f278b..00b65d2ca 100644 --- a/product/runtime/auths-gateway/src/native_public_evidence_tests.rs +++ b/product/runtime/auths-gateway/src/native_public_evidence_tests.rs @@ -1,5 +1,6 @@ //! Native public mutation projection; protected evidence stays in the journal. use super::*; +use base64ct::{Base64UrlUnpadded, Encoding as _}; use sha2::{Digest as _, Sha256}; const CONTENT: &[u8] = b"private-mutation-evidence-canary"; @@ -145,7 +146,6 @@ fn history(backend: Backend) -> (Value, Vec, String) { panic!("configured native observer must sign"); }; assert_eq!(schema, "auths.gateway-outcome/3"); - use base64ct::{Base64UrlUnpadded, Encoding as _}; let signed_bytes = Base64UrlUnpadded::decode_vec(&observation_b64).expect("canonical signature"); private_values_absent( @@ -326,9 +326,9 @@ fn wire_cases() -> Value { json!(output) } -fn history_wire_case(kind: &str, name: &str, bytes: String, accepted: bool) -> Value { +fn history_wire_case(kind: &str, name: &str, bytes: &str, accepted: bool) -> Value { assert_eq!( - serde_json::from_str::(&bytes).is_ok(), + serde_json::from_str::(bytes).is_ok(), accepted, "{name}" ); @@ -340,15 +340,14 @@ fn history_wire_case(kind: &str, name: &str, bytes: String, accepted: bool) -> V reason = "finite native wire corpus pins every affected public decoder boundary" )] fn history_wire_cases() -> Value { - use base64ct::{Base64UrlUnpadded, Encoding as _}; let pre = json!({"outcome":"pre-entry","operation_id":"step-1","observations":1,"record_commitment":"ab".repeat(32)}); // These are data-decoding vectors, not authenticated observations. Actual // configured native signatures and private facts are checked in history(). let signed = json!({"outcome":"signed","schema":crate::OUTCOME_SCHEMA,"subject":"public-subject", "observed_at":NOW,"media_type":crate::OBSERVATION_MEDIA_TYPE,"observation_b64":"AQID"}); let mut cases = vec![ - history_wire_case("pre-entry", "valid", pre.to_string(), true), - history_wire_case("signed", "valid", signed.to_string(), true), + history_wire_case("pre-entry", "valid", &pre.to_string(), true), + history_wire_case("signed", "valid", &signed.to_string(), true), ]; for (kind, name, field, replacement, accepted) in [ ("pre-entry", "zero", "observations", json!(0), true), @@ -485,7 +484,7 @@ fn history_wire_cases() -> Value { pre.clone() }; value[field] = replacement; - cases.push(history_wire_case(kind, name, value.to_string(), accepted)); + cases.push(history_wire_case(kind, name, &value.to_string(), accepted)); } for (kind, base) in [("signed", signed), ("pre-entry", pre)] { let text = base.to_string(); @@ -498,13 +497,13 @@ fn history_wire_cases() -> Value { cases.push(history_wire_case( kind, "duplicate-member", - duplicate, + &duplicate, false, )); cases.push(history_wire_case( kind, "bom", - format!("\u{feff}{text}"), + &format!("\u{feff}{text}"), false, )); let fractional = if kind == "signed" { @@ -515,13 +514,13 @@ fn history_wire_cases() -> Value { cases.push(history_wire_case( kind, "fractional-number", - fractional.clone(), + &fractional, false, )); cases.push(history_wire_case( kind, "exponent-number", - fractional.replace("1.0", "1e0"), + &fractional.replace("1.0", "1e0"), false, )); } diff --git a/product/runtime/auths-gateway/src/observed_tests.rs b/product/runtime/auths-gateway/src/observed_tests.rs index 26db56131..66be13275 100644 --- a/product/runtime/auths-gateway/src/observed_tests.rs +++ b/product/runtime/auths-gateway/src/observed_tests.rs @@ -635,6 +635,25 @@ fn chain_harness(backend: Backend) -> Harness { ) } +fn hiding_effect_reference(bytes: &[u8]) -> String { + let decoded = + auths_codec::decode_signed_observation(bytes, &VerifierLimits::default()).expect("outcome"); + decoded + .statement() + .facts() + .as_slice() + .iter() + .find_map(|item| { + if item.name().as_str() == "effect-reference" + && let FactValue::Text(value) = item.value() + { + return Some(value.as_str().to_owned()); + } + None + }) + .expect("native hiding effect reference") +} + async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backend: Backend) { let harness = chain_harness(backend); let first = harness.sign( @@ -676,22 +695,7 @@ async fn chained_step_is_refused_until_the_previous_step_is_provider_bound(backe GatewaySubmitResult::Unknown ); let unknown = signed_bytes(harness.outcome("step-1", NOW + 10).await); - let decoded = auths_codec::decode_signed_observation(&unknown, &VerifierLimits::default()) - .expect("outcome"); - let commitment = decoded - .statement() - .facts() - .as_slice() - .iter() - .find_map(|item| { - if item.name().as_str() == "effect-reference" { - if let FactValue::Text(value) = item.value() { - return Some(value.as_str().to_owned()); - } - } - None - }) - .expect("native hiding effect reference"); + let commitment = hiding_effect_reference(&unknown); assert_eq!(stage_of(&unknown), "unknown"); assert_eq!( harness diff --git a/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs index c7b00a115..ed5de031b 100644 --- a/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs +++ b/product/runtime/auths-gateway/tests/content_journey/interface_tests.rs @@ -98,6 +98,56 @@ fn witness(state: &Path, admin: &Path, secret: &[u8]) -> Value { .clone() } +fn check_public_response(value: &mut Value, secret: &[u8]) { + if value["response"]["outcome"] == "signed" { + let response = &value["response"]; + assert_eq!(response["schema"], "auths.gateway-outcome/3"); + let bytes = + Base64UrlUnpadded::decode_vec(response["observation_b64"].as_str().expect("signature")) + .expect("base64"); + no_canaries(&bytes, secret); + let signed = + auths_codec::decode_signed_observation(&bytes, &auths_model::VerifierLimits::default()) + .expect("native canonical signature"); + assert_eq!( + signed.statement().schema().as_str(), + auths_gateway::OUTCOME_SCHEMA + ); + let names: Vec<_> = signed + .statement() + .facts() + .as_slice() + .iter() + .map(|fact| fact.name().as_str()) + .collect(); + assert_eq!( + names, + [ + "effect-reference", + "evaluated-at", + "http-status", + "recipe-reference", + "record-commitment", + "stage" + ] + ); + value["response"] = json!({"outcome":"signed", "schema":auths_gateway::OUTCOME_SCHEMA, "native_canonical_public_projection_checked":true}); + } + if value["response"]["outcome"] == "pre-entry" { + let commitment = value["response"]["record_commitment"] + .as_str() + .expect("hiding commitment"); + assert_eq!(commitment.len(), 64); + assert!( + commitment + .bytes() + .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) + ); + assert!(value["response"].get("observations_b64").is_none()); + value["response"]["record_commitment"] = json!("native-hiding-value-checked"); + } +} + fn probe(mut payload: Value, secret: &[u8]) -> Value { let distinct = payload["distinct_uid"].as_bool().expect("mode"); let admin_socket = PathBuf::from(payload["admin_socket"].as_str().expect("admin socket")); @@ -171,56 +221,7 @@ fn probe(mut payload: Value, secret: &[u8]) -> Value { .expect("case") .remove("after_ready_b64"); value["post_ready_control_frames"] = json!(count); - if value["response"]["outcome"] == "signed" { - let response = &value["response"]; - assert_eq!(response["schema"], "auths.gateway-outcome/3"); - let bytes = Base64UrlUnpadded::decode_vec( - response["observation_b64"].as_str().expect("signature"), - ) - .expect("base64"); - no_canaries(&bytes, secret); - let signed = auths_codec::decode_signed_observation( - &bytes, - &auths_model::VerifierLimits::default(), - ) - .expect("native canonical signature"); - assert_eq!( - signed.statement().schema().as_str(), - auths_gateway::OUTCOME_SCHEMA - ); - let names: Vec<_> = signed - .statement() - .facts() - .as_slice() - .iter() - .map(|fact| fact.name().as_str()) - .collect(); - assert_eq!( - names, - [ - "effect-reference", - "evaluated-at", - "http-status", - "recipe-reference", - "record-commitment", - "stage" - ] - ); - value["response"] = json!({"outcome":"signed", "schema":auths_gateway::OUTCOME_SCHEMA, "native_canonical_public_projection_checked":true}); - } - if value["response"]["outcome"] == "pre-entry" { - let commitment = value["response"]["record_commitment"] - .as_str() - .expect("hiding commitment"); - assert_eq!(commitment.len(), 64); - assert!( - commitment - .bytes() - .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) - ); - assert!(value["response"].get("observations_b64").is_none()); - value["response"]["record_commitment"] = json!("native-hiding-value-checked"); - } + check_public_response(value, secret); } for value in result["private_cli"].as_array_mut().expect("private CLI") { for field in ["stdout_b64", "stderr_b64"] { diff --git a/qualification/families/stripe-platform-refund-v1/contract.json b/qualification/families/stripe-platform-refund-v1/contract.json index bbab72093..dd0bfed03 100644 --- a/qualification/families/stripe-platform-refund-v1/contract.json +++ b/qualification/families/stripe-platform-refund-v1/contract.json @@ -1 +1 @@ -{"api_release":"2025-03-31.basil","corpus_manifest_sha256":"93ed44d2649c10d19bff36f05f727eada6793ee37f15a18ae5df4c243ce99e24","declarations":{"idempotency_sha256":"425a0dca2f279765debfc847c4a01bff60fea5be68dd9d761ae6bb60ce0b8a7b","observation_sha256":"d0ce5a34d987821c69c0a839d9ed66805c625f8324dd42031fcccf0752a8821e","recovery_sha256":"bf2303abce165c175360ac975586431bbc4cf03167489ea317a27de2f0b04abb","retention_sha256":"846c2164e26d1144d9aa146034b4f7ea4dc305136a59ffd94f999d19f2c360ee"},"environment_class":"provider-test-mode","manual_assumptions":["Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","Stripe idempotency is tested only inside the declared 86400-second retention interval.","Stripe test mode and the installed platform are checked by the declared guard on each lease.","The 50-percent payment basis is a read, not an atomic provider balance reservation.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths."],"oracle_version":"auths-reviewed-reference-v2","provider":"stripe","schema":"auths.provider-contract/1"} \ No newline at end of file +{"api_release":"2025-03-31.basil","corpus_manifest_sha256":"7d7c455ff73f294e6f5207bb754fe7669adee5b2b0660eb1bbb5cd6989248d4c","declarations":{"idempotency_sha256":"425a0dca2f279765debfc847c4a01bff60fea5be68dd9d761ae6bb60ce0b8a7b","observation_sha256":"d0ce5a34d987821c69c0a839d9ed66805c625f8324dd42031fcccf0752a8821e","recovery_sha256":"bf2303abce165c175360ac975586431bbc4cf03167489ea317a27de2f0b04abb","retention_sha256":"846c2164e26d1144d9aa146034b4f7ea4dc305136a59ffd94f999d19f2c360ee"},"environment_class":"provider-test-mode","manual_assumptions":["Fresh matching state and the action-derived echo are required; HTTP success is not effect confirmation.","Only the closed run-owned resource ledger is in scope; every cleanup must be freshly confirmed.","Stripe idempotency is tested only inside the declared 86400-second retention interval.","Stripe test mode and the installed platform are checked by the declared guard on each lease.","The 50-percent payment basis is a read, not an atomic provider balance reservation.","The provider is independently operated; availability and concurrent outside writes are not controlled by Auths."],"oracle_version":"auths-reviewed-reference-v2","provider":"stripe","schema":"auths.provider-contract/1"} \ No newline at end of file diff --git a/qualification/families/stripe-platform-refund-v1/corpus-manifest.json b/qualification/families/stripe-platform-refund-v1/corpus-manifest.json index 6fce2a03a..48512fca7 100644 --- a/qualification/families/stripe-platform-refund-v1/corpus-manifest.json +++ b/qualification/families/stripe-platform-refund-v1/corpus-manifest.json @@ -1 +1 @@ -{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"a72c557b69103a52eb477deb8364ded53cd58407b9ba7ab33ccbda74389fec1e","family":"stripe-platform-refund-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"99901e36cb7c4f5882897603c874698d582e859b5d6b08d53cd80975e89aa01c","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"bd8a01adb7a0a6f58bf1ff5f7cd7d0894515c0858b4b8b894d084454d1418df1","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"445a0db1b151e12e8ea235b097acd15d6156195d408d39b7d3095820c127c5a6","expand.py":"9b6dea7793241a767065ac0456bfef5c01cfce3f1121278240eb77fc42ea7e54","family_corpus.py":"41c267688f5a03c83548ab97c1fa7a138a511abe8a4b758ac26cc580d81718a6","family_harness.py":"33b28af00a8aa0d71796fd0b92d0601db4922c5a418a2d240acc678fff32f82d","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"cd16fda3865fa6c9ab382c7ff3e4f91713b1d1399a3e89e2123d0fb7a6abb4d1","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"ae63062de1bbcbf26691d8db7bc50926e8af5009b5fa4e3e784e22e896ee78ce","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"89f50f5bc8bccbd1219074b08d59baadf14140374d09656f6b00c3a2faedaa0e","production_setup.py":"84153c0a3bceb4f1c4d3b355c489d1c56a4552052b9fb8fcf66aadf0d65bb053","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"b7f54a3261de95c8a74ff327a53ae965bfff8156297e2020d66170bf64c35ced"} \ No newline at end of file +{"compiled_corpus_schema":"auths.qualification-corpus/3","decision_record_sha256":"abc1ee2287fa72d85d2f9bb89f5dc459789ffbf22a16a9008acfec1e22745b9a","family":"stripe-platform-refund-v1","maximum_credential_leases":64,"packet_plan_schema":"auths.qualification-packet-plan/4","phases":["offline","commissioning","live"],"profile_lock_sha256":"99901e36cb7c4f5882897603c874698d582e859b5d6b08d53cd80975e89aa01c","public_packet_schema":"auths.qualification-public-packets/4","resource_count":16,"schema":"auths.qualification-reviewed-plan/1","source_files":{"airtable_record.py":"d5bf4d750fee75f02200d180f8654f426fe738bc86a281f1d015f391cc5e67fa","airtable_resources.py":"094f7d5c52a4557261c25fba6d5f1e4938091d946a05a422417b6dea22b7e76f","application_probe.py":"5e2dd6a91eb0a2acf2df1079cead5bd67ae5d6743abce6e48201e7326f63daa2","artifact_wait.py":"56efcf5a34103955e43c1d3be7fd58843efdc8095187d74dc890cf3342863f55","author_operator.py":"bd8a01adb7a0a6f58bf1ff5f7cd7d0894515c0858b4b8b894d084454d1418df1","author_packets.py":"84d550b0f82c8501000ffde07ea13720f09caa9079b2c885f65a1f5cc08c2110","author_socket.py":"3d6a031c01d7d9a58213a8368f45b68c25081d059a8ff3cba4fe47c0f75a77fd","close_proposal.py":"9a6927722ada8eaba720ff13168101244880da3fe6f2c95f653bc3840ef81756","commission.py":"f4495d6e3d2b9c50e72e339e9571eacd9b3628ebebe7c86c601b94e785a5c9fd","common.py":"604d3d6598648fbc09611e663b4048b22fa748d0f6c6f1dbbceca5d83c02a2ce","controller_socket.py":"10519cc775e963360870eac51c7fcac1ffb988b04d5de89dac1dbf3524ba6531","custody_fault.py":"445a0db1b151e12e8ea235b097acd15d6156195d408d39b7d3095820c127c5a6","expand.py":"9b6dea7793241a767065ac0456bfef5c01cfce3f1121278240eb77fc42ea7e54","family_corpus.py":"41c267688f5a03c83548ab97c1fa7a138a511abe8a4b758ac26cc580d81718a6","family_harness.py":"33b28af00a8aa0d71796fd0b92d0601db4922c5a418a2d240acc678fff32f82d","family_operations.py":"3741c3fdbcc4ef884d36abc113706281b6dd409d90e6bbb3a4866b4a3d29beb6","fresh_evidence.py":"cb54ea66a4775c5af76fbc36c4f8c8a007c553de2b2303e80fd744aee1c54d2f","installed_submit.mjs":"9d57a91c4a052fbb9103582689ee99a6d087758dcfee00defa4c762b87187468","installed_submit.py":"f9151c2dffa1a02327b0ba05bdeb180654918a2b913195185a6649d010783dc7","journey_session.py":"3c807ce45dcabe3b39d63333872af3746fe9276aacf5eba30bf903b51d80dfef","measure.py":"b620be174bc012bc6b29f95e558fce1b6fb2cc99b5fa5a0f0c933c88696b4ca0","native_observation.py":"cd16fda3865fa6c9ab382c7ff3e4f91713b1d1399a3e89e2123d0fb7a6abb4d1","network_fault.py":"94340720d8601f79ac77b95d1e855be25195c19b67db3103bbf054d82c02472b","packet_plan.py":"ae63062de1bbcbf26691d8db7bc50926e8af5009b5fa4e3e784e22e896ee78ce","production_environment.py":"607a0bc37396a5a86da1d408b384ee4a54d920b849009717587150242bd47d73","production_journey.py":"89f50f5bc8bccbd1219074b08d59baadf14140374d09656f6b00c3a2faedaa0e","production_setup.py":"84153c0a3bceb4f1c4d3b355c489d1c56a4552052b9fb8fcf66aadf0d65bb053","provider_readback.py":"d576768208985b3544f146597d181d796f2a5e2eca5026dae3fa15cadcfe65b2","resource_io.py":"18d9b11674cc9f0df6c6050b375e476675735927bed03f5a94d78674d4a35885","resource_summary.py":"c75f3f23017529ce10197c09649e2d60b3c240b8b58992786b824e85869668e0","retained_author.py":"bfd01c7df44f5f525326dfbda13b5ebc6b854f15787a8b2923de883fe20fdcf9","sign_release.py":"d0aa7697cc6889538dfd54f9101a5b7bc2e8f7aede729da2d382b6466781df99","stripe_platform.py":"2da918e72f0ec3aed4f5a80701748e0d37c71292806bfa38c74ffbe69055c4ec","stripe_resources.py":"2e050b4f5f8654cfb3a7cf9ddaa73b3515a039d5b37071d2d9c0dbafe2561489","tls_fault.py":"10e125f9623bc32a420a1d83e6d46fe30aa1ca8ff4da97a3e2422fc0e11ec42d"},"source_recipe_sha256":"b7f54a3261de95c8a74ff327a53ae965bfff8156297e2020d66170bf64c35ced"} \ No newline at end of file From 46989b7db512f382b184125e29047984f5d9607d Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:41:39 +0900 Subject: [PATCH 123/136] chore(gateway): refresh integrated source and repair evidence --- docs/plans/0074-ci-repair-7807d04b.md | 47 +++++++++++++++++++ docs/plans/0074-implementation-status.md | 32 +++++++++++++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 6 +-- release/semantic-freeze.json | 10 ++-- 6 files changed, 89 insertions(+), 10 deletions(-) create mode 100644 docs/plans/0074-ci-repair-7807d04b.md diff --git a/docs/plans/0074-ci-repair-7807d04b.md b/docs/plans/0074-ci-repair-7807d04b.md new file mode 100644 index 000000000..174b2dd88 --- /dev/null +++ b/docs/plans/0074-ci-repair-7807d04b.md @@ -0,0 +1,47 @@ +# AP074 CI repair: 7807d04b + +Published source `7807d04bfad2a2d2dba7b8f842e27fd742a9a8ad`, draft PR213. Producer merge `81a5e41c81807ffbf08de3276fdded25e3e62129` has the same verified tree `9e97fc5a871cae92cecfff97eb8cb9d8d51ba142`. Merge parents: `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b` and source7807. + +This is a repair report, not final qualification. Snapshot:48success/15failure/17skipped/1cancelled; ten macOS jobs queued and formal-fast126807398330 running. Preserve healthy jobs. Authoritative implementation/formal/dependency/compliance/security jobs skipped after preflight failure, so their required rollups correctly failed. No retry/cancellation/coverage removal/live provider action/automatic human consent. + +## Root matrix + +| Actual failed jobs | Cause and complete repair | +| --- | --- | +| Recipe41895808306:126804868144 simulation,126807854414 Stripe candidate | `qualification.harness.reviewed-plan-drift`: ADR0014 changed outcome-v2→v3. Existing generator refreshes only Stripe decision-record digest and transitive contract digest. All exact source checks retained; downstream simulation unexecuted. | +| Python41895808782:126804869433 source contracts | Native mutation differential stale: observed trust changes commitment→effect-reference, changing ten effect IDs. Actual hosted assertion decoded; regenerated native artifact differs only in ten effect_id values. All decisions/request bytes/response cases unchanged. Independent28request/26response report regenerated. | +| SDK41895808373:126804867858 Python and126804867445 npm north-star | Operator audit export ran after deliberate rollback erased journal records. Both now export private signed historical snapshot before rollback and audit it afterward. Separate post-rollback export requires only truly retained/resubmitted refund-1. No missing evidence synthesized; every original audit/provider/tamper assertion preserved. | +| SDK41895808373:126804867717 scaffold | New audit-export omitted configured run/admin.sock. Selftest and operator README now supply explicit --admin-socket; native permission gate unchanged. | +| CI41895808417:126807398306 preflight | Strict Clippy method closure in private audit signing. Focused reproduction then found eight latent test diagnostics: cloned reference slice, two overlong functions, nested if, three use-after-statement diagnostics, owned String parameter. Helper extraction/borrowing/import placement preserves all assertions, without new allowances. | + +Job URLs use `https://github.com/auths-dev/auths-proof/actions/runs/RUN/job/JOB`. All eight failed downstream main rollups inspected: implementation result skipped, not additional source failures. + +## Focused local reproduction + +Independent isolated clone `/tmp/auths-ap074-ci-resumed-20261105`; main/AP070/AP073 untouched. + +- Authoritative `python3 qualification/reference/generate_families.py` refreshes two Stripe generated files. +- `/tmp/ap074-ci-7807-venv/bin/python -m unittest discover -s qualification/reference/tests`:104tests,2conditional skips,success0.608s (local3.13; hosted3.12). System3.10 lacks tomllib; uv3.12 has unrelated venv-loader environment failure. No repository workaround for either. +- Native exact generator with `AUTHS_UPDATE_FIXTURES=1 cargo test --locked -p auths-gateway --lib --features loopback-provider,testkit-harness observed_tests::effect_native_tests::differential_tests::native_independent_mutation_differential_fixture_is_current -- --exact`:1passed/0ignored0.10s. Unchanged check without update:1passed/0ignored0.11s. +- `python3.13 qualification/reference/ap074_differential.py --update`, then without update:2families/28requests/26responses. +- `cargo clippy --locked -p auths-gateway --all-targets --all-features -- -D warnings`:success14.53s after collecting latent diagnostics; no broad workspace rerun. +- Isolated wheel built with locked maturin1.9.6/python-extension and installed into private venv. Native binary copied read-only from main's7807-built executable, parent-confirmed provenance. Local reproduction, not hosted artifact qualification. +- Full Python and TS north-star pass: each2verified/7refused/3unverified/0inconsistent, original provider/idempotency/tamper controls, restored audit operations exactly[refund-1]. TS locally packed source uses verified7807 hosted WASM artifact13356521420 ZIP SHA256 `3f3546c5387310894f39a7f787a6160dbd9e984de256b5dd812b2e6f3e7b29ab`. +- Full generated scaffold from installed wheel passes setup/install/start/selftest/stop:2verified/3refused/3unverified/0inconsistent,8tamper detections,2provider writes, credential scan empty, original one-JSON assertions. Transient processes stopped. +- cargo fmt and staged diff checks pass. Parent explicitly requested exact staged Gitleaks8.28.0 before child commit; result appended below. + +Logs: `/tmp/ap074-ci-7807-{reference,clippy,differential,differential-check,journey,tsjourney,scaffold}.log`; two journey JSON summaries; `/tmp/ap074c7sc/audit/selftest.json`; `/tmp/ap074-ci-7807-mutation-report.json`. + +## Hosted positive evidence at source7807 + +- PG41895808323/job126804867562 success: all48 exact selectors audited from downloaded log, each once/1passed/0failed/0ignored. Actual22information pairs, matching native-log digest. Artifact13356796759 ZIP SHA256 `5a8bc47f697b8048b321c018c427e91bb20227203f3baf5214bc5eba995f5fb2` verified. Producer is merge81a5 above, not relabeled as source execution. +- Linux isolation41895808583/job126804868451: old2tests pass; new distinctUID1passed/0ignored3.49s. Artifact13356001317 ZIP `d27f4016e3b36a163a47076a4a59fec995e8dc20366cbb976e5e4edf45ea1bee` verified. Exactsource7807;33app/12admin/53CLI/5privateCLI.45then49privatefiles inaccessible; canary exclusion/native recipientACK/no extra custody-provider/source retention true. Operator audit file0600,oneverifiedentry,overwrite refusal. No hostileOS/root/provider qualification claim. +- Airtable41895808300/job126810262944:success. Artifact13355937306 ZIP `de504857e77a157a2834349508b7c138b3d5fb9547679129c3ebfc37a8967899` verified.36simulationcases/privateaudit13verified0inconsistent. Owner browser all positive flags true, exactsource7807:installedPython+TS acquisition, separate disclosure/nativeACK,0600recipientfile,no replaydelivery,loss/restart no reentry. Browser-simulated consent only;productionfalse. +- Stripe41895808302/job126810393629:success. Artifact13356986494 ZIP `1b02b10327f2eeadcdba7b89acb165783b6b629817f06c5c13a976c129540858` verified.23simulationcases/privateaudit6verified0inconsistent;productionfalse. +- Operator41895808719,gitprotocol41895808393,branch41895808466,independentGoogle41895808299 passed. Custody-live41895808322 conditional skip supplies no evidence. + +## Remaining + +Exact staged Gitleaks8.28.0 passed:12,545bytes,0findings. Official release binary verified against published checksum; `/tmp/ap074-ci-gitleaks-8.28.0/gitleaks`. Per-command unsigned child commit authorized by parent; global signing configuration unchanged and no signing key accessed. + +Preserve running formal-fast126807398330. Authoritative implementation, translated/proved qualification and required rollups remain unexecuted/failed prerequisites. Ten macOS SDK/harness jobs queued. Repaired source needs next integrated hosted cohort. Parent owns combined gateway closure/release identities/compliance/ledger. No repair publication until exact parent authorization. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index f25cc986f..397f5a883 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3899,3 +3899,35 @@ Rebuilt non-update source closure passed (1 passed / 0 ignored, 0.07 s). Semantic metadata construction passed at freeze428, portable ABI129 and public surface428; no other semantic identity increment was required. Main did not run SDK, lint, broad test or formal gates and did not inspect CI. + +## Integrated holistic CI repairs after the private-history cutover + +Integrated the CI subagent's `80b89755` as `14cdc0f7`, preserving main's cost and +strict-result work. [Its source/evidence report](0074-ci-repair-7807d04b.md) records +five actual roots and precise focused reproductions. Native audit semantics and +all existing assertions remain intact. The installed Python/TypeScript north-star +journeys now preserve operator-private signed history before intentional rollback; +a separate post-rollback export proves lost entries remain absent. The scaffold +supplies its configured private admin socket. Authoritative generators refreshed +Stripe decision-record pins and ten native differential effect IDs after the +observation-contract change. The independent28request/26response comparison is +unchanged. Clippy repairs use helpers, borrowing/import placement and a method +reference, with no new allowances or removed assertions. + +The subagent reports all focused repaired journeys and the failed native/reference/ +Clippy checks passed in its isolated checkout. These are repair reproductions, +not acceptance on the combined head. Its exact-source7807 hosted audit did verify +48 nonignored native selectors,22 information pairs, both installed demos and the +Linux33app/12admin/53CLI/5privateCLI inventory. Main did not inspect CI; new cost +and209-vector binding work still require the next integrated hosted cohort. + +Combined source-closure construction passed (1 passed / 0 ignored, 0.08 s). +The final combined closure is +`f943f5421fbaca04419bbf535f6da621cb349884fc54813695788f7f14f110db`. +Release metadata advances to freeze429, portable ABI130 and public surface429, +reflecting the repaired generated Python consumer; no other increment was required. +Rebuilt source closure and metadata construction must finish before publication. +Combined rebuilt closure check passed (1 passed / 0 ignored, 0.05 s), and the +semantic metadata constructor passed. The combined revision is ready for the +CI subagent's exact-head publication and holistic verification; no completed +acceptance or formal qualification claim is made for this new source. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index be865f17e..6026845c3 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"a8e9ae02de4589c213106fe8fb5317aa95b623d223f888da874670c487232efe"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"49a61cda5da9d2bdea6d18ee8fbdf88334f3e313bc561bf42e84e64a7c5489d7"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"9bf4a62e789a29d1ce82fcb0c2a3882775ecf4fb0e1116960cb3a61dc7efe018"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"dc497675380d761b14be6d22305a433377fa03e8c0a6601ec98f61a77d600aad"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index e800269f9..6a55d3ab8 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "e6112e97c83f4e4b422f62828b3840fa3db9a9a7a9421a0f090a401613e06f81"; + "f943f5421fbaca04419bbf535f6da621cb349884fc54813695788f7f14f110db"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 9138477e6..464ecfafe 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 428 +freeze_version = 429 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -47,7 +47,7 @@ freeze_version = 428 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 "auths.identity.protocol" = 170 "auths.modular-components" = 22 -"auths.portable-abi-bindings" = 129 +"auths.portable-abi-bindings" = 130 "auths.product.bounded-domains" = 19 "auths.product.bounded-policy" = 6 "auths.product.configuration-commitments" = 1 @@ -67,4 +67,4 @@ freeze_version = 428 "auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 84 -"auths.release.public-surface" = 428 +"auths.release.public-surface" = 429 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index f5485dcd0..16c91f305 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 428, + "freezeVersion": 429, "publicSurface": { "rustRoots": [ "auths", @@ -611,7 +611,7 @@ }, { "id": "auths.portable-abi-bindings", - "version": 129, + "version": 130, "classification": "frozen-meaning", "categories": [ "portable-abi", @@ -631,7 +631,7 @@ "core/crates/auths-model/src/lib.rs", "core/spec/v1/auths-proof.cddl" ], - "sha256": "80ef7f579a1b4eb516e9d9f3d91dbc11e079b90a042e336f614e4823084062ac" + "sha256": "8b94c46938f1163d7e14fa3f89f90ea4e88ce628b5cc87f3e428cd8cee699da8" }, { "id": "auths.product.bounded-domains", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 428, + "version": 429, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "dccc969ee724a18d8cd647f9a1d7b9235e280227fa5f110c89fa2c5db048fdf8" + "sha256": "2b7b4379ad94cf9fd87e2f6352601a5984c7c1a7eeb2500657a8809ce77bd11b" } ] } From aa7cfc7664a383c3a214fad7d6967479389fb05f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 04:55:38 +0900 Subject: [PATCH 124/136] test(gateway): generate concurrent durable replay histories --- .github/workflows/postgres-lifecycle.yml | 17 + docs/plans/0074-assurance-map.md | 70 ++++ docs/plans/0074-generated-histories.md | 48 +++ docs/plans/0074-implementation-status.md | 41 ++- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_generated_history_tests.rs | 311 ++++++++++++++++++ .../auths-gateway/src/native_process_tests.rs | 2 +- .../src/native_recovery_actor_tests.rs | 2 + .../auths-gateway/src/semantic_closure.rs | 2 +- 9 files changed, 489 insertions(+), 6 deletions(-) create mode 100644 docs/plans/0074-assurance-map.md create mode 100644 docs/plans/0074-generated-histories.md create mode 100644 product/runtime/auths-gateway/src/native_generated_history_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 119ef4e0e..ce7b3d428 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -117,6 +117,23 @@ jobs: path: target/ap074-native-cost/ if-no-files-found: error retention-days: 30 + - name: Execute generated concurrent native histories on both durable adapters + env: + AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require + AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt + AUTHS_POSTGRES_SERVER_NAME: localhost + AUTHS_AP074_HISTORY_DIRECTORY: target/ap074-generated-histories + AUTHS_EVIDENCE_SOURCE_REVISION: ${{ github.event.pull_request.head.sha || github.sha }} + run: | + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::generated_history_tests::native_file_generated_concurrent_histories + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::generated_history_tests::postgres_native_generated_concurrent_histories + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + if: always() + with: + name: ap074-generated-histories-${{ github.run_id }}-${{ github.run_attempt }} + path: target/ap074-generated-histories/ + if-no-files-found: error + retention-days: 30 - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 with: python-version: "3.12" diff --git a/docs/plans/0074-assurance-map.md b/docs/plans/0074-assurance-map.md new file mode 100644 index 000000000..0b894a1a1 --- /dev/null +++ b/docs/plans/0074-assurance-map.md @@ -0,0 +1,70 @@ +# AP074 assurance boundary and evidence map + +This maps AP074 §9's six conditional properties to shipping source and required +runtime evidence. It is a producer/assumption map, not an execution receipt or a +whole-system proof. Every final claim still needs the corresponding exact-source +hosted artifacts. The acceptance ledger records that execution separately. + +## Pure proof surface and runtime obligations + +| Property | Shipping predicates and native owner | Evidence outside the pure proof | +| --- | --- | --- | +| Authority preservation | `effect::ApprovedEffect::validate_for_entry` recompiles the original native proof/action and compares the complete binding. `entry::EntryValidation::validate` reads connection/configuration dependencies and samples current time under the adapter fence before invoking it. `auths_gateway_kernel::order::next_step` orders the abstract validation/reservation/grant/send events. | Native signatures, trust installation, exact approval and clock authenticity are runtime obligations. Native dependency, mutation-entry and disclosure-entry corpora exercise independent authority/approval/observation expiry, changed threshold selection and withdrawal on both stores. Boolean ordering premises alone do not prove cryptographic authority. | +| Effect preservation | `auths_gateway_kernel::construct::{construct_write,construct_action_read,construct_credential_read}` implement the pure closed request leaves. `effect::BoundEffect` retains sealed native authority, the immutable binding and compiler result. `transition::valid_transition` requires unchanged fixed bytes and protocol/plan. | Reviewed recipe meaning, canonical codec correctness and credential insertion are explicit boundaries. The native effect/review corpus, two-recipe independent differential and installed owner journey compare the actual request against the exact approved review. TLS/provider behavior remains external. | +| Single-grant safety | `transition::{stage_transition_allowed,entry_kept,valid_transition}` permit an entry addition only at the reservation-to-grant edge and retain it afterward. `order::next_step` reaches send only after the new grant acknowledgement. Native mutation/acquisition/disclosure grant methods return consumed permits only after successful fenced persistence. | File/PostgreSQL atomicity and truthful durability acknowledgement are assumptions checked by independent-process races, process crashes, file failures, partial SQL batches and real lost COMMIT replies. Generated concurrent native histories add an independent set-of-entered-operations oracle. No persisted byte string recreates a permit. | +| Capacity conservation | Native `store::{reserve_with_claim,frontier,cumulative}` and the typed acquisition/disclosure allocation paths own reservations in the same admission batch. Final entry validates retained counters/allocation rather than charging again. Kernel transition fixed-byte equality preserves admitted charge facts. | Arithmetic/policy predicates do not prove database atomicity or actual occupancy. Native lifetime/fixed-window count and sum races, restart/retention and fault corpora check actual permanent/window rows on both adapters. Unknown stays charged; elapsed time, absent evidence or administrative annotation supplies no refund fact. | +| Revocation ordering | `entry::EntryValidation::validate`, `connection` validation and `configuration::SharedConfiguration::entry_snapshot` use snapshots held under the same fence as the final attempt replacement. Connection/configuration writers participate in that fence. | File `flock` is single-host; PostgreSQL uses the maintained transaction/advisory-lock contract across hosts. Native worker/operator schedules order withdrawal before versus after grants for mutation, acquisition and disclosure, including waits and physically distinct dependency records. Earlier committed grants retain their documented semantics. | +| Evidence soundness | `transition::{protocol_consistent,response_kept,acknowledgement_kept,valid_transition}` keep distinct protocol facts and immutable evidence. Native recipient authentication/ACK validation and recovery evidence-link validation establish the facts before projection. `observer` separates signed public history from full private audit; the auditor rechecks complete facts. | Signatures, recipient/channel/source binding, bounded HTTP evidence and provider linkage are not proved by nonempty model byte fields. Real recipient ACK substitution/loss, independent recovery, privacy and installed-interface tests supply that evidence. State equality, a response, an ACK and declared provider linkage remain distinct claims. | + +The native adapters call the shared `store::valid_transition`, which invokes the +translated `auths_gateway_kernel::transition::valid_transition` over both typed +record projections **and** validates the complete new protocol record. The model +does not replace canonical record validation or reinterpret provider fields. + +## Formal source link + +The authoritative extraction inventory is +[`qualification.toml`](../../formal/qualification/aeneas/qualification.toml). +It names the actual shipping gateway-kernel files and selected functions, +including construction, submission order, transition/presence, recovery and +ratio leaves. The qualification reproduces translation twice under pinned +Charon/Aeneas toolchains. Generated Lean files and +[`Gateway.lean`](../../formal/qualification/aeneas/cases/Gateway.lean) feed the +reviewed refinement claims in +[`assurance-manifest-v1.toml`](../../formal/assurance-manifest-v1.toml). + +The compiled assurance audit checks statement identities and transitive axioms; +Kani's record-table harness checks bounded representations, including every +protocol/stage pair and illegal edge under its byte bounds. Sequential generated +file-store properties and actual durable process histories complement this pure +surface. The existing formal mutation inventory includes gateway translations in +campaign s3. Its source freshness and adequacy must pass the existing release +gate; its presence in the repository is not a fresh execution result. + +Codecs, cryptography, full verifier control flow, store implementation, clocks, +networking, recipient behavior and provider behavior remain outside the pure +gateway proof. Full API/record validation, current native authority and concrete +adapter/transport evidence are mandatory premises, never optional exclusions +that waive an AP074 security invariant. + +## Operational limits of the claims + +File durability assumes acknowledged sync/rename and private storage on one +trusted host. PostgreSQL durability assumes the maintained TLS/isolation/commit +configuration and participating writers. Both require current epoch/configuration +and declared retention/rollback floors. A malicious operator, malicious host, +unsupported whole-store rollback and independent external provider writers are +not prevented by Rust types or these tests. + +The installed Linux inventory checks the actual unprivileged app account against +managed sockets, credentials, private files and every application/CLI route. +AP070 remains a separately application-owned reference with its own narrower +claims. It cannot receive managed grants, permits or credentials or supply a +second decision for the same managed operation. Its receipts are not native +entry, recovery or qualified execution evidence. + +The [cost evidence](0074-native-cost-evidence.md) and +[generated concurrent histories](0074-generated-histories.md) describe additional +producers and their limitations. Neither a producer definition nor a successful +artifact constructor closes A01–A22; final exact-revision verification remains +required. diff --git a/docs/plans/0074-generated-histories.md b/docs/plans/0074-generated-histories.md new file mode 100644 index 000000000..6d8061f3a --- /dev/null +++ b/docs/plans/0074-generated-histories.md @@ -0,0 +1,48 @@ +# AP074 generated concurrent durable histories + +`native_recovery_actor_tests::generated_history_tests` adds generated concurrent +mutation histories to the existing all-protocol predicate proofs, sequential +property tests and native crash/capacity/dependency matrices. The oracle is an +independent set of previously entered logical operations. It does not invoke the +shipping reducer to decide its expected number of new external entries. + +Four deterministic seeds generate different first-admission orders over four +native-approved effects plus subsequent mixed replay schedules. Each history +has eight concurrent rounds: duplicate first admission, two distinct first +admissions, mixed new/replayed admission, and five generated replay pairs. +Two real OS workers independently reopen the maintained store, load the installed +engine, synchronize on a bounded TCP start barrier, then submit the original +native proof/action/exact approval. Actual writer-fence order is chosen by the OS. + +For every round the test compares the model's expected new entries with both +the real local HTTP capture delta and actual native transport witnesses. It +checks native journal stage and byte-for-byte retention of every earlier record. +The source baseline is unchanged throughout. A final concurrent negative uses +fresh native resource authority for another operation with an earlier exact +approval. Both workers must refuse before credential lease, reservation or transport; +the new operation must remain absent and all earlier records remain unchanged. + +Each backend therefore produces four histories, 32 positive concurrent rounds, +four negative concurrent rounds, 72 generated worker processes, 16 new effect +entries and four baseline writes. The fresh process for every event also checks +that reopening cannot regenerate a permit from retained Unknown history. + +The PostgreSQL workflow explicitly executes the file and TLS PostgreSQL selectors +and uploads `ap074-generated-histories--`. The two JSON artifacts +include exact source/checkout revisions, gateway source closure, generated plans, +actual native results and observed HTTP/native counters. They retain real +scheduling outcomes rather than pretending concurrent observations have one +canonical byte representation. They expose no private proof, review, approval, +record body, response body or credential. + +This producer covers generated concurrent single-grant/replay histories. It +does not independently prove every protocol transition, conservation of bounded +count/sum capacity, crash durability, hostile-process containment or provider +qualification. Those remain the responsibility of the existing source-linked +kernel/refinement and file/PostgreSQL fault, capacity, entry, disclosure and +independent-recovery evidence. No production decision, journal or retry owner is +added. Hosted execution is pending; this source does not close A20 on its own. + +Installed trust, signer keys, provider credentials and clock are explicit synthetic +fixtures. Ordinary native verification and exact signatures still execute; the +cohort does not claim human presence or an authenticated production clock. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 397f5a883..dded19d05 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -2,9 +2,10 @@ ## Resumed — 5 November 2026 -The user reactivated the complete AP074 goal. Main is reconciling the saved -signed-output/private-audit checkpoint with the published `3cb2caad` fixes and -finishing the direct native/SDK/demo cutover. The original full objective and +The user reactivated the complete AP074 goal. The signed-output/private-audit checkpoint is +reconciled and published as `7807d04b`. Combined revision `46989b7d` also includes +native cost producers, strict 209-vector result parity and the holistic CI repair +batch. Main is adding generated concurrent histories and auditing final closure. The original full objective and acceptance requirements remain in force; no completion claim is made. The CI subagent reports the published `3cb2caad` cohort is terminal: 88 passed, @@ -3931,3 +3932,37 @@ Combined rebuilt closure check passed (1 passed / 0 ignored, 0.05 s), and the semantic metadata constructor passed. The combined revision is ready for the CI subagent's exact-head publication and holistic verification; no completed acceptance or formal qualification claim is made for this new source. + +## Generated concurrent native histories and assurance boundary map + +Added test-only deterministic event generation with an independent set-of-entered +operations oracle. Each durable adapter has four seeded histories,32 positive +concurrent rounds and four fresh-operation/old-approval negative rounds.72 fresh +OS workers reopen the actual store, synchronize at a bounded start barrier and +call the ordinary installed native engine. Every round checks real HTTP entry +counts and native transport witnesses, typed journal state, exact earlier record +bytes and unchanged original source. The model chooses only expected entry counts; +it supplies no authority, journal decision, grant, acknowledgement or retry. + +The new explicit workflow selectors preserve the existing48 adapter selector log +and two cost selectors and upload actual scheduling results in separate exact- +source artifacts. No canonical scheduling outcome is fabricated. Details and +limitations are in [generated histories](0074-generated-histories.md). This adds +mutation single-grant/replay evidence; existing all-protocol formal, capacity, +crash, dependency, disclosure and recovery producers remain mandatory. + +Added the [six-property assurance map](0074-assurance-map.md), naming shipping pure +predicates, their actual runtime callers, adapter/crypto/transport premises and +concrete evidence families. It identifies the pinned translation/refinement, +compiled theorem audit, bounded Kani and mutation source links without treating +nonempty model evidence as authenticated runtime truth. No security invariant or +acceptance row was weakened or declared complete. + +Source-closure construction passed (1 passed / 0 ignored,0.09 s); it compiled the +new cohort without executing it. Actual generated-history and cost runs await +hosted CI. Main did not inspect CI, run local broad suites or change AP070/AP073. +Rebuilt source-closure verification passed (1 passed / 0 ignored,0.07 s), and +semantic metadata construction passed without release identity changes. Final +source closure is `0057a01cccebd4fbc6b16c08a1a042f4af83ceee5e21e67a72c0c08c4bce88a1`. +No local generated-history execution is claimed; the new explicit CI producers +must execute before their evidence is accepted. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 6026845c3..35f747593 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"8bb6b7609cdb0eefcb773d49fe912de0f54d5a6b5ccd2fe1070feea7c4dcdd2a"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"4e4c6007b104a806b1fb26ea024b4a94e4901b8eecaca01edeb02fb491c4b212"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"a1808b80b958601a7b2f46b48aa2070858c413fde1ead514707fc48c6e285f68"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_generated_history_tests.rs b/product/runtime/auths-gateway/src/native_generated_history_tests.rs new file mode 100644 index 000000000..2cc529c65 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_generated_history_tests.rs @@ -0,0 +1,311 @@ +//! Generated concurrent native histories. The independent oracle remembers +//! entered operations; real OS workers reopen durable state and use local HTTP. +use super::{Case, Outcome, author, controls, input, record, retain}; +use crate::native_crash_tests::{Peer, pause_at}; +use crate::native_process_tests::{NOW, Setup, load_controlled_engine, private, runtime}; +use crate::store_testkit::{Backend, TestAttempts, postgres_configured}; +use crate::{GatewayAttemptKey, GatewayRecordKind, GatewaySubmitResult, LogicalOperationId}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; +use std::{ + collections::{BTreeMap, BTreeSet}, + io::Write as _, + net::TcpListener, +}; + +const ENVIRONMENT: &str = "AUTHS_AP074_GENERATED_HISTORY_PEER"; +const SELECTOR: &str = + "native_recovery_actor_tests::generated_history_tests::native_generated_history_peer"; + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Worker { + installation: Setup, + operation: String, + approval_operation: String, + result: String, +} + +#[test] +fn native_generated_history_peer() { + let Some(path) = std::env::var_os(ENVIRONMENT) else { + return; + }; + let worker: Worker = serde_json::from_slice(&std::fs::read(path).expect("private input")) + .expect("closed worker input"); + let store = TestAttempts::attach( + Backend::parse(&worker.installation.backend), + &worker.installation.location, + ); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &worker.installation, + &worker.result, + store.attempts().clone(), + controls(false), + )); + let (proof, action, _) = input(&worker.installation.root, &worker.operation); + let (_, _, approval) = input(&worker.installation.root, &worker.approval_operation); + pause_at(worker.installation.barrier_port); + let result = runtime.block_on(engine.submit(&proof, &action, approval)); + private( + &worker.installation.root.join(&worker.result), + &serde_json::to_vec(&json!({"pid":std::process::id(),"result":result, + "witness":engine.execution_witness()})) + .expect("public result"), + ); +} + +fn plan(seed: u32) -> Vec<[u32; 2]> { + let mut order = [0, 1, 2, 3].map(|index| (index + seed) % 4); + if seed % 2 == 1 { + order.reverse(); + } + let mut rounds = vec![ + [order[0], order[0]], + [order[1], order[2]], + [order[3], order[0]], + ]; + let mut state = seed + 1; + for _ in 0..5 { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + rounds.push([(state >> 16) % 4, (state >> 24) % 4]); + } + rounds +} + +fn operation(index: u32) -> String { + format!("generated-{index}") +} + +fn workers(case: &Case, round: usize, operations: [&str; 2], approvals: [&str; 2]) -> [Value; 2] { + let listener = TcpListener::bind("127.0.0.1:0").expect("start barrier"); + listener.set_nonblocking(true).expect("bounded accept"); + let mut peers = Vec::new(); + let mut paths = Vec::new(); + for slot in 0..2 { + let mut installation = case.setup.installation.clone(); + installation.barrier_port = listener.local_addr().expect("port").port(); + let result = format!("generated-result-{round}-{slot}"); + let path = installation + .root + .join(format!("generated-input-{round}-{slot}")); + paths.push(installation.root.join(&result)); + private( + &path, + &serde_json::to_vec(&Worker { + installation, + operation: operations[slot].to_owned(), + approval_operation: approvals[slot].to_owned(), + result, + }) + .expect("private setup"), + ); + peers.push(Peer::start(&path, SELECTOR, ENVIRONMENT)); + } + let mut first = peers[0].await_pause(&listener); + let mut second = peers[1].await_pause(&listener); + first.write_all(b"G").expect("release first"); + second.write_all(b"G").expect("release second"); + for peer in &mut peers { + peer.finish(); + } + let results: [Value; 2] = paths + .into_iter() + .map(|path| { + serde_json::from_slice(&std::fs::read(path).expect("worker output")).expect("result") + }) + .collect::>() + .try_into() + .expect("two workers"); + assert_ne!(results[0]["pid"], results[1]["pid"]); + for result in &results { + assert_ne!(result["pid"], json!(std::process::id())); + } + results +} + +fn no_new_record(store: &TestAttempts, operation: &str) { + let key = GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + author::recipe().namespace(), + &LogicalOperationId::parse(operation).expect("operation"), + ) + .expect("key"); + assert!( + store + .raw() + .load(GatewayRecordKind::Attempt, &key) + .expect("native store") + .is_none() + ); +} + +fn prepared(backend: Backend) -> Case { + let case = Case::start(backend, Outcome::LostEcho); + let runtime = runtime(); + let (engine, _) = runtime.block_on(load_controlled_engine( + &case.setup.installation, + "generated-author", + case.store.reopen(), + controls(false), + )); + for name in (0..4) + .map(operation) + .chain(["generated-approval-mismatch".to_owned()]) + { + let signed = author::signed(&author::write_call(&name), false); + let effect = runtime + .block_on(engine.compile_effect(&signed.proof, &signed.action)) + .expect("native compile"); + retain( + &case.setup.installation.root, + &name, + &signed, + &author::approval(&effect, NOW), + ); + } + case +} + +fn check_retained( + case: &Case, + entered: &BTreeSet, + retained: &mut BTreeMap>, +) { + for name in entered { + let bytes = record(&case.store, name); + let journal: Value = serde_json::from_slice(&bytes).expect("native journal"); + assert_eq!(journal["state"]["facts"]["stage"], "unknown"); + if let Some(original) = retained.get(name) { + assert_eq!( + &bytes, original, + "reopen/replay changes no historical bytes" + ); + } else { + retained.insert(name.clone(), bytes); + } + } + assert_eq!(record(&case.store, super::SOURCE), case.original); +} + +fn history(backend: Backend, seed: u32) -> Value { + let case = prepared(backend); + let mut entered = BTreeSet::new(); + let mut retained = BTreeMap::new(); + let mut rounds = Vec::new(); + for (index, pair) in plan(seed).into_iter().enumerate() { + let names = pair.map(operation); + let new_entries = names + .iter() + .filter(|name| !entered.contains(*name)) + .collect::>() + .len(); + let before = case.provider.requests.lock().expect("HTTP capture").len(); + let results = workers(&case, index, [&names[0], &names[1]], [&names[0], &names[1]]); + let after = case.provider.requests.lock().expect("HTTP capture").len(); + assert_eq!( + after - before, + new_entries, + "independent single-grant model" + ); + let write_entries: u64 = results + .iter() + .map(|result| { + result["witness"]["write_transport_entries"] + .as_u64() + .expect("actual native witness") + }) + .sum(); + assert_eq!(write_entries, new_entries as u64); + for result in &results { + let result: GatewaySubmitResult = + serde_json::from_value(result["result"].clone()).expect("closed native result"); + assert!( + matches!( + result, + GatewaySubmitResult::Unknown | GatewaySubmitResult::Reserved { .. } + ), + "a concurrent replay may observe a reservation, never a fabricated response" + ); + } + for name in &names { + entered.insert(name.clone()); + } + check_retained(&case, &entered, &mut retained); + rounds.push(json!({"round":index,"operations":names,"expected_new_entries":new_entries, + "actual_http_entries":after-before,"write_transport_entries":write_entries, + "native_results":results.iter().map(|value| value["result"].clone()).collect::>(), + "distinct_os_workers":true,"historical_bytes_preserved":true})); + } + assert_eq!(entered.len(), 4); + let before = case.provider.requests.lock().expect("HTTP capture").len(); + let refused = workers( + &case, + 8, + ["generated-approval-mismatch"; 2], + ["generated-0"; 2], + ); + for result in &refused { + assert_eq!( + result["result"], + json!({"outcome":"not-entered","code":"gateway.effect.approval"}) + ); + assert_eq!(result["witness"]["write_transport_entries"], 0); + assert_eq!(result["witness"]["credential_lease_calls"], 0); + } + assert_eq!( + case.provider.requests.lock().expect("HTTP capture").len(), + before + ); + no_new_record(&case.store, "generated-approval-mismatch"); + check_retained(&case, &entered, &mut retained); + assert_eq!( + before, 5, + "one baseline plus four distinct approved effects" + ); + json!({"seed":seed,"rounds":rounds,"distinct_effect_entries":4, + "actual_http_entries_including_baseline":before,"fresh_operation_old_approval":refused, + "refused_operation_absent":true,"original_source_unchanged":true}) +} + +fn run(backend: Backend) { + let histories: Vec<_> = (0..4).map(|seed| history(backend, seed)).collect(); + let revision = std::process::Command::new("git") + .args(["rev-parse", "HEAD"]) + .current_dir(env!("CARGO_MANIFEST_DIR")) + .output() + .expect("revision"); + assert!(revision.status.success()); + let checkout = String::from_utf8(revision.stdout).expect("revision"); + let source = std::env::var("AUTHS_EVIDENCE_SOURCE_REVISION") + .unwrap_or_else(|_| checkout.trim().to_owned()); + assert!(source.len() == 40 && source.bytes().all(|byte| byte.is_ascii_hexdigit())); + let report = json!({"schema":"auths.ap074-generated-native-histories/1","source_revision":source, + "checkout_revision":checkout.trim(),"backend":backend.label(), + "gateway_source_closure":crate::semantic_closure::GATEWAY_SEMANTIC_CLOSURE_SHA256, + "histories":histories,"model":"set of previously entered logical operations; no reducer predicates reused", + "excluded":["all-protocol transition proof","capacity model","power loss","hostile OS","live provider qualification"]}); + if let Some(path) = std::env::var_os("AUTHS_AP074_HISTORY_DIRECTORY") { + let path = std::path::PathBuf::from(path); + std::fs::create_dir_all(&path).expect("artifact directory"); + std::fs::write( + path.join(format!("generated-history-{}.json", backend.label())), + serde_json::to_vec_pretty(&report).expect("artifact"), + ) + .expect("write artifact"); + } +} + +#[test] +#[ignore = "explicit process-history evidence cohort"] +fn native_file_generated_concurrent_histories() { + run(Backend::File); +} + +#[test] +#[ignore = "requires the maintained TLS PostgreSQL fixture"] +fn postgres_native_generated_concurrent_histories() { + assert!(postgres_configured(), "TLS PostgreSQL fixture is required"); + run(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index 3107a41c3..ecb96fcfd 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -37,7 +37,7 @@ pub(super) const NOW: u64 = 1_790_000_000; const SECRET: &[u8] = b"public-native-process-fixture"; pub(super) const CONTENT: &[u8] = b"PUBLIC-NATIVE-CONTENT"; -#[derive(Deserialize, Serialize)] +#[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub(super) struct Setup { pub(super) backend: String, diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index 2bb82e326..b684eca9b 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -39,6 +39,8 @@ mod limits_tests; mod privacy_tests; #[path = "native_cost_tests.rs"] mod cost_tests; +#[path = "native_generated_history_tests.rs"] +mod generated_history_tests; #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 6a55d3ab8..a6c1938b3 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "f943f5421fbaca04419bbf535f6da621cb349884fc54813695788f7f14f110db"; + "0057a01cccebd4fbc6b16c08a1a042f4af83ceee5e21e67a72c0c08c4bce88a1"; #[cfg(test)] mod tests { From 5acd62b0cac44edd80956d7d16eaf15483240a38 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 05:05:22 +0900 Subject: [PATCH 125/136] fix(ci): retain measured artifacts and private audit defaults --- .github/workflows/postgres-lifecycle.yml | 4 +-- .../python/tests/test_enforcement_init.py | 9 +++++-- docs/plans/0074-ci-repair-46989b7d.md | 25 +++++++++++++++++ docs/plans/0074-implementation-status.md | 27 +++++++++++++++++++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/native_cost_store.rs | 2 +- .../src/native_recovery_actor_tests.rs | 8 +++--- .../src/native_result_wire_cases.rs | 2 +- .../auths-gateway/src/semantic_closure.rs | 2 +- 9 files changed, 69 insertions(+), 12 deletions(-) create mode 100644 docs/plans/0074-ci-repair-46989b7d.md diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index ce7b3d428..fe16908bc 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -105,7 +105,7 @@ jobs: AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt AUTHS_POSTGRES_SERVER_NAME: localhost - AUTHS_AP074_COST_DIRECTORY: target/ap074-native-cost + AUTHS_AP074_COST_DIRECTORY: ${{ github.workspace }}/target/ap074-native-cost AUTHS_EVIDENCE_SOURCE_REVISION: ${{ github.event.pull_request.head.sha || github.sha }} run: | cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::cost_tests::native_file_cost_measurements @@ -122,7 +122,7 @@ jobs: AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt AUTHS_POSTGRES_SERVER_NAME: localhost - AUTHS_AP074_HISTORY_DIRECTORY: target/ap074-generated-histories + AUTHS_AP074_HISTORY_DIRECTORY: ${{ github.workspace }}/target/ap074-generated-histories AUTHS_EVIDENCE_SOURCE_REVISION: ${{ github.event.pull_request.head.sha || github.sha }} run: | cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::generated_history_tests::native_file_generated_concurrent_histories diff --git a/bindings/python/tests/test_enforcement_init.py b/bindings/python/tests/test_enforcement_init.py index be36b1cd6..71dc0eb36 100644 --- a/bindings/python/tests/test_enforcement_init.py +++ b/bindings/python/tests/test_enforcement_init.py @@ -543,15 +543,20 @@ def test_audit_passes_the_gateway_verdict_through_and_adds_no_option( pretend_setup(directory) pins = {"trusted_context_sha256": "00" * 32, "observer": "key:sha256:stand-in"} (directory / "audit" / "pins.json").write_text(json.dumps(pins)) - (directory / "audit" / "bundle.json").write_text("{}") + # Stand-in transport fixtures only: the operator's private artifact is the + # default. Poison the public inventory to detect an accidental fallback. + (directory / "audit" / "bundle.json").write_text('{"pin-mismatch": true}') + private_bundle = directory / "audit" / "private-bundle.json" + private_bundle.write_text("{}") status, report, stderr = run(directory, "audit") assert (status, report, stderr.strip()) == (1, {"entries": [], "unverified": 1}, "audit.unverified") audit = [call for call in calls(short_root) if call[0] == "audit"][-1] + assert Path(audit[audit.index("--bundle") + 1]) == private_bundle assert "--allow-unverified-refusals" not in audit assert audit[audit.index("--trusted-context-sha256") + 1] == "00" * 32 status, report, _ = run(directory, "audit", "--allow-unverified-refusals") assert status == 0 and report == {"entries": [], "unverified": 1} - (directory / "audit" / "bundle.json").write_text('{"pin-mismatch": true}') + private_bundle.write_text('{"pin-mismatch": true}') status, refused, stderr = run(directory, "audit") assert (status, refused, stderr.strip()) == (1, {"error": "audit.trust-pin-mismatch"}, "audit.trust-pin-mismatch") status, refused, _ = run(directory, "audit", "--bundle", "/etc/hosts") diff --git a/docs/plans/0074-ci-repair-46989b7d.md b/docs/plans/0074-ci-repair-46989b7d.md new file mode 100644 index 000000000..9f95e6e74 --- /dev/null +++ b/docs/plans/0074-ci-repair-46989b7d.md @@ -0,0 +1,25 @@ +# AP074 hosted repair: 46989b7d + +Published source `46989b7db512f382b184125e29047984f5d9607d`; PR merge producer `f4d421821704c809dfede654f7fbc8eb66e8a95d`, both verified tree `3bcc7b399b436ab67027732001e9eae7d0fd15d5`. Merge parents: `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b` and46989. Draft PR213 unchanged. + +Repair commit `bbb391a9afc11e04654d01ce8567c4b06897da59`, isolated clone `/tmp/auths-ap074-ci-resumed-20261105`. Five source files, no shared closure/freeze/ledger changes, no main/AP070/AP073 edits. Parent must fetch independent clone before integration. No repair publication without exact integrated-head authorization. + +## All current source roots + +- [Python source contracts126820242109](https://github.com/auths-dev/auths-proof/actions/runs/41900200180/job/126820242109):438passed/11skipped/1failed. The audit argument-forwarding stand-in fixture created public bundle.json, while the correct operator default is private-bundle.json. Repair creates the private stand-in fixture, poisons the public inventory, explicitly asserts private path forwarding, and retains exact refusal/pin/option/path-escape assertions. No fake observation used as managed execution evidence. Focused test passes1.44s; installed _enforcement_init/_profile_cli/operate/common bytes verified equal current sources (local Python3.13). +- [Repository preflight126822586483](https://github.com/auths-dev/auths-proof/actions/runs/41900199852/job/126822586483):rustfmt requires sorted cost_tests module registration. Running the subsequent focused gateway Clippy portion of the same failed preflight found two latent diagnostics: timestamp digit separators in native_result_wire_cases.rs and explicit unit pattern in native_cost_store.rs. Both mechanical repairs preserve generated bytes/semantics. `cargo fmt --all --check` passes; `cargo clippy --locked -p auths-gateway --all-targets --all-features -- -D warnings` passes11.24s. No lint allowances. +- [PostgreSQL126820236050](https://github.com/auths-dev/auths-proof/actions/runs/41900199751/job/126820236050):all48ordinary selectors and both new cost selectors actually passed. Artifact upload failed because relative AUTHS_AP074_COST_DIRECTORY resolves under the Cargo crate cwd, while upload expects workspace target. Workflow now uses `${{ github.workspace }}/target/ap074-native-cost`. No completed native suite repeated locally. Cost metric JSON remains unavailable until repaired hosted upload; test durations alone are not path-latency measurements. Independent information comparison and restore were skipped afterward. +- All eight main failed rollups individually inspected: implementation RUN_RESULT=skipped after preflight failure, not eight extra source defects. Formal-fast remains active at this report checkpoint. No healthy workflow restarted/cancelled and no platform coverage removed. + +Exact staged Gitleaks8.28.0:704bytes/0findings; diff check clean. Per-command unsigned local commit under parent's established convention; global signing config untouched. + +## Current positive evidence and limits + +- Native log audited against workflow:48ordinary selectors and2cost selectors each exactly once,1passed/0failed/0ignored. File cost3.88s, TLS PostgreSQL cost4.88s. These are test durations, not reconstructed metric values. +- Uploaded PG artifact13357901657 ZIP SHA256 `e2159042bed2e902dd9ab98bff489d4043cce31db80ae0534fb99c09cdeb6d6c` verified. Despite artifact name, it contains only native log, no information comparison report. Do not count22pairs or restore as passed for46989. +- Native mutation generator and independent28request/26response comparison now pass hosted. Artifact13358171429 ZIP `d7165e53a9601f741f1be558553d109e8d5603c7166deeb33210bb1c9d43fcef` verified; seven source hashes match current sources. Python pytest reached438passes after this gate, with only unrelated audit stand-in failing. +- Previously failing real Python north-star126820238519 and scaffold126820238005 now pass on hosted source46989; npm north-star126820238099 also passed. All current installed demo jobs pass. +- Airtable artifact13359390742 ZIP `a1521b8cf5808858f0cc787252342fe1d175a4e94abbfd4cc5076b879c03ce46` verified:exactsource46989,36simulation cases/privateaudit13verified0inconsistent; all positive owner-browser flags true, productionfalse. Installed Python/TS acquisition, separate disclosure/ACK, private0600content, replay/no extra execution, loss/restart controls retained. +- Stripe artifact13359295606 ZIP `6c676f969afa8c36d2f56f62ad13813c81f2c07ba426c550dca2e46006bcbbfa` verified:exactsource46989,23simulation cases/privateaudit6verified0inconsistent, productionfalse. + +Final source qualification remains open. Required implementations are blocked by formatting prerequisite; cost artifact upload/information comparison/restore must run on repaired head. macOS wheel producer/git protocol were still queued at checkpoint, so their dependent matrix cannot be inferred. Preserve formal-fast and finish terminal cohort before next authorized publication. Parent's newer generated-history work is not part of this source or evidence. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index dded19d05..09c82c926 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3966,3 +3966,30 @@ semantic metadata construction passed without release identity changes. Final source closure is `0057a01cccebd4fbc6b16c08a1a042f4af83ceee5e21e67a72c0c08c4bce88a1`. No local generated-history execution is claimed; the new explicit CI producers must execute before their evidence is accepted. + +## Integrated cost-artifact and private-audit fixture repairs + +Integrated all five changes from the CI subagent's `bbb391a9` directly into the +current generated-history source: the parent module ordering is formatted with +the new generated-history module retained; the other four path diffs apply +unchanged. Cost and generated-history outputs now use workspace-absolute paths. +The Python audit argument-forwarding stand-in targets private-bundle.json and +poisons public bundle.json to detect fallback, retaining every verdict, pin and +option assertion. Two Clippy repairs change only a literal separator and unit +closure pattern. No runtime semantics, vectors or acceptance assertion changes. + +[The subagent report](0074-ci-repair-46989b7d.md) records actual source46989 hosted +results:48 ordinary native selectors and both new cost selectors each executed +once,1 passed/0 ignored; cost selector durations3.88s and4.88s. Their metric files +were not uploaded due to the now-repaired path, so measured distributions remain +unavailable. The independent22 comparison and restore were skipped after upload +failure and are not claimed as passed. Both installed demos, owner journey, +28/26 mutation differential and real SDK journeys passed, as reported by the +subagent. Final current-head qualification remains required. + +Main ran only source artifact constructors: updated closure1 passed/0 ignored +(0.07s), rebuilt closure1 passed/0 ignored(0.05s), and semantic metadata +construction passed with no release identity changes. Final source closure is +`c46116f44bcab92337597ef95fc499dd79488a214584135c60135fb82c44150a`. +Generated concurrent histories remain unexecuted until the next exact-head CI +cohort. Main did not inspect CI or rerun local SDK/Clippy/cost suites. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 35f747593..96cda2690 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"bda57df16868603d267f5e53a779c527821917dda5fa82cdccf23b49d715f415"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"a1808b80b958601a7b2f46b48aa2070858c413fde1ead514707fc48c6e285f68"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"41e28ba963325479649b4e271f598a08b9dda16542881685dfc32e2a7b6f42d1"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_cost_store.rs b/product/runtime/auths-gateway/src/native_cost_store.rs index 9e07783fd..b9719e7e3 100644 --- a/product/runtime/auths-gateway/src/native_cost_store.rs +++ b/product/runtime/auths-gateway/src/native_cost_store.rs @@ -172,7 +172,7 @@ impl GatewayAttemptStore for MeteredStore { "replace", current.len() + next.len(), || self.inner.replace(kind, key, current, next), - |_| 0, + |()| 0, ) } diff --git a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs index b684eca9b..abcdb621b 100644 --- a/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs +++ b/product/runtime/auths-gateway/src/native_recovery_actor_tests.rs @@ -31,16 +31,16 @@ const RECOVERY: &str = "independent-reader"; const PEER_ENV: &str = "AUTHS_AP074_RECOVERY_ACTOR_PEER"; const TARGET: &str = "/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001"; +#[path = "native_cost_tests.rs"] +mod cost_tests; +#[path = "native_generated_history_tests.rs"] +mod generated_history_tests; #[path = "native_recovery_history_tests.rs"] mod history_tests; #[path = "native_recovery_limits_tests.rs"] mod limits_tests; #[path = "native_public_evidence_tests.rs"] mod privacy_tests; -#[path = "native_cost_tests.rs"] -mod cost_tests; -#[path = "native_generated_history_tests.rs"] -mod generated_history_tests; #[derive(Clone, Copy, Deserialize, Serialize)] #[serde(rename_all = "kebab-case")] diff --git a/product/runtime/auths-gateway/src/native_result_wire_cases.rs b/product/runtime/auths-gateway/src/native_result_wire_cases.rs index e91d7c7cf..1b1537182 100644 --- a/product/runtime/auths-gateway/src/native_result_wire_cases.rs +++ b/product/runtime/auths-gateway/src/native_result_wire_cases.rs @@ -138,7 +138,7 @@ pub(super) fn cases() -> Value { json!({"outcome":"observed","status":200,"matched":true}), json!({"outcome":"observed-by-provider","status":200, "evidence":{"schema":crate::PUBLIC_EVIDENCE_SCHEMA,"channel":"read-back", - "evidence_commitment":"ab".repeat(32),"observed_at":1790000000}}), + "evidence_commitment":"ab".repeat(32),"observed_at":1_790_000_000}}), ]; let mut output = Vec::new(); for base in &bases { diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index a6c1938b3..05c4f7975 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "0057a01cccebd4fbc6b16c08a1a042f4af83ceee5e21e67a72c0c08c4bce88a1"; + "c46116f44bcab92337597ef95fc499dd79488a214584135c60135fb82c44150a"; #[cfg(test)] mod tests { From 01109d389df65a542bece6777c7791986c1d2541 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 05:20:24 +0900 Subject: [PATCH 126/136] test(gateway): bind changed review meaning to fresh approval --- .../gateway/review-approval-boundary.json | 490 ++++++++++++++++++ compliance.toml | 1 + docs/plans/0074-implementation-status.md | 31 ++ docs/plans/0074-review-approval-evidence.md | 29 ++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/effect_native_tests.rs | 2 + .../src/effect_review_approval_tests.rs | 279 ++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 10 files changed, 845 insertions(+), 13 deletions(-) create mode 100644 bindings/fixtures/gateway/review-approval-boundary.json create mode 100644 docs/plans/0074-review-approval-evidence.md create mode 100644 product/runtime/auths-gateway/src/effect_review_approval_tests.rs diff --git a/bindings/fixtures/gateway/review-approval-boundary.json b/bindings/fixtures/gateway/review-approval-boundary.json new file mode 100644 index 000000000..fd92a8361 --- /dev/null +++ b/bindings/fixtures/gateway/review-approval-boundary.json @@ -0,0 +1,490 @@ +{ + "schema": "auths.native-review-approval-boundary/1", + "scope": "native signed proof and exact approval; complete literal review; explicit synthetic trust/connection/clock", + "excluded": [ + "provider entry", + "durable adapter", + "installed frontend", + "human presence", + "provider qualification" + ], + "cases": [ + { + "case": "label-as-literal-data", + "original_effect": "a32f5f110895b486c434fc98705adb625ae97639a770b2f2639ebf62d9d19b31", + "changed_effect": "85ba1cce59d5f15dd8b204716b6ec4bbd73df5bd429f9c3e78ff576cd99089cc", + "old_native_action_refused": true, + "old_exact_approval_refused": true, + "fresh_exact_approval_accepted": true, + "complete_native_literal": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"85ba1cce59d5f15dd8b204716b6ec4bbd73df5bd429f9c3e78ff576cd99089cc\",\n \"binding_canonical\": \"{\\\"action\\\":[32,56,239,78,62,17,163,229,159,238,153,68,135,115,156,10,192,238,107,224,229,153,158,37,127,219,252,236,224,1,44,135],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[78,180,190,62,159,76,156,243,230,59,27,80,91,100,40,131,43,198,182,191,59,210,59,133,209,162,153,245,189,48,70,213],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"airtable-demo\\\",\\\"native_authority\\\":[118,3,149,176,138,104,134,226,203,164,214,235,122,74,147,71,72,143,122,236,67,118,181,86,109,7,169,107,19,128,90,118],\\\"operation\\\":\\\"review-bound-1\\\",\\\"partition\\\":\\\"test-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[41,28,41,149,254,97,45,214,185,161,114,43,122,150,217,134,223,70,157,175,96,146,80,8,122,243,124,40,17,33,89,147]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[74,94,75,117,203,255,6,105,149,53,5,79,151,168,160,232,133,57,123,222,44,148,36,53,129,12,24,2,135,173,232,152],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"airtable-demo\",\n \"partition\": \"test-partition\",\n \"epoch\": 1,\n \"operation\": \"review-bound-1\",\n \"action\": [\n 32,\n 56,\n 239,\n 78,\n 62,\n 17,\n 163,\n 229,\n 159,\n 238,\n 153,\n 68,\n 135,\n 115,\n 156,\n 10,\n 192,\n 238,\n 107,\n 224,\n 229,\n 153,\n 158,\n 37,\n 127,\n 219,\n 252,\n 236,\n 224,\n 1,\n 44,\n 135\n ],\n \"native_authority\": [\n 118,\n 3,\n 149,\n 176,\n 138,\n 104,\n 134,\n 226,\n 203,\n 164,\n 214,\n 235,\n 122,\n 74,\n 147,\n 71,\n 72,\n 143,\n 122,\n 236,\n 67,\n 118,\n 181,\n 86,\n 109,\n 7,\n 169,\n 107,\n 19,\n 128,\n 90,\n 118\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 74,\n 94,\n 75,\n 117,\n 203,\n 255,\n 6,\n 105,\n 149,\n 53,\n 5,\n 79,\n 151,\n 168,\n 160,\n 232,\n 133,\n 57,\n 123,\n 222,\n 44,\n 148,\n 36,\n 53,\n 129,\n 12,\n 24,\n 2,\n 135,\n 173,\n 232,\n 152\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 78,\n 180,\n 190,\n 62,\n 159,\n 76,\n 156,\n 243,\n 230,\n 59,\n 27,\n 80,\n 91,\n 100,\n 40,\n 131,\n 43,\n 198,\n 182,\n 191,\n 59,\n 210,\n 59,\n 133,\n 209,\n 162,\n 153,\n 245,\n 189,\n 48,\n 70,\n 213\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 41,\n 28,\n 41,\n 149,\n 254,\n 97,\n 45,\n 214,\n 185,\n 161,\n 114,\n 43,\n 122,\n 150,\n 217,\n 134,\n 223,\n 70,\n 157,\n 175,\n 96,\n 146,\n 80,\n 8,\n 122,\n 243,\n 124,\n 40,\n 17,\n 33,\n 89,\n 147\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"2038ef4e3e11a3e59fee994487739c0ac0ee6be0e5999e257fdbfcece0012c87\",\n \"arguments\": {\n \"operation_id\": \"review-bound-1\",\n \"operator_namespace\": \"airtable-demo\",\n \"recipe_digest\": \"4a5e4b75cbff06699535054f97a8a0e885397bde2c942435810c180287ade898\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"Approved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"Approved\\\",\\\"auths_echo\\\":\\\"auths-e1-3662a9ea578b13839dff8eedc20a8e70f85fc164f8e0c0da7e0b382fbe27c064\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"\n ],\n \"fields\": [\n {\n \"kind\": \"identifier\",\n \"label\": \"Record id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"\",\n \"argument\": \"replacement\",\n \"value\": \"Approved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"identifier\",\n \"label\": \"Record id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"\"\n }\n }\n },\n \"digest\": \"4a5e4b75cbff06699535054f97a8a0e885397bde2c942435810c180287ade898\",\n \"operator_namespace\": \"airtable-demo\",\n \"service\": \"airtable-gateway-demo\",\n \"tool\": \"set_demo_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "native_signing_request": { + "schema": "auths.exact-effect-approval/1", + "effect": [ + 133, + 186, + 28, + 206, + 89, + 213, + 241, + 93, + 216, + 178, + 4, + 113, + 107, + 110, + 196, + 187, + 215, + 61, + 245, + 189, + 66, + 159, + 156, + 62, + 120, + 255, + 87, + 108, + 217, + 144, + 137, + 204 + ], + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "not_before": 1790000000, + "expires_at": 1790000300 + } + }, + { + "case": "consequences", + "original_effect": "a32f5f110895b486c434fc98705adb625ae97639a770b2f2639ebf62d9d19b31", + "changed_effect": "64e541ac0c652d88f592d96fbccfca1084df5c69b0cd7b0478af40b25babe627", + "old_native_action_refused": true, + "old_exact_approval_refused": true, + "fresh_exact_approval_accepted": true, + "complete_native_literal": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"64e541ac0c652d88f592d96fbccfca1084df5c69b0cd7b0478af40b25babe627\",\n \"binding_canonical\": \"{\\\"action\\\":[197,184,229,95,27,150,21,105,99,179,153,190,42,89,70,119,70,149,21,43,146,201,20,196,210,238,46,118,164,217,75,197],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[235,43,224,117,90,17,12,154,172,65,0,127,192,118,29,61,21,200,114,231,31,227,27,87,3,5,85,72,243,36,7,39],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"airtable-demo\\\",\\\"native_authority\\\":[211,89,226,141,187,216,243,99,31,91,137,102,208,32,124,104,161,136,7,118,116,154,31,99,247,71,60,209,68,26,62,63],\\\"operation\\\":\\\"review-bound-1\\\",\\\"partition\\\":\\\"test-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[35,60,21,0,165,133,93,95,202,118,45,98,6,162,85,41,106,107,199,254,6,74,77,45,241,52,110,143,208,33,91,24]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,137,208,187,200,62,159,141,85,88,193,11,111,79,219,11,184,10,23,113,48,17,195,109,255,25,27,227,231,248,74,76],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"airtable-demo\",\n \"partition\": \"test-partition\",\n \"epoch\": 1,\n \"operation\": \"review-bound-1\",\n \"action\": [\n 197,\n 184,\n 229,\n 95,\n 27,\n 150,\n 21,\n 105,\n 99,\n 179,\n 153,\n 190,\n 42,\n 89,\n 70,\n 119,\n 70,\n 149,\n 21,\n 43,\n 146,\n 201,\n 20,\n 196,\n 210,\n 238,\n 46,\n 118,\n 164,\n 217,\n 75,\n 197\n ],\n \"native_authority\": [\n 211,\n 89,\n 226,\n 141,\n 187,\n 216,\n 243,\n 99,\n 31,\n 91,\n 137,\n 102,\n 208,\n 32,\n 124,\n 104,\n 161,\n 136,\n 7,\n 118,\n 116,\n 154,\n 31,\n 99,\n 247,\n 71,\n 60,\n 209,\n 68,\n 26,\n 62,\n 63\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 137,\n 208,\n 187,\n 200,\n 62,\n 159,\n 141,\n 85,\n 88,\n 193,\n 11,\n 111,\n 79,\n 219,\n 11,\n 184,\n 10,\n 23,\n 113,\n 48,\n 17,\n 195,\n 109,\n 255,\n 25,\n 27,\n 227,\n 231,\n 248,\n 74,\n 76\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 235,\n 43,\n 224,\n 117,\n 90,\n 17,\n 12,\n 154,\n 172,\n 65,\n 0,\n 127,\n 192,\n 118,\n 29,\n 61,\n 21,\n 200,\n 114,\n 231,\n 31,\n 227,\n 27,\n 87,\n 3,\n 5,\n 85,\n 72,\n 243,\n 36,\n 7,\n 39\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 35,\n 60,\n 21,\n 0,\n 165,\n 133,\n 93,\n 95,\n 202,\n 118,\n 45,\n 98,\n 6,\n 162,\n 85,\n 41,\n 106,\n 107,\n 199,\n 254,\n 6,\n 74,\n 77,\n 45,\n 241,\n 52,\n 110,\n 143,\n 208,\n 33,\n 91,\n 24\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"c5b8e55f1b96156963b399be2a5946774695152b92c914c4d2ee2e76a4d94bc5\",\n \"arguments\": {\n \"operation_id\": \"review-bound-1\",\n \"operator_namespace\": \"airtable-demo\",\n \"recipe_digest\": \"4489d0bbc83e9f8d5558c10b6f4fdb0bb80a17713011c36dff191be3e7f84a4c\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"Approved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"Approved\\\",\\\"auths_echo\\\":\\\"auths-e1-6ea13733d48df0159c58d826bf881ddf083278cb5f7d8d2f4bc83577b6c6c1d0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Replace the named field; independent writers may change it afterward.\"\n ],\n \"fields\": [\n {\n \"kind\": \"identifier\",\n \"label\": \"Record id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"Replacement\",\n \"argument\": \"replacement\",\n \"value\": \"Approved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Replace the named field; independent writers may change it afterward.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"identifier\",\n \"label\": \"Record id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"Replacement\"\n }\n }\n },\n \"digest\": \"4489d0bbc83e9f8d5558c10b6f4fdb0bb80a17713011c36dff191be3e7f84a4c\",\n \"operator_namespace\": \"airtable-demo\",\n \"service\": \"airtable-gateway-demo\",\n \"tool\": \"set_demo_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "native_signing_request": { + "schema": "auths.exact-effect-approval/1", + "effect": [ + 100, + 229, + 65, + 172, + 12, + 101, + 45, + 136, + 245, + 146, + 217, + 111, + 188, + 207, + 202, + 16, + 132, + 223, + 92, + 105, + 176, + 205, + 123, + 4, + 120, + 175, + 64, + 178, + 91, + 171, + 230, + 39 + ], + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "not_before": 1790000000, + "expires_at": 1790000300 + } + }, + { + "case": "destination", + "original_effect": "a32f5f110895b486c434fc98705adb625ae97639a770b2f2639ebf62d9d19b31", + "changed_effect": "92a6f7bfb9a46445b2c8697470aa6f2c5e07f1c8cde4fd0ab463f3c6d37bea06", + "old_native_action_refused": true, + "old_exact_approval_refused": true, + "fresh_exact_approval_accepted": true, + "complete_native_literal": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"92a6f7bfb9a46445b2c8697470aa6f2c5e07f1c8cde4fd0ab463f3c6d37bea06\",\n \"binding_canonical\": \"{\\\"action\\\":[164,192,50,54,20,89,152,227,159,209,67,241,92,152,175,197,245,209,108,233,229,109,75,184,163,196,36,129,108,106,1,136],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[120,0,211,85,235,100,195,59,103,219,50,150,164,43,71,201,247,200,234,24,74,58,87,171,119,44,14,30,167,56,136,77],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"airtable-demo\\\",\\\"native_authority\\\":[210,128,200,74,192,243,235,77,159,110,180,137,175,147,56,32,24,175,4,216,3,250,95,39,176,76,144,85,250,68,108,28],\\\"operation\\\":\\\"review-bound-1\\\",\\\"partition\\\":\\\"test-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[166,142,236,226,220,239,242,208,42,233,154,97,25,210,218,64,225,145,153,2,100,169,179,119,255,95,72,215,60,249,36,130]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[143,154,6,42,105,105,109,19,11,215,134,209,94,222,38,220,215,244,104,55,23,151,70,255,108,129,222,8,55,102,24,43],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"airtable-demo\",\n \"partition\": \"test-partition\",\n \"epoch\": 1,\n \"operation\": \"review-bound-1\",\n \"action\": [\n 164,\n 192,\n 50,\n 54,\n 20,\n 89,\n 152,\n 227,\n 159,\n 209,\n 67,\n 241,\n 92,\n 152,\n 175,\n 197,\n 245,\n 209,\n 108,\n 233,\n 229,\n 109,\n 75,\n 184,\n 163,\n 196,\n 36,\n 129,\n 108,\n 106,\n 1,\n 136\n ],\n \"native_authority\": [\n 210,\n 128,\n 200,\n 74,\n 192,\n 243,\n 235,\n 77,\n 159,\n 110,\n 180,\n 137,\n 175,\n 147,\n 56,\n 32,\n 24,\n 175,\n 4,\n 216,\n 3,\n 250,\n 95,\n 39,\n 176,\n 76,\n 144,\n 85,\n 250,\n 68,\n 108,\n 28\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 143,\n 154,\n 6,\n 42,\n 105,\n 105,\n 109,\n 19,\n 11,\n 215,\n 134,\n 209,\n 94,\n 222,\n 38,\n 220,\n 215,\n 244,\n 104,\n 55,\n 23,\n 151,\n 70,\n 255,\n 108,\n 129,\n 222,\n 8,\n 55,\n 102,\n 24,\n 43\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 120,\n 0,\n 211,\n 85,\n 235,\n 100,\n 195,\n 59,\n 103,\n 219,\n 50,\n 150,\n 164,\n 43,\n 71,\n 201,\n 247,\n 200,\n 234,\n 24,\n 74,\n 58,\n 87,\n 171,\n 119,\n 44,\n 14,\n 30,\n 167,\n 56,\n 136,\n 77\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 166,\n 142,\n 236,\n 226,\n 220,\n 239,\n 242,\n 208,\n 42,\n 233,\n 154,\n 97,\n 25,\n 210,\n 218,\n 64,\n 225,\n 145,\n 153,\n 2,\n 100,\n 169,\n 179,\n 119,\n 255,\n 95,\n 72,\n 215,\n 60,\n 249,\n 36,\n 130\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"a4c03236145998e39fd143f15c98afc5f5d16ce9e56d4bb8a3c424816c6a0188\",\n \"arguments\": {\n \"operation_id\": \"review-bound-1\",\n \"operator_namespace\": \"airtable-demo\",\n \"recipe_digest\": \"8f9a062a69696d130bd786d15ede26dcd7f46837179746ff6c81de083766182b\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"Approved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://different.example/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"Approved\\\",\\\"auths_echo\\\":\\\"auths-e1-372b424c58e08a0f8c3a27476ea93b1f07304f669075f08ec5522c1d67e16e71\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"\n ],\n \"fields\": [\n {\n \"kind\": \"identifier\",\n \"label\": \"Record id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"Replacement\",\n \"argument\": \"replacement\",\n \"value\": \"Approved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Replace the DemoStatus field of the displayed record with the displayed replacement value. Other writers may change the record before or after this mutation.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"identifier\",\n \"label\": \"Record id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"Replacement\"\n }\n }\n },\n \"digest\": \"8f9a062a69696d130bd786d15ede26dcd7f46837179746ff6c81de083766182b\",\n \"operator_namespace\": \"airtable-demo\",\n \"service\": \"airtable-gateway-demo\",\n \"tool\": \"set_demo_status_v1\",\n \"origin\": \"https://different.example\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "native_signing_request": { + "schema": "auths.exact-effect-approval/1", + "effect": [ + 146, + 166, + 247, + 191, + 185, + 164, + 100, + 69, + 178, + 200, + 105, + 116, + 112, + 170, + 111, + 44, + 94, + 7, + 241, + 200, + 205, + 228, + 253, + 10, + 180, + 99, + 243, + 198, + 211, + 123, + 234, + 6 + ], + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "not_before": 1790000000, + "expires_at": 1790000300 + } + }, + { + "case": "financial-units", + "original_effect": "cac7edc5d86044da27bed2973b9fb9b6ae5dc56f9360b3b7b11c690adf4d64ae", + "changed_effect": "8b1ee0465fcd0a6017ca6f9dd651a3d6f82099df20dab8cf994ce3928b031287", + "old_native_action_refused": true, + "old_exact_approval_refused": true, + "fresh_exact_approval_accepted": true, + "complete_native_literal": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"8b1ee0465fcd0a6017ca6f9dd651a3d6f82099df20dab8cf994ce3928b031287\",\n \"binding_canonical\": \"{\\\"action\\\":[72,196,167,60,130,228,132,221,200,116,132,105,1,93,212,167,43,83,31,172,28,74,191,233,17,217,89,179,19,212,129,181],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[94,182,67,88,143,93,216,217,222,30,139,202,220,130,149,161,17,237,170,195,127,160,11,205,75,130,107,48,11,14,150,208],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"stripe-refunds\\\",\\\"native_authority\\\":[141,150,181,207,162,45,39,236,156,162,218,113,72,203,162,154,109,90,92,226,226,161,116,211,35,192,156,107,2,107,29,16],\\\"operation\\\":\\\"review-bound-1\\\",\\\"partition\\\":\\\"test-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[203,81,132,89,59,20,165,97,181,48,229,72,39,50,73,119,181,222,192,69,201,166,244,32,222,134,36,34,127,75,70,237]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[202,5,68,138,175,26,1,199,16,86,232,183,178,240,29,103,33,8,198,117,18,247,40,246,69,201,31,128,203,185,231,217],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":10,\\\"key\\\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\\\"unit\\\":\\\"mutation-count\\\",\\\"window\\\":{\\\"index\\\":497222,\\\"kind\\\":\\\"fixed\\\",\\\"seconds\\\":3600}},{\\\"amount\\\":500,\\\"ceiling\\\":10000,\\\"key\\\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\\\"unit\\\":\\\"mutation-sum\\\",\\\"window\\\":{\\\"index\\\":497222,\\\"kind\\\":\\\"fixed\\\",\\\"seconds\\\":3600}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"stripe-refunds\",\n \"partition\": \"test-partition\",\n \"epoch\": 1,\n \"operation\": \"review-bound-1\",\n \"action\": [\n 72,\n 196,\n 167,\n 60,\n 130,\n 228,\n 132,\n 221,\n 200,\n 116,\n 132,\n 105,\n 1,\n 93,\n 212,\n 167,\n 43,\n 83,\n 31,\n 172,\n 28,\n 74,\n 191,\n 233,\n 17,\n 217,\n 89,\n 179,\n 19,\n 212,\n 129,\n 181\n ],\n \"native_authority\": [\n 141,\n 150,\n 181,\n 207,\n 162,\n 45,\n 39,\n 236,\n 156,\n 162,\n 218,\n 113,\n 72,\n 203,\n 162,\n 154,\n 109,\n 90,\n 92,\n 226,\n 226,\n 161,\n 116,\n 211,\n 35,\n 192,\n 156,\n 107,\n 2,\n 107,\n 29,\n 16\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 202,\n 5,\n 68,\n 138,\n 175,\n 26,\n 1,\n 199,\n 16,\n 86,\n 232,\n 183,\n 178,\n 240,\n 29,\n 103,\n 33,\n 8,\n 198,\n 117,\n 18,\n 247,\n 40,\n 246,\n 69,\n 201,\n 31,\n 128,\n 203,\n 185,\n 231,\n 217\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 94,\n 182,\n 67,\n 88,\n 143,\n 93,\n 216,\n 217,\n 222,\n 30,\n 139,\n 202,\n 220,\n 130,\n 149,\n 161,\n 17,\n 237,\n 170,\n 195,\n 127,\n 160,\n 11,\n 205,\n 75,\n 130,\n 107,\n 48,\n 11,\n 14,\n 150,\n 208\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 41,\n 99,\n 160,\n 99,\n 100,\n 194,\n 62,\n 104,\n 252,\n 43,\n 194,\n 221,\n 247,\n 202,\n 94,\n 242,\n 30,\n 140,\n 150,\n 36,\n 5,\n 157,\n 62,\n 51,\n 233,\n 190,\n 112,\n 84,\n 94,\n 239,\n 26,\n 6\n ],\n \"unit\": \"mutation-count\",\n \"amount\": 1,\n \"ceiling\": 10,\n \"window\": {\n \"kind\": \"fixed\",\n \"index\": 497222,\n \"seconds\": 3600\n }\n },\n {\n \"key\": [\n 126,\n 92,\n 18,\n 248,\n 196,\n 186,\n 59,\n 228,\n 72,\n 195,\n 208,\n 41,\n 175,\n 208,\n 151,\n 238,\n 243,\n 75,\n 224,\n 81,\n 223,\n 57,\n 64,\n 212,\n 189,\n 16,\n 1,\n 42,\n 149,\n 34,\n 79,\n 69\n ],\n \"unit\": \"mutation-sum\",\n \"amount\": 500,\n \"ceiling\": 10000,\n \"window\": {\n \"kind\": \"fixed\",\n \"index\": 497222,\n \"seconds\": 3600\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 203,\n 81,\n 132,\n 89,\n 59,\n 20,\n 165,\n 97,\n 181,\n 48,\n 229,\n 72,\n 39,\n 50,\n 73,\n 119,\n 181,\n 222,\n 192,\n 69,\n 201,\n 166,\n 244,\n 32,\n 222,\n 134,\n 36,\n 34,\n 127,\n 75,\n 70,\n 237\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"48c4a73c82e484ddc8748469015dd4a72b531fac1c4abfe911d959b313d481b5\",\n \"arguments\": {\n \"amount\": 500,\n \"connect_account\": \"acct_TESTACCOUNT01\",\n \"currency\": \"usd\",\n \"operation_id\": \"review-bound-1\",\n \"operator_namespace\": \"stripe-refunds\",\n \"payment_intent\": \"pi_review_fixture\",\n \"recipe_digest\": \"ca05448aaf1a01c71056e8b7b2f01d672108c67512f728f645c91f80cbb9e7d9\"\n },\n \"request\": {\n \"method\": \"POST\",\n \"url\": \"https://api.stripe.com/v1/refunds\",\n \"content_type\": \"application/x-www-form-urlencoded\",\n \"body\": \"amount=500&metadata%5Bauths_echo%5D=auths-e1-4eb9d4f84d8ef8cf816b72b34948bd0cccd1b12fda850e04f8ead55bfb438287&payment_intent=pi_review_fixture\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ],\n [\n \"Stripe-Account\",\n \"acct_TESTACCOUNT01\"\n ],\n [\n \"Idempotency-Key\",\n \"auths-i1-96ec4da433accd16e9c05d4c7a304ce06a4650baee0e55917f3e2391bc70ed05\"\n ]\n ],\n \"idempotency_key\": \"auths-i1-96ec4da433accd16e9c05d4c7a304ce06a4650baee0e55917f3e2391bc70ed05\"\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\n \"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"\n ],\n \"fields\": [\n {\n \"kind\": \"integer\",\n \"label\": \"Amount\",\n \"unit\": \"different explicitly reviewed units\",\n \"argument\": \"amount\",\n \"value\": 500\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Connect account\",\n \"argument\": \"connect_account\",\n \"value\": \"acct_TESTACCOUNT01\"\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Currency\",\n \"argument\": \"currency\",\n \"value\": \"usd\"\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Payment intent\",\n \"argument\": \"payment_intent\",\n \"value\": \"pi_review_fixture\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\n \"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"\n ],\n \"fields\": {\n \"amount\": {\n \"kind\": \"integer\",\n \"label\": \"Amount\",\n \"unit\": \"different explicitly reviewed units\"\n },\n \"connect_account\": {\n \"kind\": \"identifier\",\n \"label\": \"Connect account\"\n },\n \"currency\": {\n \"kind\": \"identifier\",\n \"label\": \"Currency\"\n },\n \"payment_intent\": {\n \"kind\": \"identifier\",\n \"label\": \"Payment intent\"\n }\n }\n },\n \"digest\": \"ca05448aaf1a01c71056e8b7b2f01d672108c67512f728f645c91f80cbb9e7d9\",\n \"operator_namespace\": \"stripe-refunds\",\n \"service\": \"stripe-refunds\",\n \"tool\": \"create_refund_v1\",\n \"origin\": \"https://api.stripe.com\",\n \"method\": \"POST\",\n \"path\": [\n \"v1\",\n \"refunds\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": true,\n \"echo\": {\n \"kind\": \"form-field\",\n \"write\": \"metadata[auths_echo]\",\n \"observe\": \"/metadata/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked-after-response\",\n \"state_observation\": \"response-locator\",\n \"provider_link\": \"response-locator\",\n \"unknown_resolution\": \"none\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"declared\",\n \"kind\": \"derived-header\",\n \"retention_seconds\": 86400\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": {\n \"Stripe-Version\": {\n \"value\": \"2025-03-31.basil\",\n \"response\": \"required\"\n }\n },\n \"credential_guard\": {\n \"prefixes\": [\n \"rk_test_\"\n ],\n \"probe\": {\n \"path\": [\n \"v1\",\n \"balance\"\n ],\n \"json_pointer\": \"/livemode\",\n \"equals\": false,\n \"maximum_response_bytes\": 16384\n },\n \"account\": {\n \"path\": [\n \"v1\",\n \"account\"\n ],\n \"json_pointer\": \"/id\",\n \"maximum_response_bytes\": 65536\n },\n \"denied_reads\": [\n {\n \"method\": \"GET\",\n \"path\": [\n \"v1\",\n \"customers\"\n ],\n \"refused_status\": [\n 403\n ]\n },\n {\n \"method\": \"GET\",\n \"path\": [\n \"v1\",\n \"payouts\"\n ],\n \"refused_status\": [\n 403\n ]\n }\n ],\n \"disclosure\": \"run at onboarding and at every lease; a denied read shows only the refusals observed\"\n },\n \"idempotency\": {\n \"kind\": \"derived-header\",\n \"retention_seconds\": 86400,\n \"disclosure\": \"declared by the recipe author; the gateway cannot verify that the provider honors it\"\n },\n \"observation\": {\n \"locator\": \"response-locator\",\n \"path\": [\n \"v1\",\n \"refunds\",\n \"\"\n ],\n \"json_pointer\": \"/amount\",\n \"expected_field\": \"amount\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": {\n \"header\": \"Stripe-Account\",\n \"field\": \"connect_account\",\n \"disclosure\": \"sent only with a value the grant lists\"\n },\n \"relative_ceiling\": {\n \"rule\": \"amount \\u2264 floor(basis \\u00d7 5000 / 10000)\",\n \"argument\": \"amount\",\n \"basis_points\": 5000,\n \"path\": [\n \"v1\",\n \"payment_intents\",\n \"\"\n ],\n \"json_pointer\": \"/amount_received\",\n \"subtract_pointer\": null,\n \"bind\": [\n {\n \"pointer\": \"/currency\",\n \"field\": \"currency\"\n }\n ],\n \"maximum_response_bytes\": 65536\n },\n \"bounds\": {\n \"sum\": {\n \"argument\": \"amount\",\n \"partition\": \"currency\"\n }\n }\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": [\n {\n \"purpose\": {\n \"kind\": \"account\",\n \"json_pointer\": \"/id\",\n \"expected_account_commitment\": [\n 211,\n 137,\n 141,\n 250,\n 238,\n 251,\n 144,\n 251,\n 244,\n 138,\n 249,\n 139,\n 90,\n 91,\n 110,\n 174,\n 184,\n 145,\n 125,\n 218,\n 248,\n 246,\n 26,\n 88,\n 244,\n 34,\n 169,\n 159,\n 47,\n 19,\n 232,\n 36\n ],\n \"commitment_domain\": \"auths.gateway-account/1\"\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/account\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 65536\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"denied-capability\",\n \"index\": 0,\n \"refused_statuses\": [\n 403\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/customers\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 16384\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"denied-capability\",\n \"index\": 1,\n \"refused_statuses\": [\n 403\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/payouts\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 16384\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"relative-ceiling\",\n \"argument\": 500,\n \"basis_points\": 5000,\n \"json_pointer\": \"/amount_received\",\n \"subtract_pointer\": null,\n \"binds\": [\n [\n \"/currency\",\n \"usd\"\n ]\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/payment_intents/pi_review_fixture\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ],\n [\n \"Stripe-Account\",\n \"acct_TESTACCOUNT01\"\n ]\n ],\n \"maximum_response_bytes\": 65536\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n ]\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "native_signing_request": { + "schema": "auths.exact-effect-approval/1", + "effect": [ + 139, + 30, + 224, + 70, + 95, + 205, + 10, + 96, + 23, + 202, + 111, + 157, + 214, + 81, + 163, + 214, + 248, + 32, + 153, + 223, + 32, + 218, + 184, + 207, + 153, + 76, + 227, + 146, + 139, + 3, + 18, + 135 + ], + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "not_before": 1790000000, + "expires_at": 1790000300 + } + }, + { + "case": "financial-unit-limit", + "original_effect": "cac7edc5d86044da27bed2973b9fb9b6ae5dc56f9360b3b7b11c690adf4d64ae", + "changed_effect": "265c70ef4d7290042b5167bedeb240d9bc6b1e7ce1f35f5c21532e9d0a21143f", + "old_native_action_refused": true, + "old_exact_approval_refused": true, + "fresh_exact_approval_accepted": true, + "complete_native_literal": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"265c70ef4d7290042b5167bedeb240d9bc6b1e7ce1f35f5c21532e9d0a21143f\",\n \"binding_canonical\": \"{\\\"action\\\":[145,224,28,28,242,92,25,180,187,238,87,202,71,252,218,39,142,253,165,30,242,40,123,218,135,146,194,54,255,7,239,107],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[145,77,147,50,109,223,68,201,100,23,178,19,62,70,69,137,236,66,223,25,12,13,227,160,5,189,22,176,247,11,238,53],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"stripe-refunds\\\",\\\"native_authority\\\":[221,43,8,215,183,226,194,224,252,132,154,238,185,135,224,37,43,150,56,155,108,236,219,237,22,143,5,208,12,235,212,192],\\\"operation\\\":\\\"review-bound-1\\\",\\\"partition\\\":\\\"test-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[74,59,104,144,197,87,223,125,56,207,44,134,0,85,161,120,23,174,253,240,185,220,176,57,252,203,43,114,194,22,92,124]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[94,3,220,195,177,254,229,198,124,214,241,92,154,203,12,155,240,102,208,166,231,240,12,22,202,220,151,240,83,17,41,96],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":10,\\\"key\\\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\\\"unit\\\":\\\"mutation-count\\\",\\\"window\\\":{\\\"index\\\":497222,\\\"kind\\\":\\\"fixed\\\",\\\"seconds\\\":3600}},{\\\"amount\\\":500,\\\"ceiling\\\":10000,\\\"key\\\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\\\"unit\\\":\\\"mutation-sum\\\",\\\"window\\\":{\\\"index\\\":497222,\\\"kind\\\":\\\"fixed\\\",\\\"seconds\\\":3600}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"stripe-refunds\",\n \"partition\": \"test-partition\",\n \"epoch\": 1,\n \"operation\": \"review-bound-1\",\n \"action\": [\n 145,\n 224,\n 28,\n 28,\n 242,\n 92,\n 25,\n 180,\n 187,\n 238,\n 87,\n 202,\n 71,\n 252,\n 218,\n 39,\n 142,\n 253,\n 165,\n 30,\n 242,\n 40,\n 123,\n 218,\n 135,\n 146,\n 194,\n 54,\n 255,\n 7,\n 239,\n 107\n ],\n \"native_authority\": [\n 221,\n 43,\n 8,\n 215,\n 183,\n 226,\n 194,\n 224,\n 252,\n 132,\n 154,\n 238,\n 185,\n 135,\n 224,\n 37,\n 43,\n 150,\n 56,\n 155,\n 108,\n 236,\n 219,\n 237,\n 22,\n 143,\n 5,\n 208,\n 12,\n 235,\n 212,\n 192\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 94,\n 3,\n 220,\n 195,\n 177,\n 254,\n 229,\n 198,\n 124,\n 214,\n 241,\n 92,\n 154,\n 203,\n 12,\n 155,\n 240,\n 102,\n 208,\n 166,\n 231,\n 240,\n 12,\n 22,\n 202,\n 220,\n 151,\n 240,\n 83,\n 17,\n 41,\n 96\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 145,\n 77,\n 147,\n 50,\n 109,\n 223,\n 68,\n 201,\n 100,\n 23,\n 178,\n 19,\n 62,\n 70,\n 69,\n 137,\n 236,\n 66,\n 223,\n 25,\n 12,\n 13,\n 227,\n 160,\n 5,\n 189,\n 22,\n 176,\n 247,\n 11,\n 238,\n 53\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 41,\n 99,\n 160,\n 99,\n 100,\n 194,\n 62,\n 104,\n 252,\n 43,\n 194,\n 221,\n 247,\n 202,\n 94,\n 242,\n 30,\n 140,\n 150,\n 36,\n 5,\n 157,\n 62,\n 51,\n 233,\n 190,\n 112,\n 84,\n 94,\n 239,\n 26,\n 6\n ],\n \"unit\": \"mutation-count\",\n \"amount\": 1,\n \"ceiling\": 10,\n \"window\": {\n \"kind\": \"fixed\",\n \"index\": 497222,\n \"seconds\": 3600\n }\n },\n {\n \"key\": [\n 126,\n 92,\n 18,\n 248,\n 196,\n 186,\n 59,\n 228,\n 72,\n 195,\n 208,\n 41,\n 175,\n 208,\n 151,\n 238,\n 243,\n 75,\n 224,\n 81,\n 223,\n 57,\n 64,\n 212,\n 189,\n 16,\n 1,\n 42,\n 149,\n 34,\n 79,\n 69\n ],\n \"unit\": \"mutation-sum\",\n \"amount\": 500,\n \"ceiling\": 10000,\n \"window\": {\n \"kind\": \"fixed\",\n \"index\": 497222,\n \"seconds\": 3600\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 74,\n 59,\n 104,\n 144,\n 197,\n 87,\n 223,\n 125,\n 56,\n 207,\n 44,\n 134,\n 0,\n 85,\n 161,\n 120,\n 23,\n 174,\n 253,\n 240,\n 185,\n 220,\n 176,\n 57,\n 252,\n 203,\n 43,\n 114,\n 194,\n 22,\n 92,\n 124\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"91e01c1cf25c19b4bbee57ca47fcda278efda51ef2287bda8792c236ff07ef6b\",\n \"arguments\": {\n \"amount\": 500,\n \"connect_account\": \"acct_TESTACCOUNT01\",\n \"currency\": \"usd\",\n \"operation_id\": \"review-bound-1\",\n \"operator_namespace\": \"stripe-refunds\",\n \"payment_intent\": \"pi_review_fixture\",\n \"recipe_digest\": \"5e03dcc3b1fee5c67cd6f15c9acb0c9bf066d0a6e7f00c16cadc97f053112960\"\n },\n \"request\": {\n \"method\": \"POST\",\n \"url\": \"https://api.stripe.com/v1/refunds\",\n \"content_type\": \"application/x-www-form-urlencoded\",\n \"body\": \"amount=500&metadata%5Bauths_echo%5D=auths-e1-98551ec032f3f8ebe192ef185e5086336c98a7746f0466cfe463d0e805a6fba2&payment_intent=pi_review_fixture\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ],\n [\n \"Stripe-Account\",\n \"acct_TESTACCOUNT01\"\n ],\n [\n \"Idempotency-Key\",\n \"auths-i1-96ec4da433accd16e9c05d4c7a304ce06a4650baee0e55917f3e2391bc70ed05\"\n ]\n ],\n \"idempotency_key\": \"auths-i1-96ec4da433accd16e9c05d4c7a304ce06a4650baee0e55917f3e2391bc70ed05\"\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\n \"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"\n ],\n \"fields\": [\n {\n \"kind\": \"integer\",\n \"label\": \"Amount\",\n \"unit\": \"uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\",\n \"argument\": \"amount\",\n \"value\": 500\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Connect account\",\n \"argument\": \"connect_account\",\n \"value\": \"acct_TESTACCOUNT01\"\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Currency\",\n \"argument\": \"currency\",\n \"value\": \"usd\"\n },\n {\n \"kind\": \"identifier\",\n \"label\": \"Payment intent\",\n \"argument\": \"payment_intent\",\n \"value\": \"pi_review_fixture\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\n \"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"\n ],\n \"fields\": {\n \"amount\": {\n \"kind\": \"integer\",\n \"label\": \"Amount\",\n \"unit\": \"uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\"\n },\n \"connect_account\": {\n \"kind\": \"identifier\",\n \"label\": \"Connect account\"\n },\n \"currency\": {\n \"kind\": \"identifier\",\n \"label\": \"Currency\"\n },\n \"payment_intent\": {\n \"kind\": \"identifier\",\n \"label\": \"Payment intent\"\n }\n }\n },\n \"digest\": \"5e03dcc3b1fee5c67cd6f15c9acb0c9bf066d0a6e7f00c16cadc97f053112960\",\n \"operator_namespace\": \"stripe-refunds\",\n \"service\": \"stripe-refunds\",\n \"tool\": \"create_refund_v1\",\n \"origin\": \"https://api.stripe.com\",\n \"method\": \"POST\",\n \"path\": [\n \"v1\",\n \"refunds\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": true,\n \"echo\": {\n \"kind\": \"form-field\",\n \"write\": \"metadata[auths_echo]\",\n \"observe\": \"/metadata/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked-after-response\",\n \"state_observation\": \"response-locator\",\n \"provider_link\": \"response-locator\",\n \"unknown_resolution\": \"none\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"declared\",\n \"kind\": \"derived-header\",\n \"retention_seconds\": 86400\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": {\n \"Stripe-Version\": {\n \"value\": \"2025-03-31.basil\",\n \"response\": \"required\"\n }\n },\n \"credential_guard\": {\n \"prefixes\": [\n \"rk_test_\"\n ],\n \"probe\": {\n \"path\": [\n \"v1\",\n \"balance\"\n ],\n \"json_pointer\": \"/livemode\",\n \"equals\": false,\n \"maximum_response_bytes\": 16384\n },\n \"account\": {\n \"path\": [\n \"v1\",\n \"account\"\n ],\n \"json_pointer\": \"/id\",\n \"maximum_response_bytes\": 65536\n },\n \"denied_reads\": [\n {\n \"method\": \"GET\",\n \"path\": [\n \"v1\",\n \"customers\"\n ],\n \"refused_status\": [\n 403\n ]\n },\n {\n \"method\": \"GET\",\n \"path\": [\n \"v1\",\n \"payouts\"\n ],\n \"refused_status\": [\n 403\n ]\n }\n ],\n \"disclosure\": \"run at onboarding and at every lease; a denied read shows only the refusals observed\"\n },\n \"idempotency\": {\n \"kind\": \"derived-header\",\n \"retention_seconds\": 86400,\n \"disclosure\": \"declared by the recipe author; the gateway cannot verify that the provider honors it\"\n },\n \"observation\": {\n \"locator\": \"response-locator\",\n \"path\": [\n \"v1\",\n \"refunds\",\n \"\"\n ],\n \"json_pointer\": \"/amount\",\n \"expected_field\": \"amount\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": {\n \"header\": \"Stripe-Account\",\n \"field\": \"connect_account\",\n \"disclosure\": \"sent only with a value the grant lists\"\n },\n \"relative_ceiling\": {\n \"rule\": \"amount \\u2264 floor(basis \\u00d7 5000 / 10000)\",\n \"argument\": \"amount\",\n \"basis_points\": 5000,\n \"path\": [\n \"v1\",\n \"payment_intents\",\n \"\"\n ],\n \"json_pointer\": \"/amount_received\",\n \"subtract_pointer\": null,\n \"bind\": [\n {\n \"pointer\": \"/currency\",\n \"field\": \"currency\"\n }\n ],\n \"maximum_response_bytes\": 65536\n },\n \"bounds\": {\n \"sum\": {\n \"argument\": \"amount\",\n \"partition\": \"currency\"\n }\n }\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": [\n {\n \"purpose\": {\n \"kind\": \"account\",\n \"json_pointer\": \"/id\",\n \"expected_account_commitment\": [\n 211,\n 137,\n 141,\n 250,\n 238,\n 251,\n 144,\n 251,\n 244,\n 138,\n 249,\n 139,\n 90,\n 91,\n 110,\n 174,\n 184,\n 145,\n 125,\n 218,\n 248,\n 246,\n 26,\n 88,\n 244,\n 34,\n 169,\n 159,\n 47,\n 19,\n 232,\n 36\n ],\n \"commitment_domain\": \"auths.gateway-account/1\"\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/account\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 65536\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"denied-capability\",\n \"index\": 0,\n \"refused_statuses\": [\n 403\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/customers\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 16384\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"denied-capability\",\n \"index\": 1,\n \"refused_statuses\": [\n 403\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/payouts\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ]\n ],\n \"maximum_response_bytes\": 16384\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n {\n \"purpose\": {\n \"kind\": \"relative-ceiling\",\n \"argument\": 500,\n \"basis_points\": 5000,\n \"json_pointer\": \"/amount_received\",\n \"subtract_pointer\": null,\n \"binds\": [\n [\n \"/currency\",\n \"usd\"\n ]\n ]\n },\n \"request\": {\n \"method\": \"GET\",\n \"url\": \"https://api.stripe.com/v1/payment_intents/pi_review_fixture\",\n \"headers\": [\n [\n \"Stripe-Version\",\n \"2025-03-31.basil\"\n ],\n [\n \"Stripe-Account\",\n \"acct_TESTACCOUNT01\"\n ]\n ],\n \"maximum_response_bytes\": 65536\n },\n \"maximum_calls\": 1,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n ]\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "native_signing_request": { + "schema": "auths.exact-effect-approval/1", + "effect": [ + 38, + 92, + 112, + 239, + 77, + 114, + 144, + 4, + 43, + 81, + 103, + 190, + 222, + 178, + 64, + 217, + 188, + 107, + 30, + 124, + 225, + 243, + 95, + 92, + 33, + 83, + 46, + 157, + 10, + 33, + 20, + 63 + ], + "approver": [ + 232, + 218, + 99, + 164, + 12, + 166, + 135, + 200, + 124, + 252, + 224, + 92, + 178, + 74, + 120, + 108, + 126, + 117, + 204, + 73, + 199, + 13, + 181, + 87, + 63, + 2, + 111, + 28, + 106, + 134, + 206, + 170 + ], + "not_before": 1790000000, + "expires_at": 1790000300 + } + } + ], + "incomplete_review_refusals": [ + { + "case": "missing-unit", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "null-unit", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":null},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "empty-unit", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "whitespace-unit", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\" minor units \"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "unit-limit-plus-one", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "unit-nonascii", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"‮USD\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "unit-control", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"USD\\nDestination: hidden\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "missing-fields", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{}}}" + }, + { + "case": "unsupported-review", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/999\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"minor units of the declared currency\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "missing-consequences", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"minor units of the declared currency\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "consequence-limit-plus-one", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"minor units of the declared currency\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "too-many-consequences", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\",\"Consequence\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"Amount\",\"unit\":\"minor units of the declared currency\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + }, + { + "case": "case-insensitive-label-collision", + "code": "gateway.recipe.invalid-source", + "source_json": "{\"schema\":\"auths.gateway-recipe-source/3\",\"profile_schema_digest\":\"db3a47820a6f5c3ce3883068bea16542721e049cab8453a2af579c77a46d5c5e\",\"service\":\"stripe-refunds\",\"tool\":\"create_refund_v1\",\"operator_namespace\":\"stripe-refunds\",\"credential\":{\"kind\":\"bearer\",\"guard\":{\"prefixes\":[\"rk_test_\"],\"probe\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"balance\"}],\"json_pointer\":\"/livemode\",\"equals\":false,\"maximum_response_bytes\":16384},\"account\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"account\"}],\"json_pointer\":\"/id\",\"maximum_response_bytes\":65536},\"denied_reads\":[{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"customers\"}],\"refused_status\":[403]},{\"method\":\"GET\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payouts\"}],\"refused_status\":[403]}]}},\"origin\":\"https://api.stripe.com\",\"provider_headers\":{\"Stripe-Version\":\"2025-03-31.basil\"},\"account_scope\":{\"header\":\"Stripe-Account\",\"field\":\"connect_account\"},\"bounds\":{\"sum\":{\"argument\":\"amount\",\"partition\":\"currency\"}},\"relative_ceiling\":{\"argument\":\"amount\",\"basis_points\":5000,\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"payment_intents\"},{\"kind\":\"field\",\"name\":\"payment_intent\"}],\"json_pointer\":\"/amount_received\",\"bind\":[{\"pointer\":\"/currency\",\"field\":\"currency\"}],\"maximum_response_bytes\":65536},\"write\":{\"method\":\"POST\",\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"}],\"body\":{\"kind\":\"form\",\"fields\":{\"payment_intent\":{\"kind\":\"field\",\"name\":\"payment_intent\"},\"amount\":{\"kind\":\"field\",\"name\":\"amount\"}}},\"idempotency\":{\"kind\":\"derived-header\",\"retention_seconds\":86400}},\"observation\":{\"path\":[{\"kind\":\"fixed\",\"value\":\"v1\"},{\"kind\":\"fixed\",\"value\":\"refunds\"},{\"kind\":\"response-field\",\"pointer\":\"/id\",\"max_bytes\":255}],\"json_pointer\":\"/amount\",\"expected_field\":\"amount\",\"maximum_response_bytes\":16384},\"echo\":{\"write\":{\"kind\":\"form-field\",\"name\":\"metadata[auths_echo]\"},\"observe\":\"/metadata/auths_echo\"},\"review\":{\"schema\":\"auths.effect-review-contract/1\",\"consequences\":[\"Issue one refund against the identified payment intent for the displayed amount. This is not a recurring charge.\",\"The provider determines refund settlement timing. A response or receipt does not itself establish settlement.\"],\"fields\":{\"amount\":{\"kind\":\"integer\",\"label\":\"currency\",\"unit\":\"minor units of the declared currency\"},\"connect_account\":{\"kind\":\"identifier\",\"label\":\"Connect account\"},\"currency\":{\"kind\":\"identifier\",\"label\":\"Currency\"},\"payment_intent\":{\"kind\":\"identifier\",\"label\":\"Payment intent\"}}}}" + } + ] +} \ No newline at end of file diff --git a/compliance.toml b/compliance.toml index d86ee45a5..05e1475fe 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1671,6 +1671,7 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/effect_native_tests.rs#native_recovery_acquisition_fixture_is_current", "product/runtime/auths-gateway/src/recipe/tests.rs#native_review_contract_fixture_is_current", "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", + "product/runtime/auths-gateway/src/effect_review_approval_tests.rs#native_review_changes_require_fresh_authority_and_approval", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", "product/runtime/auths-gateway/src/native_epoch_tests.rs#native_file_epoch_fence_fixture_is_current", diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 09c82c926..3e5bd787a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3993,3 +3993,34 @@ construction passed with no release identity changes. Final source closure is `c46116f44bcab92337597ef95fc499dd79488a214584135c60135fb82c44150a`. Generated concurrent histories remain unexecuted until the next exact-head CI cohort. Main did not inspect CI or rerun local SDK/Clippy/cost suites. + +## Native signed review meaning and approval corpus + +Added five native-signed approval witnesses over maintained Airtable and Stripe +refund example recipes. Changed label-as-literal-data, consequences, destination, +financial units and the 80-byte unit boundary each change the recipe/effect. The +original signed native action refuses the changed recipe. Fresh native authority +still cannot reuse the original exact approval; original and freshly approved +controls pass. Complete native literal/private-review equality and refusal of a +summary/truncation renderer are asserted. Native proofs, policy scopes, currencies, +amount sums and exact Ed25519 approval use the existing owners. + +Thirteen financial review source negatives reject missing/null/empty/whitespace/ +over-limit/control/bidi units, missing fields, unsupported review versions, +missing/oversized/excess consequences and case-insensitive label collisions. +The canonical [review/approval artifact](../../bindings/fixtures/gateway/review-approval-boundary.json) +retains the native literal and signing request, with no provider/durability/human +claim. [Scope and composition](0074-review-approval-evidence.md) keep the installed +owner-channel and generic literal-renderer evidence separate and mandatory. +Compliance names the exact native constructor; no public API or shipping decision +changes. Changed units do not themselves qualify new provider-domain meaning. + +Required artifact construction passed (1 passed /0 ignored,0.09s). Updated source +closure passed (1 passed /0 ignored,0.07s) and rebuilt non-update check passed +(1 passed /0 ignored,0.07s). Closure is +`a00efd11f811f045119cfef58ea049b73bdb6848f3eabfbfed9dc94e9d55d3b8`. +Semantic metadata advances freeze430, identity171, public SDK167 and public +surface430, only as required by the changed compliance evidence inventory. +Hosted execution and complete acceptance closure remain pending. Main has not +inspected CI or run local SDK, lint, broad test or formal suites. +Semantic metadata construction passed for this review-evidence batch. No complete acceptance row is closed by the constructor alone. diff --git a/docs/plans/0074-review-approval-evidence.md b/docs/plans/0074-review-approval-evidence.md new file mode 100644 index 000000000..7caa0ae74 --- /dev/null +++ b/docs/plans/0074-review-approval-evidence.md @@ -0,0 +1,29 @@ +# Native review meaning and exact approval evidence + +The `review_approval_tests::native_review_changes_require_fresh_authority_and_approval` +constructor uses the maintained Airtable and Stripe refund example recipes, +ordinary native MCP proofs and exact Ed25519 approvals. Five cases independently +change a displayed label, consequences, destination, financial units or the +80-byte unit boundary. Every case proves the original native action pins its +original recipe and refuses the changed recipe; a newly authorized action still +cannot reuse the old exact approval. Original and freshly approved controls pass. + +The complete native literal is retained beside its native signing request in +`bindings/fixtures/gateway/review-approval-boundary.json`. The constructor compares +the complete parsed literal to the native private review without truncation and +refuses an unsupported summary renderer. Markup in a label remains literal data. +Thirteen financial-review source negatives cover missing/null/empty/whitespace/ +over-limit/control/bidi units, omitted fields, unsupported review version, +missing/oversized/excess consequences and case-insensitive label collisions. + +Trust, keys, connection/account and clock are explicit synthetic fixtures. This +is signed native compilation/review/approval evidence, not provider execution, +financial interpretation, durable-store behavior or human attention. A changed +unit declaration does not establish that a provider honors that unit; qualified +domain meaning still requires the independently reviewed recipe contract. + +The installed owner channel's separate authentication, review/signing correlation +and complete literal-display tests remain required. The native constructor and +the installed generic renderer provide complementary evidence; this artifact +does not manufacture an installed frontend result. Exact-head hosted execution +remains pending after artifact construction. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 96cda2690..7dbee0c50 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"c3cb77e4fd1aa138133b1af33dfcf2abf03e2f011964da53b9da0d0143f0751e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"fee59c6c8d7eb3bae2174da4ef806d6d8e18bb6d4db87c27ee703dbbc899785e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 8bd7dd16b..025eda989 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -30,6 +30,8 @@ mod read_budget_tests; #[path = "effect_recovery_prerequisite_tests.rs"] mod recovery_prerequisite_tests; +#[path = "effect_review_approval_tests.rs"] +mod review_approval_tests; /// Native read authority is independent of an expired source writer. File /// provenance is real; the source entry is a test grant with no provider send. diff --git a/product/runtime/auths-gateway/src/effect_review_approval_tests.rs b/product/runtime/auths-gateway/src/effect_review_approval_tests.rs new file mode 100644 index 000000000..275091b88 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_review_approval_tests.rs @@ -0,0 +1,279 @@ +//! Native signed approval witnesses for changed review meaning. Pure compilation +//! uses explicit synthetic trust/connection/clock; no transport or human claim. +use super::*; +use crate::effect::{BoundEffect, ExactEffectApproval, fixture_policy}; +use crate::harness::authoring::{ToolFixture, tool_fixture_in_window}; + +struct NativeCase { + recipe: CompiledRecipe, + signed: ToolFixture, + effect: BoundEffect, +} + +fn effect( + recipe: &CompiledRecipe, + signed: &ToolFixture, +) -> Result { + let context = auths_codec::decode_verifier_context(&signed.context).expect("explicit trust"); + let connection = connection_account( + recipe, + crate::submit::account_commitment("acct_TESTACCOUNT01"), + ); + let policy = fixture_policy().expect("policy"); + compile_mutation_effect( + &policy.installation( + recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ), + NOW, + &signed.proof, + &signed.action, + ) +} + +fn native(source: &Value, lock: &[u8], financial: bool) -> NativeCase { + let recipe = CompiledRecipe::compile(&serde_json::to_vec(source).expect("source"), lock) + .expect("reviewed recipe"); + let mut arguments = if financial { + json!({"amount":500,"currency":"usd","connect_account":"acct_TESTACCOUNT01","payment_intent":"pi_review_fixture"}) + } else { + json!({"record_id":"recTEST0000000001","replacement":"Approved"}) + }; + arguments["operation_id"] = json!("review-bound-1"); + arguments["operator_namespace"] = json!(recipe.namespace().as_str()); + arguments["recipe_digest"] = json!(recipe.digest_hex()); + let call = McpToolCall::new( + recipe.review().service(), + recipe.review().tool(), + arguments.as_object().expect("arguments").clone(), + ) + .expect("native call"); + let policy = financial.then(|| { + crate::ArgumentCeilingPolicy::new("amount", 1_000, 3_600, 10) + .expect("bound") + .with_sum( + 10_000, + Some(crate::ListedValues::new("currency", &["usd"]).expect("partition")), + ) + .expect("sum") + .with_scope( + crate::ListedValues::new("connect_account", &["acct_TESTACCOUNT01"]) + .expect("scope"), + ) + .expect("scope bound") + }); + let signed = tool_fixture_in_window(&call, NOW, NOW - 10, NOW + 3_600, policy.as_ref()) + .expect("real signed native proof"); + let effect = effect(&recipe, &signed).expect("native effect"); + NativeCase { + recipe, + signed, + effect, + } +} + +fn approval(effect: &BoundEffect) -> ExactEffectApproval { + let request = effect + .approval_request(NOW, NOW + 300) + .expect("complete native request"); + let signature = SigningKey::from_bytes(&[29; 32]) + .sign(&request.signing_message().expect("native preimage")) + .to_bytes(); + request.with_signature(signature) +} + +fn case( + source: &Value, + lock: &[u8], + financial: bool, + name: &str, + pointer: &str, + replacement: Value, +) -> Value { + let original = native(source, lock, financial); + let original_id = *original.effect.binding().id().as_bytes(); + let old_approval = approval(&original.effect); + let mut changed_source = source.clone(); + *changed_source + .pointer_mut(pointer) + .expect("declared review field") = replacement; + let changed = native(&changed_source, lock, financial); + let changed_id = *changed.effect.binding().id().as_bytes(); + assert_ne!(original.recipe.digest(), changed.recipe.digest()); + assert_ne!(original_id, changed_id); + assert!( + effect(&changed.recipe, &original.signed).is_err(), + "old native action pins the original recipe" + ); + let request = changed + .effect + .approval_request(NOW, NOW + 300) + .expect("fresh review request"); + let fresh_approval = approval(&changed.effect); + let review = changed + .effect + .private_review() + .expect("complete private review"); + let literal = review + .render_literal(crate::effect::LITERAL_REVIEW_RENDERER) + .expect("supported complete renderer"); + assert_eq!( + serde_json::from_str::(&literal).expect("literal"), + serde_json::from_slice::(&review.to_private_bytes().expect("review bytes")) + .expect("review") + ); + assert!(review.render_literal("summary-with-truncation/1").is_err()); + let public = SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(); + assert!( + changed + .effect + .approve(old_approval.clone(), &public, NOW) + .is_err(), + "changed meaning cannot reuse approval" + ); + original + .effect + .approve(old_approval, &public, NOW) + .expect("original positive control"); + let fresh = native(&changed_source, lock, financial); + fresh + .effect + .approve(fresh_approval, &public, NOW) + .expect("fresh exact approval positive control"); + json!({"case":name,"original_effect":hex::encode(original_id),"changed_effect":hex::encode(changed_id), + "old_native_action_refused":true,"old_exact_approval_refused":true,"fresh_exact_approval_accepted":true, + "complete_native_literal":literal.as_str(),"native_signing_request":serde_json::to_value(request).expect("request")}) +} + +fn incomplete(source: &Value, lock: &[u8]) -> Vec { + let mut cases = Vec::new(); + for (name, pointer, replacement) in [ + ( + "missing-unit", + "/review/fields/amount", + json!({"kind":"integer","label":"Amount"}), + ), + ("null-unit", "/review/fields/amount/unit", Value::Null), + ("empty-unit", "/review/fields/amount/unit", json!("")), + ( + "whitespace-unit", + "/review/fields/amount/unit", + json!(" minor units "), + ), + ( + "unit-limit-plus-one", + "/review/fields/amount/unit", + json!("u".repeat(81)), + ), + ( + "unit-nonascii", + "/review/fields/amount/unit", + json!("\u{202e}USD"), + ), + ( + "unit-control", + "/review/fields/amount/unit", + json!("USD\nDestination: hidden"), + ), + ("missing-fields", "/review/fields", json!({})), + ( + "unsupported-review", + "/review/schema", + json!("auths.effect-review-contract/999"), + ), + ("missing-consequences", "/review/consequences", json!([])), + ( + "consequence-limit-plus-one", + "/review/consequences", + json!(["c".repeat(513)]), + ), + ( + "too-many-consequences", + "/review/consequences", + json!(vec!["Consequence"; 9]), + ), + ( + "case-insensitive-label-collision", + "/review/fields/amount/label", + json!("currency"), + ), + ] { + let mut changed = source.clone(); + *changed.pointer_mut(pointer).expect("declared field") = replacement; + let input = serde_json::to_vec(&changed).expect("source"); + let refusal = CompiledRecipe::compile(&input, lock).expect_err(name); + cases.push(json!({"case":name,"code":refusal.code(),"source_json":String::from_utf8(input).expect("JSON")})); + } + cases +} + +#[test] +fn native_review_changes_require_fresh_authority_and_approval() { + let airtable: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/airtable/recipe.json" + )) + .expect("source"); + let airtable_lock = + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"); + let stripe: Value = serde_json::from_slice(include_bytes!( + "../../../../examples/stripe-refund-approval/recipe.json" + )) + .expect("source"); + let stripe_lock = + include_bytes!("../../../../examples/stripe-refund-approval/profile.lock.json"); + let cases = vec![ + case( + &airtable, + airtable_lock, + false, + "label-as-literal-data", + "/review/fields/replacement/label", + json!(""), + ), + case( + &airtable, + airtable_lock, + false, + "consequences", + "/review/consequences", + json!(["Replace the named field; independent writers may change it afterward."]), + ), + case( + &airtable, + airtable_lock, + false, + "destination", + "/origin", + json!("https://different.example"), + ), + case( + &stripe, + stripe_lock, + true, + "financial-units", + "/review/fields/amount/unit", + json!("different explicitly reviewed units"), + ), + case( + &stripe, + stripe_lock, + true, + "financial-unit-limit", + "/review/fields/amount/unit", + json!("u".repeat(80)), + ), + ]; + let bytes = serde_json::to_vec_pretty(&json!({"schema":"auths.native-review-approval-boundary/1", + "scope":"native signed proof and exact approval; complete literal review; explicit synthetic trust/connection/clock", + "excluded":["provider entry","durable adapter","installed frontend","human presence","provider qualification"], + "cases":cases,"incomplete_review_refusals":incomplete(&stripe,stripe_lock)})).expect("artifact"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/review-approval-boundary.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 05c4f7975..a4bc0f0f9 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "c46116f44bcab92337597ef95fc499dd79488a214584135c60135fb82c44150a"; + "a00efd11f811f045119cfef58ea049b73bdb6848f3eabfbfed9dc94e9d55d3b8"; #[cfg(test)] mod tests { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 464ecfafe..70297323a 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 429 +freeze_version = 430 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 429 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 170 +"auths.identity.protocol" = 171 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 130 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 429 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 166 +"auths.product.public-sdk-contract" = 167 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 84 -"auths.release.public-surface" = 429 +"auths.release.public-surface" = 430 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index 16c91f305..dac77bd9e 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 429, + "freezeVersion": 430, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 170, + "version": 171, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "64e2932da7ae8fd7350cb83f29a9d92818ad1e705953485915fc11218b35dae1" + "sha256": "8c2d8909c9aea852fd65ccb4fc99c5bc8087f62627deb21f9a909af26bff7e73" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 166, + "version": 167, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "79808494f670c200965d763898a3557f830d0b3aa9561dbf5b0f42457707cab9" + "sha256": "da7bd251822a3fc1805792b64e71df80322f53c4fef28b27157146eaafda5adb" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 429, + "version": 430, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "2b7b4379ad94cf9fd87e2f6352601a5984c7c1a7eeb2500657a8809ce77bd11b" + "sha256": "9a3bcd9ae0a0a673542f6f2d109a909807fc066495113fc804468f7d965ff79a" } ] } From 977ae61f568ea1144d2f8788280bb98f3dbacd55 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 06:13:02 +0900 Subject: [PATCH 127/136] fix(gateway): close crash and journal assurance gaps --- .github/workflows/postgres-lifecycle.yml | 141 +-- AGENTS.md | 37 +- .../gateway/application-content-frame.json | 4 +- .../gateway/application-recovery-frame.json | 2 +- .../gateway/candidate-compilation.json | 326 +++---- .../fixtures/gateway/content-compilation.json | 256 +++--- .../gateway/effect-approval-request.json | 2 +- .../fixtures/gateway/effect-approval.json | 2 +- bindings/fixtures/gateway/effect-binding.json | 74 +- .../gateway/native-dependency-order-file.json | 46 + .../native-dependency-order-postgres.json | 46 + .../native-disclosure-entry-order-file.json | 48 + ...ative-disclosure-entry-order-postgres.json | 48 + .../gateway/native-epoch-fence-file.json | 33 + .../gateway/native-epoch-fence-postgres.json | 33 + .../native-guarded-mutation-crash-file.json | 818 ++++++++++++++++++ ...ative-guarded-mutation-crash-postgres.json | 818 ++++++++++++++++++ .../gateway/native-independent-bindings.json | 96 ++ .../native-information-journal-file.json | 339 ++++++++ .../native-information-journal-postgres.json | 339 ++++++++ .../native-mutation-entry-order-file.json | 32 + .../native-mutation-entry-order-postgres.json | 32 + .../gateway/native-mutation-journal-file.json | 118 +++ .../native-mutation-journal-postgres.json | 118 +++ .../gateway/native-partial-upload-file.json | 37 + .../native-partial-upload-postgres.json | 37 + .../gateway/prerequisite-compilation.json | 74 +- .../gateway/recovery-compilation.json | 10 +- compliance.toml | 9 + docs/plans/0074-final-acceptance-audit.md | 147 ++++ docs/plans/0074-final-coding-checklist.md | 64 ++ docs/plans/0074-generated-histories.md | 7 +- docs/plans/0074-implementation-status.md | 129 ++- docs/plans/0074-native-cost-evidence.md | 42 +- ...ound-effects-and-recovery-state-machine.md | 7 + .../corpus/target_gateway_app_frame/content | 2 +- .../corpus/target_gateway_app_frame/disclose | 2 +- .../corpus/target_gateway_app_frame/recover | 2 +- .../corpus/target_gateway_app_frame/submit | 2 +- .../auths-gateway/semantic-closure.json | 2 +- .../src/effect_binding_boundary_tests.rs | 241 ++++++ .../auths-gateway/src/effect_native_tests.rs | 2 + product/runtime/auths-gateway/src/lib.rs | 3 + .../auths-gateway/src/native_crash_tests.rs | 21 +- .../src/native_dependency_tests.rs | 24 +- .../src/native_disclosure_entry_tests.rs | 15 +- .../auths-gateway/src/native_epoch_tests.rs | 127 +++ .../native_guarded_mutation_crash_tests.rs | 260 ++++++ .../src/native_information_journal_tests.rs | 119 +++ .../src/native_information_replay_tests.rs | 3 + .../auths-gateway/src/native_journal_tests.rs | 126 +++ .../src/native_mutation_crash_tests.rs | 279 ++++-- .../src/native_mutation_entry_tests.rs | 15 +- .../src/native_mutation_journal_tests.rs | 109 +++ .../src/native_mutation_replay_tests.rs | 3 + .../src/native_partial_upload_tests.rs | 155 ++++ .../auths-gateway/src/native_process_tests.rs | 6 +- .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 15 +- release/semantic-freeze-versions.toml | 8 +- release/semantic-freeze.json | 14 +- 61 files changed, 5355 insertions(+), 573 deletions(-) create mode 100644 bindings/fixtures/gateway/native-guarded-mutation-crash-file.json create mode 100644 bindings/fixtures/gateway/native-guarded-mutation-crash-postgres.json create mode 100644 bindings/fixtures/gateway/native-independent-bindings.json create mode 100644 bindings/fixtures/gateway/native-information-journal-file.json create mode 100644 bindings/fixtures/gateway/native-information-journal-postgres.json create mode 100644 bindings/fixtures/gateway/native-mutation-journal-file.json create mode 100644 bindings/fixtures/gateway/native-mutation-journal-postgres.json create mode 100644 bindings/fixtures/gateway/native-partial-upload-file.json create mode 100644 bindings/fixtures/gateway/native-partial-upload-postgres.json create mode 100644 docs/plans/0074-final-acceptance-audit.md create mode 100644 docs/plans/0074-final-coding-checklist.md create mode 100644 product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_information_journal_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_journal_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_mutation_journal_tests.rs create mode 100644 product/runtime/auths-gateway/src/native_partial_upload_tests.rs diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index fe16908bc..07eaf8fa1 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -49,57 +49,98 @@ jobs: set -o pipefail mkdir -p target { - cargo test -p auths-gateway --lib -- --ignored postgres - cargo test -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --exact native_content_process_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_process_tests::native_file_process_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_crash_tests::native_file_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::native_file_mutation_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::postgres_native_mutation_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::native_file_disclosure_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_native_disclosure_process_crash_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::native_file_mutation_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_native_mutation_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::window_capacity_tests::native_file_disclosure_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::window_capacity_tests::postgres_native_disclosure_window_capacity_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::file_fault_tests::native_file_mutation_io_fault_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::file_fault_tests::native_file_disclosure_io_fault_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_batch_tests::postgres_native_mutation_partial_batch_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_batch_tests::postgres_native_disclosure_partial_batch_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_commit_tests::postgres_native_mutation_commit_reply_loss_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_commit_tests::postgres_native_disclosure_commit_reply_loss_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::native_file_mutation_retained_replay_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::retention_tests::native_file_retention_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::retention_tests::postgres_native_retention_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::epoch_tests::native_file_epoch_fence_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::epoch_tests::postgres_native_epoch_fence_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::scope_tests::native_file_managed_scope_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::scope_tests::postgres_native_managed_scope_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::entry_tests::native_file_mutation_entry_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::entry_tests::postgres_native_mutation_entry_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::entry_tests::native_file_disclosure_entry_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::entry_tests::postgres_native_disclosure_entry_order_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::limits_tests::native_file_recovery_limits_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::limits_tests::postgres_native_recovery_limits_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::history_tests::native_file_recovery_history_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::history_tests::postgres_native_recovery_history_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::privacy_tests::native_file_public_mutation_evidence_fixture_is_current - cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::privacy_tests::postgres_native_public_mutation_evidence_fixture_is_current - cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres + failures=0 + cargo test -p auths-gateway --lib -- --ignored postgres || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --test content_journey -- --exact native_content_process_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_process_tests::native_file_process_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_process_tests::postgres_native_process_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_crash_tests::native_file_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_crash_tests::postgres_native_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::native_file_mutation_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::postgres_native_mutation_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::native_file_disclosure_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_native_disclosure_process_crash_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_dependency_tests::native_file_dependency_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_dependency_tests::postgres_native_dependency_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_budget_tests::native_file_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_budget_tests::postgres_native_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::native_file_mutation_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_native_mutation_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::window_capacity_tests::native_file_disclosure_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::window_capacity_tests::postgres_native_disclosure_window_capacity_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_file_fault_tests::native_file_io_fault_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_crash_tests::window_capacity_tests::file_fault_tests::native_file_mutation_io_fault_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_disclosure_crash_tests::file_fault_tests::native_file_disclosure_io_fault_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_fault_tests::postgres_native_partial_batch_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_batch_tests::postgres_native_mutation_partial_batch_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_batch_tests::postgres_native_disclosure_partial_batch_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_postgres_commit_tests::postgres_native_commit_reply_loss_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_crash_tests::window_capacity_tests::postgres_commit_tests::postgres_native_mutation_commit_reply_loss_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_disclosure_crash_tests::postgres_commit_tests::postgres_native_disclosure_commit_reply_loss_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::native_file_mutation_retained_replay_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::postgres_native_mutation_retained_replay_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::native_file_information_retained_replay_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::postgres_native_information_retained_replay_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::retention_tests::native_file_retention_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::retention_tests::postgres_native_retention_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::epoch_tests::native_file_epoch_fence_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::epoch_tests::postgres_native_epoch_fence_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::scope_tests::native_file_managed_scope_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::scope_tests::postgres_native_managed_scope_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_mutation_replay_tests::entry_tests::native_file_mutation_entry_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_mutation_replay_tests::entry_tests::postgres_native_mutation_entry_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_information_replay_tests::entry_tests::native_file_disclosure_entry_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_information_replay_tests::entry_tests::postgres_native_disclosure_entry_order_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::native_file_independent_recovery_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::postgres_native_independent_recovery_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::limits_tests::native_file_recovery_limits_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::limits_tests::postgres_native_recovery_limits_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::history_tests::native_file_recovery_history_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::history_tests::postgres_native_recovery_history_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact native_recovery_actor_tests::privacy_tests::native_file_public_mutation_evidence_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features loopback-provider,testkit-harness --lib -- --ignored --exact native_recovery_actor_tests::privacy_tests::postgres_native_public_mutation_evidence_fixture_is_current || failures=$((failures + 1)) + cargo test -p auths-gateway --features testkit-production-plaintext,testkit-production-unqualified --test operator_plane -- --ignored postgres || failures=$((failures + 1)) + test "$failures" -eq 0 } 2>&1 | tee target/ap074-native-adapter-evidence.log + - name: Run complete AP074 final hardening batch + if: ${{ !cancelled() }} + env: + AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require + AUTHS_POSTGRES_CA_PEM: ${{ github.workspace }}/product/stores/auths-stores/tests/postgres_tls/generated/ca.crt + AUTHS_POSTGRES_SERVER_NAME: localhost + run: | + set -o pipefail + mkdir -p target/ap074-final-hardening + failures=0 + while IFS= read -r selector; do + extra=() + if [[ "$selector" == *::postgres_* ]]; then extra+=(--ignored); fi + log="target/ap074-final-hardening/${selector//::/__}.log" + if ! cargo test --locked -p auths-gateway --features loopback-provider,testkit-harness --lib -- "${extra[@]}" --exact "$selector" 2>&1 | tee "$log"; then + failures=$((failures + 1)) + elif ! rg -q 'test result: ok\. 1 passed; 0 failed; 0 ignored;' "$log"; then + echo "Required selector did not execute exactly once: $selector" + failures=$((failures + 1)) + fi + done <<'SELECTORS' + native_mutation_crash_tests::guarded_tests::native_file_guarded_mutation_crash_fixture_is_current + native_mutation_crash_tests::guarded_tests::postgres_native_guarded_mutation_crash_fixture_is_current + native_mutation_crash_tests::partial_upload_tests::native_file_partial_upload_fixture_is_current + native_mutation_crash_tests::partial_upload_tests::postgres_native_partial_upload_fixture_is_current + native_information_replay_tests::journal_tests::native_file_information_journal_fixture_is_current + native_information_replay_tests::journal_tests::postgres_native_information_journal_fixture_is_current + native_mutation_replay_tests::journal_tests::native_file_mutation_journal_fixture_is_current + native_mutation_replay_tests::journal_tests::postgres_native_mutation_journal_fixture_is_current + observed_tests::effect_native_tests::binding_boundary_tests::native_independent_binding_substitutions_require_new_approval + SELECTORS + test "$failures" -eq 0 + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + if: always() + with: + name: ap074-final-hardening-${{ github.run_id }}-${{ github.run_attempt }} + path: target/ap074-final-hardening/ + if-no-files-found: error + retention-days: 30 - name: Measure native managed paths and bounded recovery inventory env: AUTHS_POSTGRES_URL: host=localhost port=55438 dbname=auths_lifecycle user=auths password=local-fixture-password sslmode=require diff --git a/AGENTS.md b/AGENTS.md index d8c513fa8..272f3d2ca 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -207,8 +207,8 @@ A new package is incomplete until all applicable items below are handled: touches the corresponding risk. 7. Update architecture snapshots with `cargo xtask arch --update` when the package graph intentionally changes. -8. Run the narrow layer check while iterating, then run the authoritative suite - before handoff. +8. Map and write the complete test/check batch before execution, then run the + required layer and authoritative verification together before handoff. Deleting or moving a package requires the inverse work: remove stale workspace, architecture, compliance, ownership, fixture, and generated-snapshot entries. @@ -311,7 +311,30 @@ intentional result of a dependency update. Do not regenerate them gratuitously. ## Testing and handoff -Use the smallest useful check during development: +### Batch test and assurance hardening + +Never use incremental write–run cycles when adding or hardening tests, checks, +or assurance evidence. Repeatedly writing one case, running it, fixing it, and +moving to the next can explode the time to completion. + +1. Map the complete set of checks to add and the requirements they cover. +2. Write the entire planned batch, including implementation changes, tests, + assertions, fixture generators, and CI wiring. +3. Save execution for the end of the coding batch. This includes test-based + fixture generation and artifact constructors; do not run each assurance case + as it is written. +4. Run combined verification and collect all independent failures together. + Arrange verification to expose the full failure set rather than stopping at + the first independent failure. +5. Fix the collected failures in one coherent batch, then rerun the affected + verification together. Do not return to one-test-at-a-time repair cycles. + +Keep all required coverage and acceptance criteria intact. Apply the same batch +discipline to CI repairs and follow the GitHub-first policy below for where +final verification runs. + +At the verification phase, choose the smallest set of checks covering the +complete batch: ```text cargo xtask core @@ -343,9 +366,11 @@ to its PR without first running local build, test, lint, formal, package, fuzz, or secret-scanning gates. Running the same expensive suite locally and then in GitHub duplicates work without removing the required hosted gate. -If GitHub CI fails, inspect the hosted failure first. Reproduce only the -specific failing check locally when that is useful for diagnosis, then push the -fix and let GitHub CI verify it again. Run local checks before the first push +If GitHub CI fails, inspect the hosted cohort's failures first and collect their +root causes into a coherent repair batch. Finish those changes before running +local reproductions or publishing another verification revision. Reproduce only +the failed checks needed for diagnosis or verification, then push the complete +repair batch and let GitHub CI verify it again. Run local checks before the first push only when the user explicitly requests them or when a repository-local result is required to construct the change. Never report an unrun local check as passing; cite the successful GitHub run as the merge evidence. diff --git a/bindings/fixtures/gateway/application-content-frame.json b/bindings/fixtures/gateway/application-content-frame.json index 5eaf1d6b9..e8e5a7ea8 100644 --- a/bindings/fixtures/gateway/application-content-frame.json +++ b/bindings/fixtures/gateway/application-content-frame.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ" } }, "content-history": { @@ -131,7 +131,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ" } }, "disclosure-ack": { diff --git a/bindings/fixtures/gateway/application-recovery-frame.json b/bindings/fixtures/gateway/application-recovery-frame.json index 885474352..9288c0be8 100644 --- a/bindings/fixtures/gateway/application-recovery-frame.json +++ b/bindings/fixtures/gateway/application-recovery-frame.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ" } }, "cases": [ diff --git a/bindings/fixtures/gateway/candidate-compilation.json b/bindings/fixtures/gateway/candidate-compilation.json index ee9c3fb0d..6fa2a7c42 100644 --- a/bindings/fixtures/gateway/candidate-compilation.json +++ b/bindings/fixtures/gateway/candidate-compilation.json @@ -150,38 +150,38 @@ "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 208, - 38, + 224, + 159, + 63, + 94, + 226, + 12, + 99, + 37, + 247, + 90, + 234, + 227, + 197, 165, - 192, + 210, + 203, 10, - 42, - 38, - 233, - 209, - 20, - 238, - 107, - 255, - 90, - 14, - 183, - 169, - 73, - 131, - 188, - 221, - 241, - 38, - 133, - 233, - 99, - 194, - 253, - 224, + 10, + 197, + 46, + 219, + 108, + 119, + 135, + 190, + 173, 246, - 24, - 8 + 191, + 121, + 18, + 101, + 248 ], "operation": "candidate-1", "partition": "synthetic-candidate", @@ -383,8 +383,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[208,38,165,192,10,42,38,233,209,20,238,107,255,90,14,183,169,73,131,188,221,241,38,133,233,99,194,253,224,246,24,8],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "aa960fe7f2c140d13c50650ee14ba7584c6ee9f701d4eaf8627b65729eb03681", + "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[224,159,63,94,226,12,99,37,247,90,234,227,197,165,210,203,10,10,197,46,219,108,119,135,190,173,246,191,121,18,101,248],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "c5687bdb788340f33c3530d59ff2144a8fa16ac39912f3791fff6c2ff8c6c4c6", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -965,7 +965,7 @@ "noncanonical", "oversized" ], - "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[208,38,165,192,10,42,38,233,209,20,238,107,255,90,14,183,169,73,131,188,221,241,38,133,233,99,194,253,224,246,24,8],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[254,188,237,184,63,106,229,37,201,72,61,250,48,129,35,237,54,135,206,83,37,94,2,4,234,32,100,160,120,144,222,200],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[224,159,63,94,226,12,99,37,247,90,234,227,197,165,210,203,10,10,197,46,219,108,119,135,190,173,246,191,121,18,101,248],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[214,208,227,7,36,143,190,187,157,223,172,71,99,249,237,14,248,25,155,46,113,192,39,141,78,53,116,127,192,238,78,57],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", @@ -1127,38 +1127,38 @@ "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 20, - 112, - 47, - 231, - 171, - 55, - 86, - 99, - 134, - 148, - 142, - 70, - 205, - 192, - 14, - 222, - 179, - 148, - 167, - 180, - 95, - 4, + 31, + 31, + 44, + 235, + 27, + 233, + 140, + 85, + 241, + 92, + 13, + 241, + 96, + 69, 144, - 198, - 9, - 165, - 232, - 10, - 59, + 40, + 55, + 65, + 190, + 227, + 13, + 94, + 243, + 17, 26, - 192, - 22 + 34, + 40, + 66, + 167, + 211, + 32, + 212 ], "operation": "candidate-1", "partition": "synthetic-candidate", @@ -1360,8 +1360,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[20,112,47,231,171,55,86,99,134,148,142,70,205,192,14,222,179,148,167,180,95,4,144,198,9,165,232,10,59,26,192,22],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "ca164a1d4ab6b0985aff34953d53e462c4f571895ebcd0a5550e4e30544c94d5", + "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[31,31,44,235,27,233,140,85,241,92,13,241,96,69,144,40,55,65,190,227,13,94,243,17,26,34,40,66,167,211,32,212],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "f94984f117dd678a683e26b6662030405845905cafee7b0ca21ad3eb608bed08", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -2002,7 +2002,7 @@ "noncanonical", "oversized" ], - "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[20,112,47,231,171,55,86,99,134,148,142,70,205,192,14,222,179,148,167,180,95,4,144,198,9,165,232,10,59,26,192,22],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[124,153,84,88,80,248,196,146,58,220,89,1,172,113,131,82,108,206,210,178,177,219,175,87,115,115,29,90,16,251,245,157],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[142,56,126,236,9,217,7,98,193,162,213,162,202,138,108,82,236,109,128,65,75,38,104,128,131,186,240,209,0,217,170,180],\"credential_generation\":2,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[31,31,44,235,27,233,140,85,241,92,13,241,96,69,144,40,55,65,190,227,13,94,243,17,26,34,40,66,167,211,32,212],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[115,128,130,155,163,133,102,177,239,101,240,99,31,178,149,69,239,222,1,88,76,94,144,14,37,22,48,218,196,173,53,164],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[51,79,158,237,106,159,68,168,239,94,173,143,40,103,59,192,154,61,167,187,167,87,200,166,67,172,80,127,127,248,175,232],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[133,104,54,45,137,113,5,251,109,122,163,68,250,208,82,131,31,100,15,154,70,8,158,225,154,17,158,106,205,115,144,162],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", @@ -2164,38 +2164,38 @@ "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 189, - 8, + 78, + 102, + 203, + 162, + 104, + 84, 239, - 231, - 198, - 100, - 77, - 232, + 75, + 210, + 151, + 123, + 66, + 62, + 51, + 139, + 83, + 214, + 253, + 229, 190, - 74, - 108, - 205, - 187, - 236, + 3, + 33, + 223, + 210, + 210, + 1, + 59, 170, - 175, - 242, - 154, - 124, - 105, - 134, - 160, - 172, - 63, - 141, - 189, - 45, - 89, - 10, - 209, - 144, - 38 + 5, + 163, + 233, + 103 ], "operation": "candidate-1", "partition": "synthetic-candidate", @@ -2397,8 +2397,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[189,8,239,231,198,100,77,232,190,74,108,205,187,236,170,175,242,154,124,105,134,160,172,63,141,189,45,89,10,209,144,38],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "874a488e2331930983ebfdf323202e3f7ed8f5b7be0e7fc0fc7d557af4e8014b", + "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[78,102,203,162,104,84,239,75,210,151,123,66,62,51,139,83,214,253,229,190,3,33,223,210,210,1,59,170,5,163,233,103],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "0ece9b3a5c20dc0922c88b3d68cbee79e054d5bb7a203fd2492ada2c9fbe964f", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -3039,7 +3039,7 @@ "noncanonical", "oversized" ], - "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[189,8,239,231,198,100,77,232,190,74,108,205,187,236,170,175,242,154,124,105,134,160,172,63,141,189,45,89,10,209,144,38],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[135,76,176,192,90,100,194,57,103,74,64,156,55,239,68,55,185,200,134,82,66,236,248,231,123,63,17,190,132,61,2,61],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,53,101,123,228,84,67,146,12,21,194,232,128,171,142,130,201,180,66,9,177,239,146,175,76,203,217,115,118,252,150,36],\"credential_generation\":3,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[78,102,203,162,104,84,239,75,210,151,123,66,62,51,139,83,214,253,229,190,3,33,223,210,210,1,59,170,5,163,233,103],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[149,185,79,98,221,201,40,105,70,190,99,98,217,33,85,239,9,251,175,46,132,166,192,182,190,13,80,110,246,191,228,111],\"request\":[159,147,67,87,30,216,102,239,216,20,110,96,112,204,21,84,208,97,239,113,222,166,162,211,181,178,26,249,70,116,147,146]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[40,112,119,69,113,57,227,171,226,123,141,64,11,202,248,248,203,231,70,1,49,224,175,42,115,6,30,32,83,239,28,78],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[239,187,178,157,136,234,188,74,82,178,49,215,71,183,101,241,106,67,176,80,216,59,9,102,184,242,218,89,187,210,185,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", @@ -3201,38 +3201,38 @@ "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 188, - 236, - 232, - 4, - 135, - 50, + 182, + 88, + 24, + 224, 61, - 56, - 161, - 5, - 123, - 148, - 8, - 217, - 87, - 15, - 39, - 29, - 126, - 63, - 139, - 160, - 132, - 69, - 10, - 105, - 40, - 52, - 17, - 98, - 228, - 169 + 134, + 14, + 138, + 249, + 214, + 178, + 90, + 117, + 95, + 20, + 224, + 194, + 164, + 180, + 68, + 150, + 103, + 235, + 62, + 220, + 214, + 184, + 18, + 108, + 198, + 179, + 254 ], "operation": "candidate-1", "partition": "synthetic-candidate", @@ -3434,8 +3434,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[188,236,232,4,135,50,61,56,161,5,123,148,8,217,87,15,39,29,126,63,139,160,132,69,10,105,40,52,17,98,228,169],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "f5e5ca393f760e157ba3a02d4f3089cb66d08399348bf5c3a92011b4be6d9102", + "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[182,88,24,224,61,134,14,138,249,214,178,90,117,95,20,224,194,164,180,68,150,103,235,62,220,214,184,18,108,198,179,254],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "a93b1d8345fb5b3d73da7dc22cd2bb4798cf98fa1bae8cc805a79d856ecfddbb", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -4016,7 +4016,7 @@ "noncanonical", "oversized" ], - "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[188,236,232,4,135,50,61,56,161,5,123,148,8,217,87,15,39,29,126,63,139,160,132,69,10,105,40,52,17,98,228,169],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[95,139,64,176,169,84,133,27,235,166,176,40,158,1,196,30,111,181,251,21,96,158,57,39,84,36,159,19,182,62,191,222],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[68,137,40,169,48,182,26,229,22,22,199,171,27,249,153,70,13,173,61,214,174,178,37,64,96,111,28,41,222,77,137,226],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[182,88,24,224,61,134,14,138,249,214,178,90,117,95,20,224,194,164,180,68,150,103,235,62,220,214,184,18,108,198,179,254],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[9,38,150,106,189,178,5,254,158,107,31,100,42,7,27,106,66,2,183,225,183,137,59,243,138,8,255,202,63,71,209,179],\"request\":[127,144,120,26,221,235,119,212,48,47,88,54,204,33,12,195,141,74,202,125,170,32,97,176,232,181,226,102,188,26,157,244]},\"qualification_policy\":\"optional\",\"recipe\":[180,198,112,158,11,120,239,19,180,66,79,44,4,19,130,40,80,156,236,36,65,70,235,55,230,19,73,214,242,68,231,28],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", @@ -4178,38 +4178,38 @@ "epoch": 1, "namespace": "stripe-refunds", "native_authority": [ - 164, - 129, - 114, + 42, + 8, + 122, + 175, + 175, 253, - 141, - 88, - 237, - 82, - 71, - 126, - 178, - 81, - 103, - 60, - 87, - 72, - 92, - 103, - 130, - 187, - 183, - 138, - 219, + 79, + 83, + 153, + 180, 24, - 110, - 11, - 186, - 11, - 194, + 123, + 252, + 170, + 141, + 69, + 192, + 249, 99, - 193, - 189 + 159, + 50, + 92, + 158, + 197, + 88, + 156, + 134, + 170, + 213, + 164, + 3, + 2 ], "operation": "candidate-1", "partition": "synthetic-candidate", @@ -4411,8 +4411,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[164,129,114,253,141,88,237,82,71,126,178,81,103,60,87,72,92,103,130,187,183,138,219,24,110,11,186,11,194,99,193,189],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "901f6f7627b65d7208a8f605d52135d6ecb8499a9187a9eb638c3e58908c8403", + "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[42,8,122,175,175,253,79,83,153,180,24,123,252,170,141,69,192,249,99,159,50,92,158,197,88,156,134,170,213,164,3,2],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "91a7d6bb507d6d5f80e6341ba81fb91a36ef53dad40cabef939efb7acaca7166", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -4577,7 +4577,7 @@ "noncanonical", "oversized" ], - "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[164,129,114,253,141,88,237,82,71,126,178,81,103,60,87,72,92,103,130,187,183,138,219,24,110,11,186,11,194,99,193,189],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "binding_canonical": "{\"action\":[2,241,228,184,159,244,56,10,67,221,149,42,101,12,185,192,41,4,115,134,162,161,57,145,209,136,226,44,63,133,168,241],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[226,64,92,244,133,189,206,112,245,115,217,226,153,30,5,213,126,247,35,0,251,85,4,78,94,38,67,189,33,198,75,100],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[42,8,122,175,175,253,79,83,153,180,24,123,252,170,141,69,192,249,99,159,50,92,158,197,88,156,134,170,213,164,3,2],\"operation\":\"candidate-1\",\"partition\":\"synthetic-candidate\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":8192,\"projection\":[10,19,169,28,7,92,106,176,225,149,91,163,246,31,140,87,64,38,50,206,105,108,100,168,25,252,161,158,131,172,135,66],\"request\":[34,21,75,72,97,66,130,128,193,230,226,46,167,112,197,118,191,254,64,148,222,106,27,149,37,194,63,102,134,202,3,229]},\"qualification_policy\":\"optional\",\"recipe\":[180,218,234,81,78,245,231,55,19,82,69,198,222,117,228,219,10,112,223,228,83,72,31,224,39,90,223,111,16,140,61,102],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[13,153,126,38,186,172,2,4,168,81,26,183,190,101,43,123,14,96,69,1,199,90,50,54,95,91,16,80,73,32,29,103],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":8192,\"ceiling\":131072,\"key\":[246,115,101,184,224,103,148,224,6,91,104,216,1,145,23,221,209,137,178,11,80,26,249,206,239,254,33,158,195,240,12,138],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", "substitutions_refused": [ "candidate_connection", "expected_previous", diff --git a/bindings/fixtures/gateway/content-compilation.json b/bindings/fixtures/gateway/content-compilation.json index e2c54e9e2..85df3d515 100644 --- a/bindings/fixtures/gateway/content-compilation.json +++ b/bindings/fixtures/gateway/content-compilation.json @@ -151,38 +151,38 @@ "epoch": 1, "namespace": "observer-demo", "native_authority": [ - 157, - 99, - 226, - 53, - 129, - 14, - 10, - 92, - 196, - 224, - 24, - 133, - 70, - 13, - 131, - 113, - 33, - 97, - 223, - 212, - 241, - 100, + 42, 140, - 29, - 127, - 6, - 83, - 132, - 33, - 30, - 117, - 133 + 194, + 52, + 148, + 102, + 96, + 8, + 209, + 67, + 32, + 65, + 32, + 190, + 120, + 122, + 173, + 232, + 101, + 43, + 224, + 15, + 116, + 11, + 254, + 169, + 160, + 126, + 191, + 50, + 222, + 19 ], "operation": "content-1", "partition": "synthetic-content", @@ -540,38 +540,38 @@ "epoch": 1, "namespace": "observer-demo", "native_authority": [ - 157, - 99, - 226, - 53, - 129, - 14, - 10, - 92, - 196, - 224, - 24, - 133, - 70, - 13, - 131, - 113, - 33, - 97, - 223, - 212, - 241, - 100, + 42, 140, - 29, - 127, - 6, - 83, - 132, - 33, - 30, - 117, - 133 + 194, + 52, + 148, + 102, + 96, + 8, + 209, + 67, + 32, + 65, + 32, + 190, + 120, + 122, + 173, + 232, + 101, + 43, + 224, + 15, + 116, + 11, + 254, + 169, + 160, + 126, + 191, + 50, + 222, + 19 ], "operation": "content-1", "partition": "synthetic-content", @@ -773,8 +773,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[123,101,92,8,173,255,47,178,84,221,211,211,157,10,244,34,210,16,194,46,222,70,90,131,141,87,142,77,5,50,32,65],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[126,4,253,125,106,36,2,103,170,218,77,164,116,238,163,187,163,42,101,55,28,247,66,106,113,188,5,248,124,127,255,89],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[157,99,226,53,129,14,10,92,196,224,24,133,70,13,131,113,33,97,223,212,241,100,140,29,127,6,83,132,33,30,117,133],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[186,134,10,64,59,230,78,145,186,124,229,225,104,26,147,18,130,158,9,66,162,160,43,12,79,132,110,59,179,61,92,83],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[83,137,120,1,231,42,164,181,136,48,195,57,129,186,141,180,16,154,233,52,93,205,193,222,118,65,189,144,152,113,240,91],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[105,41,83,124,233,83,68,118,39,19,130,240,203,11,244,235,184,81,198,153,242,222,102,43,170,4,115,0,89,232,184,172],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[247,97,173,99,52,180,40,254,5,133,22,154,109,61,124,66,222,159,107,132,154,217,111,209,174,108,222,216,78,202,9,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "a65b450850b4fda1425590d0f72119cef2b00e4936d4ef0a4377c63fcc191380", + "binding_canonical": "{\"action\":[123,101,92,8,173,255,47,178,84,221,211,211,157,10,244,34,210,16,194,46,222,70,90,131,141,87,142,77,5,50,32,65],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[126,4,253,125,106,36,2,103,170,218,77,164,116,238,163,187,163,42,101,55,28,247,66,106,113,188,5,248,124,127,255,89],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[42,140,194,52,148,102,96,8,209,67,32,65,32,190,120,122,173,232,101,43,224,15,116,11,254,169,160,126,191,50,222,19],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[186,134,10,64,59,230,78,145,186,124,229,225,104,26,147,18,130,158,9,66,162,160,43,12,79,132,110,59,179,61,92,83],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[83,137,120,1,231,42,164,181,136,48,195,57,129,186,141,180,16,154,233,52,93,205,193,222,118,65,189,144,152,113,240,91],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[105,41,83,124,233,83,68,118,39,19,130,240,203,11,244,235,184,81,198,153,242,222,102,43,170,4,115,0,89,232,184,172],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[247,97,173,99,52,180,40,254,5,133,22,154,109,61,124,66,222,159,107,132,154,217,111,209,174,108,222,216,78,202,9,17],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "337005a1e9eb323db2f55a600a993a7935aacc6ea7873abc440a7727858d3ac1", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -1014,38 +1014,38 @@ "epoch": 1, "namespace": "observer-demo", "native_authority": [ - 170, - 43, - 34, - 186, - 94, - 74, - 1, - 23, - 26, - 178, - 211, - 22, - 146, - 255, - 146, - 213, - 204, - 73, - 133, - 210, - 178, - 214, + 104, + 139, + 199, + 120, 37, - 238, - 193, - 9, - 247, - 156, - 169, - 32, - 156, - 136 + 214, + 41, + 95, + 5, + 165, + 211, + 153, + 38, + 97, + 120, + 180, + 56, + 143, + 7, + 51, + 160, + 65, + 172, + 140, + 130, + 14, + 223, + 13, + 69, + 97, + 83, + 178 ], "operation": "content-1", "partition": "synthetic-content", @@ -1403,38 +1403,38 @@ "epoch": 1, "namespace": "observer-demo", "native_authority": [ - 170, - 43, - 34, - 186, - 94, - 74, - 1, - 23, - 26, - 178, - 211, - 22, - 146, - 255, - 146, - 213, - 204, - 73, - 133, - 210, - 178, - 214, + 104, + 139, + 199, + 120, 37, - 238, - 193, - 9, - 247, - 156, - 169, - 32, - 156, - 136 + 214, + 41, + 95, + 5, + 165, + 211, + 153, + 38, + 97, + 120, + 180, + 56, + 143, + 7, + 51, + 160, + 65, + 172, + 140, + 130, + 14, + 223, + 13, + 69, + 97, + 83, + 178 ], "operation": "content-1", "partition": "synthetic-content", @@ -1636,8 +1636,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[254,75,106,241,48,135,66,134,224,169,188,102,74,218,122,253,135,241,38,2,107,192,76,102,120,45,32,206,236,142,87,152],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[25,124,247,121,35,198,106,221,114,109,191,0,209,210,101,184,13,254,251,13,1,211,112,202,103,233,235,145,235,6,25,134],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[170,43,34,186,94,74,1,23,26,178,211,22,146,255,146,213,204,73,133,210,178,214,37,238,193,9,247,156,169,32,156,136],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[191,150,64,208,58,68,35,126,95,94,19,188,108,115,122,96,160,146,172,239,103,210,36,215,169,201,137,184,45,3,170,53],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[134,42,110,152,29,156,1,124,179,237,93,249,136,146,86,80,141,248,26,13,254,119,208,6,67,8,74,194,212,254,38,10],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[10,235,170,233,141,16,25,219,84,66,54,161,67,174,57,187,195,15,251,170,159,44,6,189,118,32,69,81,22,209,79,214],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[179,195,13,135,187,169,232,190,251,252,53,195,183,45,200,128,127,218,53,164,187,69,233,162,187,252,180,121,192,243,7,65],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "b3c4385772ef4f0500e441a3791d30ad6bb90a45684943d66e9a7d6c0f3f9b7b", + "binding_canonical": "{\"action\":[254,75,106,241,48,135,66,134,224,169,188,102,74,218,122,253,135,241,38,2,107,192,76,102,120,45,32,206,236,142,87,152],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[25,124,247,121,35,198,106,221,114,109,191,0,209,210,101,184,13,254,251,13,1,211,112,202,103,233,235,145,235,6,25,134],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[104,139,199,120,37,214,41,95,5,165,211,153,38,97,120,180,56,143,7,51,160,65,172,140,130,14,223,13,69,97,83,178],\"operation\":\"content-1\",\"partition\":\"synthetic-content\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":1024,\"projection\":[191,150,64,208,58,68,35,126,95,94,19,188,108,115,122,96,160,146,172,239,103,210,36,215,169,201,137,184,45,3,170,53],\"request\":[214,240,166,221,112,228,162,33,238,171,168,166,120,148,49,160,197,198,46,163,205,82,67,223,45,156,139,122,15,140,9,146]},\"qualification_policy\":\"optional\",\"recipe\":[134,42,110,152,29,156,1,124,179,237,93,249,136,146,86,80,141,248,26,13,254,119,208,6,67,8,74,194,212,254,38,10],\"reservations\":[{\"amount\":1024,\"ceiling\":16384,\"key\":[10,235,170,233,141,16,25,219,84,66,54,161,67,174,57,187,195,15,251,170,159,44,6,189,118,32,69,81,22,209,79,214],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[179,195,13,135,187,169,232,190,251,252,53,195,183,45,200,128,127,218,53,164,187,69,233,162,187,252,180,121,192,243,7,65],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "168013536ee26baaecb08990af27c71fd2041b8fd8ade3df2fc6b1a1eeb43c07", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", diff --git a/bindings/fixtures/gateway/effect-approval-request.json b/bindings/fixtures/gateway/effect-approval-request.json index 3ef060877..56887be98 100644 --- a/bindings/fixtures/gateway/effect-approval-request.json +++ b/bindings/fixtures/gateway/effect-approval-request.json @@ -1 +1 @@ -{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file +{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[61,227,42,82,28,73,109,128,145,71,131,191,198,183,213,138,223,99,224,114,176,0,120,24,88,191,68,183,156,186,86,168],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-approval.json b/bindings/fixtures/gateway/effect-approval.json index 0d7712592..29713bce1 100644 --- a/bindings/fixtures/gateway/effect-approval.json +++ b/bindings/fixtures/gateway/effect-approval.json @@ -1 +1 @@ -{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"lhYXACHK7PnyzLTJXNlqVR1vaFb2rHfbRgUNInIyVtaxMIV9b1AGv9vKXVuiJ70Rx3Vrrdpb-2b8rD7hXUcdDg"} \ No newline at end of file +{"request":{"approver":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],"effect":[61,227,42,82,28,73,109,128,145,71,131,191,198,183,213,138,223,99,224,114,176,0,120,24,88,191,68,183,156,186,86,168],"expires_at":1790000030,"not_before":1790000000,"schema":"auths.exact-effect-approval/1"},"signature_b64":"DabN65k9hqdKLQ0HNZXsVgJi0bfOKrXVzhtijgQRABHZJ4Zjw22ghwTepLB7JXU_rk25MGFE1JDNT39ZKJpSCw"} \ No newline at end of file diff --git a/bindings/fixtures/gateway/effect-binding.json b/bindings/fixtures/gateway/effect-binding.json index 39c9b4f53..6ff2438d0 100644 --- a/bindings/fixtures/gateway/effect-binding.json +++ b/bindings/fixtures/gateway/effect-binding.json @@ -146,38 +146,38 @@ "epoch": 1, "namespace": "observer-demo", "native_authority": [ - 12, - 223, - 7, - 218, - 165, - 63, - 40, - 255, - 24, - 196, - 38, - 32, - 163, - 189, - 22, + 128, + 122, + 199, + 245, + 21, + 95, + 220, + 211, + 6, + 44, + 221, + 127, + 8, + 116, 212, - 80, - 171, - 110, + 113, + 96, + 93, + 139, + 15, + 113, + 84, + 120, + 135, + 30, + 132, + 88, + 4, 200, - 136, - 172, - 112, - 195, - 198, - 191, - 162, - 85, - 246, - 209, - 25, - 182 + 153, + 224, + 65 ], "operation": "bound-native-1", "partition": "synthetic-partition", @@ -259,8 +259,8 @@ "kind": "unscoped" } }, - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id_hex": "b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[128,122,199,245,21,95,220,211,6,44,221,127,8,116,212,113,96,93,139,15,113,84,120,135,30,132,88,4,200,153,224,65],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id_hex": "3de32a521c496d80914783bfc6b7d58adf63e072b000781858bf44b79cba56a8", "installation": { "alias": "synthetic", "connection_contract": "auths.gateway-operation/1", @@ -394,17 +394,17 @@ "uncertainty": "Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund." } }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 12,\n 223,\n 7,\n 218,\n 165,\n 63,\n 40,\n 255,\n 24,\n 196,\n 38,\n 32,\n 163,\n 189,\n 22,\n 212,\n 80,\n 171,\n 110,\n 200,\n 136,\n 172,\n 112,\n 195,\n 198,\n 191,\n 162,\n 85,\n 246,\n 209,\n 25,\n 182\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"3de32a521c496d80914783bfc6b7d58adf63e072b000781858bf44b79cba56a8\",\n \"binding_canonical\": \"{\\\"action\\\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[128,122,199,245,21,95,220,211,6,44,221,127,8,116,212,113,96,93,139,15,113,84,120,135,30,132,88,4,200,153,224,65],\\\"operation\\\":\\\"bound-native-1\\\",\\\"partition\\\":\\\"synthetic-partition\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"mutation\\\",\\\"request\\\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\\\"reservations\\\":[],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"synthetic-partition\",\n \"epoch\": 1,\n \"operation\": \"bound-native-1\",\n \"action\": [\n 219,\n 243,\n 122,\n 229,\n 143,\n 29,\n 19,\n 240,\n 24,\n 237,\n 170,\n 175,\n 210,\n 164,\n 29,\n 59,\n 66,\n 162,\n 74,\n 103,\n 67,\n 79,\n 155,\n 221,\n 113,\n 192,\n 76,\n 90,\n 209,\n 8,\n 239,\n 133\n ],\n \"native_authority\": [\n 128,\n 122,\n 199,\n 245,\n 21,\n 95,\n 220,\n 211,\n 6,\n 44,\n 221,\n 127,\n 8,\n 116,\n 212,\n 113,\n 96,\n 93,\n 139,\n 15,\n 113,\n 84,\n 120,\n 135,\n 30,\n 132,\n 88,\n 4,\n 200,\n 153,\n 224,\n 65\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 35,\n 115,\n 55,\n 47,\n 0,\n 150,\n 49,\n 135,\n 103,\n 9,\n 208,\n 125,\n 94,\n 182,\n 6,\n 172,\n 251,\n 207,\n 120,\n 195,\n 131,\n 70,\n 177,\n 24,\n 159,\n 158,\n 208,\n 23,\n 9,\n 217,\n 23,\n 89\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 91,\n 45,\n 36,\n 252,\n 80,\n 62,\n 186,\n 89,\n 20,\n 225,\n 233,\n 127,\n 185,\n 175,\n 28,\n 222,\n 171,\n 0,\n 62,\n 94,\n 35,\n 57,\n 163,\n 66,\n 193,\n 2,\n 220,\n 223,\n 114,\n 143,\n 9,\n 14\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [],\n \"protocol\": {\n \"kind\": \"mutation\",\n \"request\": [\n 10,\n 3,\n 212,\n 214,\n 155,\n 114,\n 230,\n 62,\n 87,\n 216,\n 12,\n 154,\n 74,\n 136,\n 62,\n 244,\n 119,\n 78,\n 150,\n 133,\n 199,\n 20,\n 221,\n 144,\n 143,\n 12,\n 172,\n 156,\n 100,\n 132,\n 227,\n 54\n ]\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"schema\": \"auths.gateway-submission-review/1\",\n \"actors\": [\n \"key:sha256:YqztR9B8IBG4DgX4fH9SsnfiTJmaoFToFcgkEqz1aXw\"\n ],\n \"action_commitment\": \"dbf37ae58f1d13f018edaaafd2a41d3b42a24a67434f9bdd71c04c5ad108ef85\",\n \"arguments\": {\n \"operation_id\": \"bound-native-1\",\n \"operator_namespace\": \"observer-demo\",\n \"recipe_digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"record_id\": \"recTEST0000000001\",\n \"replacement\": \"private-sentinel-\\u202eApproved\"\n },\n \"request\": {\n \"method\": \"PATCH\",\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"content_type\": \"application/json\",\n \"body\": \"{\\\"fields\\\":{\\\"DemoStatus\\\":\\\"private-sentinel-\\u202eApproved\\\",\\\"auths_echo\\\":\\\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\\\"}}\",\n \"headers\": [],\n \"idempotency_key\": null\n }\n },\n \"semantic\": {\n \"contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"presentation\": \"literal-complete-values/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": [\n {\n \"kind\": \"text\",\n \"label\": \"record_id\",\n \"argument\": \"record_id\",\n \"value\": \"recTEST0000000001\"\n },\n {\n \"kind\": \"text\",\n \"label\": \"replacement\",\n \"argument\": \"replacement\",\n \"value\": \"private-sentinel-\\u202eApproved\"\n }\n ]\n },\n \"recipe\": {\n \"schema\": \"auths.gateway-recipe-review/3\",\n \"effect_review_contract\": {\n \"schema\": \"auths.effect-review-contract/1\",\n \"consequences\": [\n \"Synthetic fixture mutation; no production semantics or human-review claim.\"\n ],\n \"fields\": {\n \"record_id\": {\n \"kind\": \"text\",\n \"label\": \"record_id\"\n },\n \"replacement\": {\n \"kind\": \"text\",\n \"label\": \"replacement\"\n }\n }\n },\n \"digest\": \"2373372f009631876709d07d5eb606acfbcf78c38346b1189f9ed01709d91759\",\n \"operator_namespace\": \"observer-demo\",\n \"service\": \"gateway-observer-test\",\n \"tool\": \"set_status_v1\",\n \"origin\": \"https://api.airtable.com\",\n \"method\": \"PATCH\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"credential\": {\n \"kind\": \"bearer\"\n },\n \"maximum_body_bytes\": 16384,\n \"has_observation\": true,\n \"sends_idempotency_key\": false,\n \"echo\": {\n \"kind\": \"json-pointer\",\n \"write\": \"/fields/auths_echo\",\n \"observe\": \"/fields/auths_echo\",\n \"disclosure\": \"the gateway writes a token derived from the authorized action into this provider field; the provider stores it and anyone who can read the record can read it; do not declare echo when the observation response may contain secrets\"\n },\n \"preconditions\": null,\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-capability/1\",\n \"class\": \"linked\",\n \"state_observation\": \"verified-locator\",\n \"provider_link\": \"verified-locator\",\n \"unknown_resolution\": \"gateway-reobservation\",\n \"lost_claim_reentry\": {\n \"deduplication\": \"none\"\n },\n \"pre_entry_reread\": false,\n \"write_is_conditional\": false\n },\n \"write_is_conditional\": false,\n \"provider_headers\": null,\n \"credential_guard\": null,\n \"idempotency\": null,\n \"observation\": {\n \"locator\": \"verified-locator\",\n \"path\": [\n \"v0\",\n \"appTEST0000000001\",\n \"tblTEST0000000001\",\n \"\"\n ],\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected_field\": \"replacement\",\n \"maximum_response_bytes\": 16384\n },\n \"pre_entry\": null,\n \"account_scope\": null,\n \"relative_ceiling\": null,\n \"bounds\": null\n },\n \"uncertainty\": \"Approval does not establish provider entry or outcome. Unknown outcomes do not authorize blind retry or refund.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "scope": "native compilation and exact approval; no entry or durability claim", - "effect_id_hex": "b887acd801158c619f6acc6997083c2ebd235b33f58b0e4017036ed0a6329f3f", + "effect_id_hex": "3de32a521c496d80914783bfc6b7d58adf63e072b000781858bf44b79cba56a8", "operation_key_hex": "76c0a947f811d60c92d35fc2e90c9648d46c297d28e2400c6798fa7d96eaf9af", - "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[12,223,7,218,165,63,40,255,24,196,38,32,163,189,22,212,80,171,110,200,136,172,112,195,198,191,162,85,246,209,25,182],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[184,135,172,216,1,21,140,97,159,106,204,105,151,8,60,46,189,35,91,51,245,139,14,64,23,3,110,208,166,50,159,63],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"lhYXACHK7PnyzLTJXNlqVR1vaFb2rHfbRgUNInIyVtaxMIV9b1AGv9vKXVuiJ70Rx3Vrrdpb-2b8rD7hXUcdDg\"}", + "binding_canonical": "{\"action\":[219,243,122,229,143,29,19,240,24,237,170,175,210,164,29,59,66,162,74,103,67,79,155,221,113,192,76,90,209,8,239,133],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[91,45,36,252,80,62,186,89,20,225,233,127,185,175,28,222,171,0,62,94,35,57,163,66,193,2,220,223,114,143,9,14],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[128,122,199,245,21,95,220,211,6,44,221,127,8,116,212,113,96,93,139,15,113,84,120,135,30,132,88,4,200,153,224,65],\"operation\":\"bound-native-1\",\"partition\":\"synthetic-partition\",\"protocol\":{\"kind\":\"mutation\",\"request\":[10,3,212,214,155,114,230,62,87,216,12,154,74,136,62,244,119,78,150,133,199,20,221,144,143,12,172,156,100,132,227,54]},\"qualification_policy\":\"optional\",\"recipe\":[35,115,55,47,0,150,49,135,103,9,208,125,94,182,6,172,251,207,120,195,131,70,177,24,159,158,208,23,9,217,23,89],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[61,227,42,82,28,73,109,128,145,71,131,191,198,183,213,138,223,99,224,114,176,0,120,24,88,191,68,183,156,186,86,168],\"expires_at\":1790000030,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"DabN65k9hqdKLQ0HNZXsVgJi0bfOKrXVzhtijgQRABHZJ4Zjw22ghwTepLB7JXU_rk25MGFE1JDNT39ZKJpSCw\"}", "approver_public_key_hex": "e8da63a40ca687c87cfce05cb24a786c7e75cc49c70db5573f026f1c6a86ceaa", "request_method": "PATCH", "request_url": "https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001", "request_body": "{\"fields\":{\"DemoStatus\":\"private-sentinel-‮Approved\",\"auths_echo\":\"auths-e1-cf82f21a82f942e8d023c76d3a373593db52f56299987e0b795cc714e36befc0\"}}", "evaluated_at": 1790000000, "approval_expires_at": 1790000030, - "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" + "submission_frame_canonical": "{\"action_b64\":\"pgCiAGlhdXRocy5tY3ABAgF4JmFwcGxpY2F0aW9uL3ZuZC5hdXRocy5tY3AtY2FsbC52Mitqc29uAlkBXHsiYXJndW1lbnRzIjp7Im9wZXJhdGlvbl9pZCI6ImJvdW5kLW5hdGl2ZS0xIiwib3BlcmF0b3JfbmFtZXNwYWNlIjoib2JzZXJ2ZXItZGVtbyIsInJlY2lwZV9kaWdlc3QiOiIyMzczMzcyZjAwOTYzMTg3NjcwOWQwN2Q1ZWI2MDZhY2ZiY2Y3OGMzODM0NmIxMTg5ZjllZDAxNzA5ZDkxNzU5IiwicmVjb3JkX2lkIjoicmVjVEVTVDAwMDAwMDAwMDEiLCJyZXBsYWNlbWVudCI6InByaXZhdGUtc2VudGluZWwt4oCuPHRhZz5BcHByb3ZlZCJ9LCJuYW1lIjoic2V0X3N0YXR1c192MSIsInByb2ZpbGUiOiJhdXRocy5tY3AiLCJwcm9maWxlX3ZlcnNpb24iOjIsInNlcnZpY2UiOiJnYXRld2F5LW9ic2VydmVyLXRlc3QifQOiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEE9gWA\",\"approval_b64\":\"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ\",\"proof_b64\":\"qwCiAAEBAAGBogCwAAEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcDaWF1dGhzLm1jcAQCBYGiAGp0b29scy9jYWxsAXgvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEGGmqxLXAHGmqyjQAIgXgbbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0CaEAAAr2CwAM9g2hAAAOeBhnYXRld2F5LW9ic2VydmVyLXRlc3QtdjEPgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OjhHSmRsdkNBcmZ5RjhiYklHTHZUM3dNVmdHNm5lR3FNVnFkTG8yN0p2ZHMCamVkMjU1MTktdjEBWECV9qs4bp4q7jg8Z6UpF_ZYyuNucuJJCYO4U9MCEKOSZSR4Kwr7TT2E-75qGtjIkRwGTBvpWwbTLkEMaVSFM94HAoGiALMAAQFpYXV0aHMubWNwAgIDeCZhcHBsaWNhdGlvbi92bmQuYXV0aHMubWNwLWNhbGwudjIranNvbgRYIGOYSz0t9WKik4RTKTGvOueRKUiVHacZdinl61YmTSXIBWp0b29scy9jYWxsBngvbWNwOi8vZ2F0ZXdheS1vYnNlcnZlci10ZXN0L3Rvb2xzL3NldF9zdGF0dXNfdjEH9gh4G21jcDovL2dhdGV3YXktb2JzZXJ2ZXItdGVzdAlYIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChpqsS1wCxpqsUmQDHg2a2V5OnNoYTI1NjpZcXp0UjlCOElCRzREZ1g0Zkg5U3NuZmlUSm1hb0ZUb0ZjZ2tFcXoxYVh3DVggOW8vmaoam2FN4p60u76LwuIFixiKxnq3WLvvh2U2vr4OWCAc1kCvHZNC1n9-paCf6PSJoBEGstzRko6wiJtMseDH4Q9nbm9uZS12MRBYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLEYASgAGiAKMAanJhdy1rZXktdjEBeDZrZXk6c2hhMjU2OllxenRSOUI4SUJHNERnWDRmSDlTc25maVRKbWFvRlRvRmNna0VxejFhWHcCamVkMjU1MTktdjEBWEB7rFd47wdm0RFW3wKMbjjbdsadKaz2xPP6MxuaXM4swJSvWoXwpyZNAmBrkhoiwSYib6SpqKlHyV0wJhtEu9MGA6IAAAFYIAsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBIKkAFggEJpuvSZan3I2wYiCnBY5o_qrKkOH2px5xK_GRvliF-UBanJhdy1rZXktdjECeCBhcHBsaWNhdGlvbi92bmQuYXV0aHMucmF3LWtleS52MQNYMkFVVEhTLVJBVy1LRVkAAQEAINBKsjJ0K7SrOhNovUYV5ObQIkq3GgFrr4UgozLJd4c3pABYIM0b6nEFus9MTRlltKFjhSwAbYSSsZiRXMcW1wHpnMbrAWpyYXcta2V5LXYxAnggYXBwbGljYXRpb24vdm5kLmF1dGhzLnJhdy1rZXkudjEDWDJBVVRIUy1SQVctS0VZAAEBACCgmqX0emdZgC_5VfjcLSoUpcmdI76X-GQSf_k4NFWk8AWCogCiAAABWCA5by-ZqhqbYU3inrS7vovC4gWLGIrGerdYu--HZTa-vgGBWCAQmm69JlqfcjbBiIKcFjmj-qsqQ4fanHnEr8ZG-WIX5aIAogABAVggVoJJ3WLRxl_VzHN3q4JyDfJItThupOmRg7fuvTjQTZkBgVggzRvqcQW6z0xNGWW0oWOFLABthJKxmJFcxxbXAemcxusGgAeACIAJWQFceyJhcmd1bWVudHMiOnsib3BlcmF0aW9uX2lkIjoiYm91bmQtbmF0aXZlLTEiLCJvcGVyYXRvcl9uYW1lc3BhY2UiOiJvYnNlcnZlci1kZW1vIiwicmVjaXBlX2RpZ2VzdCI6IjIzNzMzNzJmMDA5NjMxODc2NzA5ZDA3ZDVlYjYwNmFjZmJjZjc4YzM4MzQ2YjExODlmOWVkMDE3MDlkOTE3NTkiLCJyZWNvcmRfaWQiOiJyZWNURVNUMDAwMDAwMDAwMSIsInJlcGxhY2VtZW50IjoicHJpdmF0ZS1zZW50aW5lbC3igK48dGFnPkFwcHJvdmVkIn0sIm5hbWUiOiJzZXRfc3RhdHVzX3YxIiwicHJvZmlsZSI6ImF1dGhzLm1jcCIsInByb2ZpbGVfdmVyc2lvbiI6Miwic2VydmljZSI6ImdhdGV3YXktb2JzZXJ2ZXItdGVzdCJ9CoA\",\"schema\":\"auths.gateway-submit/2\"}" } \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-dependency-order-file.json b/bindings/fixtures/gateway/native-dependency-order-file.json index 63dab3167..f9ece532d 100644 --- a/bindings/fixtures/gateway/native-dependency-order-file.json +++ b/bindings/fixtures/gateway/native-dependency-order-file.json @@ -103,6 +103,52 @@ "clock_after_wait": null, "history_inspection_did_not_change_journal": true }, + { + "scenario": "epoch", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "epoch", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-dependency-order-postgres.json b/bindings/fixtures/gateway/native-dependency-order-postgres.json index 57a23c6b9..e44f44abd 100644 --- a/bindings/fixtures/gateway/native-dependency-order-postgres.json +++ b/bindings/fixtures/gateway/native-dependency-order-postgres.json @@ -103,6 +103,52 @@ "clock_after_wait": null, "history_inspection_did_not_change_journal": true }, + { + "scenario": "epoch", + "order": "change-first", + "actual_provider_reads": 0, + "native_history": { + "revision": 1, + "stage": "reserved", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": null, + "response_bytes": null, + "response_version_ok": null + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, + { + "scenario": "epoch", + "order": "grant-first", + "actual_provider_reads": 1, + "native_history": { + "revision": 3, + "stage": "response-recorded", + "reserved_calls": 1, + "reserved_bytes": 1024, + "policy_count_counters": 0, + "policy_byte_counters": 0, + "response_status": 200, + "response_bytes": 21, + "response_version_ok": true, + "content_projection": { + "kind": "ready", + "bytes": 21 + } + }, + "separate_operator_completed": true, + "signed_inputs_unchanged": true, + "admission_time": 1790000000, + "clock_after_wait": null, + "history_inspection_did_not_change_journal": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-file.json b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json index 3c8f95714..e3ffeb98b 100644 --- a/bindings/fixtures/gateway/native-disclosure-entry-order-file.json +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-file.json @@ -98,6 +98,54 @@ "reopened_journal_unchanged": true, "historical_replay_sends_nothing": true }, + { + "scenario": "epoch", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "epoch", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json index f6b3d6d51..365998732 100644 --- a/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json +++ b/bindings/fixtures/gateway/native-disclosure-entry-order-postgres.json @@ -98,6 +98,54 @@ "reopened_journal_unchanged": true, "historical_replay_sends_nothing": true }, + { + "scenario": "epoch", + "order": "change-first", + "native_snapshot": { + "revision": 1, + "stage": "reserved", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 0, + "native_recipient_ack_sent": false, + "captured_wire_bytes_after_authentication_challenge": 0, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": false + }, + { + "scenario": "epoch", + "order": "grant-first", + "native_snapshot": { + "revision": 3, + "stage": "acknowledged", + "reserved_deliveries": 1, + "reserved_bytes": 21, + "policy_count_counters": 0, + "policy_byte_counters": 0 + }, + "separate_worker_operator_processes": true, + "signed_inputs_unchanged": true, + "original_admission_time": 1790000000, + "clock_after_wait": null, + "recipient_bytes": 21, + "native_recipient_ack_sent": true, + "captured_wire_bytes_after_authentication_challenge": 25, + "provider_reads": 1, + "additional_provider_reads": 0, + "credential_leases_at_release": 0, + "reopened_journal_unchanged": true, + "historical_replay_sends_nothing": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-epoch-fence-file.json b/bindings/fixtures/gateway/native-epoch-fence-file.json index 99f23c7bf..75c144a99 100644 --- a/bindings/fixtures/gateway/native-epoch-fence-file.json +++ b/bindings/fixtures/gateway/native-epoch-fence-file.json @@ -47,6 +47,39 @@ ], "provider_reads": 2 }, + "independent_generation_floor": { + "current_generation": 2, + "current_positive_provider_reads": 1, + "cases": [ + { + "case": "older-connection", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "same-generation-substitution", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "missing-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "malformed-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "obsolete-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + } + ], + "premise": "host-local independent floor survives database backup/restore", + "excluded": "rollback of both the complete store and every independent floor" + }, "scope": "actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", "excluded": [ "malicious store rollback without an independent anchor", diff --git a/bindings/fixtures/gateway/native-epoch-fence-postgres.json b/bindings/fixtures/gateway/native-epoch-fence-postgres.json index e6a0334b8..ae8df98a9 100644 --- a/bindings/fixtures/gateway/native-epoch-fence-postgres.json +++ b/bindings/fixtures/gateway/native-epoch-fence-postgres.json @@ -47,6 +47,39 @@ ], "provider_reads": 2 }, + "independent_generation_floor": { + "current_generation": 2, + "current_positive_provider_reads": 1, + "cases": [ + { + "case": "older-connection", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "same-generation-substitution", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "missing-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "malformed-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + }, + { + "case": "obsolete-floor", + "refused_before_custody_and_entry": true, + "attempts_unchanged": true + } + ], + "premise": "host-local independent floor survives database backup/restore", + "excluded": "rollback of both the complete store and every independent floor" + }, "scope": "actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", "excluded": [ "malicious store rollback without an independent anchor", diff --git a/bindings/fixtures/gateway/native-guarded-mutation-crash-file.json b/bindings/fixtures/gateway/native-guarded-mutation-crash-file.json new file mode 100644 index 000000000..ed2f85b21 --- /dev/null +++ b/bindings/fixtures/gateway/native-guarded-mutation-crash-file.json @@ -0,0 +1,818 @@ +{ + "schema": "auths.native-guarded-mutation-crash/1", + "adapter": "file", + "scope": "maintained full Stripe recipe, real HTTP credential/relative reads and mutation, OS SIGKILL, native proof/approval and durable adapters; synthetic credential/key/clock", + "parent_cases": [ + { + "recipe": "stripe-guarded", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + } + ], + "prerequisite_cases": [ + { + "prerequisite_index": 0, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 0, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + } + ], + "excluded": [ + "live provider qualification", + "power loss", + "hostile OS", + "human presence" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-guarded-mutation-crash-postgres.json b/bindings/fixtures/gateway/native-guarded-mutation-crash-postgres.json new file mode 100644 index 000000000..29ab55370 --- /dev/null +++ b/bindings/fixtures/gateway/native-guarded-mutation-crash-postgres.json @@ -0,0 +1,818 @@ +{ + "schema": "auths.native-guarded-mutation-crash/1", + "adapter": "postgres", + "scope": "maintained full Stripe recipe, real HTTP credential/relative reads and mutation, OS SIGKILL, native proof/approval and durable adapters; synthetic credential/key/clock", + "parent_cases": [ + { + "recipe": "stripe-guarded", + "pause": "before-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": true, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-entry-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "during-response", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "unknown" + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-response-commit", + "sigkill": true, + "resume_gate": "current", + "provider_writes_at_kill": 1, + "native_result_after_reopen": { + "outcome": "response-recorded", + "status": 200 + }, + "prior_grant_absent": false, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 1, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "after-reservation-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 1 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 0, + "prerequisite_reads_after_replay": 0, + "retained_prerequisite_records": 0, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "approval-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "authority-expired", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "revoked", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + }, + { + "recipe": "stripe-guarded", + "pause": "before-entry-commit", + "sigkill": true, + "resume_gate": "configuration-replaced", + "provider_writes_at_kill": 0, + "native_result_after_reopen": { + "outcome": "reserved", + "revision": 2 + }, + "prior_grant_absent": true, + "continued_after_fresh_authorization": false, + "provider_writes_after_replays": 0, + "native_count_slots": 1, + "native_sum_units": 500, + "same_reviewed_request_and_declared_idempotency": true, + "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged": true, + "prerequisite_reads_at_kill": 4, + "prerequisite_reads_after_replay": 4, + "retained_prerequisite_records": 4, + "prerequisite_evidence_not_refetched_or_retimestamped": true + } + ], + "prerequisite_cases": [ + { + "prerequisite_index": 0, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 0, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 0, + "provider_reads_after_replays": 0, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 0, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 1, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 1, + "provider_reads_after_replays": 1, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 1, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 2, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 2, + "provider_reads_after_replays": 2, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 2, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "before-reservation-commit", + "sigkill": true, + "child_stage_at_kill": null, + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "after-reservation-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "before-entry-commit", + "sigkill": true, + "child_stage_at_kill": "reserved", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + }, + { + "prerequisite_index": 3, + "pause": "after-entry-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 3, + "provider_reads_after_replays": 3, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "during-response", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "before-response-commit", + "sigkill": true, + "child_stage_at_kill": "entry-granted", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 0, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": true + }, + { + "prerequisite_index": 3, + "pause": "after-response-commit", + "sigkill": true, + "child_stage_at_kill": "response-recorded", + "provider_reads_at_kill": 4, + "provider_reads_after_replays": 4, + "provider_writes_after_replays": 1, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "parent_charges_preserved": true, + "completed_child_evidence_immutable": true, + "replay_creates_no_transport_entry": true, + "unresolved_child_preserves_parent_reservation": false + } + ], + "excluded": [ + "live provider qualification", + "power loss", + "hostile OS", + "human presence" + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-independent-bindings.json b/bindings/fixtures/gateway/native-independent-bindings.json new file mode 100644 index 000000000..b0bd6b498 --- /dev/null +++ b/bindings/fixtures/gateway/native-independent-bindings.json @@ -0,0 +1,96 @@ +{ + "schema": "auths.native-independent-bindings/1", + "scope": "ordinary native signed proof, compiled effect and exact approval; explicit synthetic trust/connection/clock", + "excluded": [ + "durable entry", + "provider execution", + "human presence" + ], + "cases": [ + { + "case": "actor", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "0ef44c858f71c0f218503776f0a0625dc9ed0da1078c810f1db6cf4dc6b0edf5", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "account", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "550aa34b98586d305ba6460a3fef835a85ba8aba1d9b82ca9cfcf2a6941bd5f1", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "credential-generation", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "7b09c56d4170cd0269b93eccc90c32591194dafb37b30d48758baa55a1fa4215", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "partition", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "6a37cc9555f0a7bd66aa970b067d34cb9c76b8dbbca8fff33c558966629cb5f4", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "epoch", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "bc519b75d202987afd7a41859accb4edc37b67732e4e579148a41681c603921a", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "operation", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "80e7fc02450cf8843cb5674eee84a5322dd1943170c6740c0e528f510e34d7a0", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "resource", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "e5ec2ffe6fc79a4c4818878feb79938784824941fd4162a67ccc6ef0eb912f0b", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "body", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "954501ad2171f36c83ee7c4fcd057d255b38ee73cc065f813d24bd27684197a6", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "header", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "063b0fc97864332f1743e96a435022b8fc676a4b77c0091f5cdf8c73c701e707", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "destination", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "b8a37e3c7a309302c503b7783dfd076067cd55b2bfadb055e0f059328f2d8974", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "approver", + "baseline_effect": "490c1bd2e1ce3c3ebca07bbafba9da4f01cd91fd75fb8dc5775754f1b758b9af", + "changed_effect": "6c37e8766fd6c7d02a899408826256a518189fa914b1e81c65e3d894c06be2bb", + "old_exact_approval_refused": true, + "fresh_native_authority_and_approval_accepted": true + }, + { + "case": "namespace", + "native_compilation_refused": true + }, + { + "case": "verifier-configuration", + "native_compilation_refused": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-information-journal-file.json b/bindings/fixtures/gateway/native-information-journal-file.json new file mode 100644 index 000000000..03bcb110a --- /dev/null +++ b/bindings/fixtures/gateway/native-information-journal-file.json @@ -0,0 +1,339 @@ +{ + "schema": "auths.native-information-journal/1", + "adapter": "file", + "scope": "native signed acquisition/disclosure, real HTTP and authenticated Unix delivery, reopened engine and adapter; isolated privileged record corruption", + "excluded": [ + "hostile store rewriting every correlated record", + "whole-store rollback without independent anchor", + "power loss" + ], + "cases": [ + { + "protocol": "acquisition-response", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + }, + { + "protocol": "disclosure-acknowledged", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + }, + { + "protocol": "disclosure-unknown", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-information-journal-postgres.json b/bindings/fixtures/gateway/native-information-journal-postgres.json new file mode 100644 index 000000000..4cbe028fe --- /dev/null +++ b/bindings/fixtures/gateway/native-information-journal-postgres.json @@ -0,0 +1,339 @@ +{ + "schema": "auths.native-information-journal/1", + "adapter": "postgres", + "scope": "native signed acquisition/disclosure, real HTTP and authenticated Unix delivery, reopened engine and adapter; isolated privileged record corruption", + "excluded": [ + "hostile store rewriting every correlated record", + "whole-store rollback without independent anchor", + "power loss" + ], + "cases": [ + { + "protocol": "acquisition-response", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + }, + { + "protocol": "disclosure-acknowledged", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + }, + { + "protocol": "disclosure-unknown", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_reads": 1, + "exact_retained_charges_preserved": true, + "disclosure_replay_sends_zero_bytes": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-file.json b/bindings/fixtures/gateway/native-mutation-entry-order-file.json index 208ef7e7b..c57ae120c 100644 --- a/bindings/fixtures/gateway/native-mutation-entry-order-file.json +++ b/bindings/fixtures/gateway/native-mutation-entry-order-file.json @@ -66,6 +66,38 @@ "reopened_history_unchanged": true, "historical_replay_performs_no_io": true }, + { + "scenario": "epoch", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "epoch", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json index e3b3ffd49..3faedb83d 100644 --- a/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json +++ b/bindings/fixtures/gateway/native-mutation-entry-order-postgres.json @@ -66,6 +66,38 @@ "reopened_history_unchanged": true, "historical_replay_performs_no_io": true }, + { + "scenario": "epoch", + "order": "change-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "reserved", + "revision": 1 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 0, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": false + }, + { + "scenario": "epoch", + "order": "grant-first", + "separate_worker_and_operator_processes": true, + "signed_inputs_unchanged": true, + "native_result": { + "outcome": "response-recorded", + "status": 200 + }, + "admission_time": 1790000000, + "clock_after_wait": null, + "actual_credential_leases": 1, + "actual_provider_writes": 1, + "reopened_history_unchanged": true, + "historical_replay_performs_no_io": true + }, { "scenario": "approval-valid", "order": "lock-wait", diff --git a/bindings/fixtures/gateway/native-mutation-journal-file.json b/bindings/fixtures/gateway/native-mutation-journal-file.json new file mode 100644 index 000000000..51dbd707d --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-journal-file.json @@ -0,0 +1,118 @@ +{ + "schema": "auths.native-mutation-journal/1", + "adapter": "file", + "scope": "native signed mutation, real HTTP, reopened engine and adapter; isolated privileged record corruption", + "excluded": [ + "hostile store rewriting every correlated record", + "whole-store rollback without independent anchor", + "power loss" + ], + "case": { + "protocol": "mutation-response", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_writes": 1, + "retained_charges_preserved": true + } +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-mutation-journal-postgres.json b/bindings/fixtures/gateway/native-mutation-journal-postgres.json new file mode 100644 index 000000000..8c27f5e69 --- /dev/null +++ b/bindings/fixtures/gateway/native-mutation-journal-postgres.json @@ -0,0 +1,118 @@ +{ + "schema": "auths.native-mutation-journal/1", + "adapter": "postgres", + "scope": "native signed mutation, real HTTP, reopened engine and adapter; isolated privileged record corruption", + "excluded": [ + "hostile store rewriting every correlated record", + "whole-store rollback without independent anchor", + "power loss" + ], + "case": { + "protocol": "mutation-response", + "cases": [ + { + "case": "obsolete-schema", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-zero", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-boolean", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "revision-fractional", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "signed-time-unsafe-integer", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-operation", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-binding", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-authority", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "changed-approval", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "missing-entry-evidence", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "inconsistent-protocol", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "truncated", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "noncanonical-whitespace", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "duplicate-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "unknown-member", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, + { + "case": "record-limit-plus-one", + "refused_at_adapter": true, + "original_preserved": true + } + ], + "real_provider_writes": 1, + "retained_charges_preserved": true + } +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-partial-upload-file.json b/bindings/fixtures/gateway/native-partial-upload-file.json new file mode 100644 index 000000000..a649c1665 --- /dev/null +++ b/bindings/fixtures/gateway/native-partial-upload-file.json @@ -0,0 +1,37 @@ +{ + "schema": "auths.native-partial-upload/1", + "adapter": "file", + "scope": "real gateway worker, approved request, TCP relay/destination, SIGKILL, maintained durable store", + "excluded": [ + "kernel backpressure", + "provider atomicity or known non-effect", + "power loss", + "live provider qualification" + ], + "cases": [ + { + "recipe": "airtable", + "sigkill_during_request": true, + "destination_connections": 1, + "declared_native_body_bytes": 125, + "destination_consumed_body_bytes": 1, + "exact_approved_prefix": true, + "complete_destination_requests": 0, + "reopened_result": "unknown", + "retained_charges_and_journal_unchanged": true, + "replay_has_no_custody_or_transport": true + }, + { + "recipe": "stripe-plain", + "sigkill_during_request": true, + "destination_connections": 1, + "declared_native_body_bytes": 49, + "destination_consumed_body_bytes": 1, + "exact_approved_prefix": true, + "complete_destination_requests": 0, + "reopened_result": "unknown", + "retained_charges_and_journal_unchanged": true, + "replay_has_no_custody_or_transport": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/native-partial-upload-postgres.json b/bindings/fixtures/gateway/native-partial-upload-postgres.json new file mode 100644 index 000000000..6744aad1c --- /dev/null +++ b/bindings/fixtures/gateway/native-partial-upload-postgres.json @@ -0,0 +1,37 @@ +{ + "schema": "auths.native-partial-upload/1", + "adapter": "postgres", + "scope": "real gateway worker, approved request, TCP relay/destination, SIGKILL, maintained durable store", + "excluded": [ + "kernel backpressure", + "provider atomicity or known non-effect", + "power loss", + "live provider qualification" + ], + "cases": [ + { + "recipe": "airtable", + "sigkill_during_request": true, + "destination_connections": 1, + "declared_native_body_bytes": 125, + "destination_consumed_body_bytes": 1, + "exact_approved_prefix": true, + "complete_destination_requests": 0, + "reopened_result": "unknown", + "retained_charges_and_journal_unchanged": true, + "replay_has_no_custody_or_transport": true + }, + { + "recipe": "stripe-plain", + "sigkill_during_request": true, + "destination_connections": 1, + "declared_native_body_bytes": 49, + "destination_consumed_body_bytes": 1, + "exact_approved_prefix": true, + "complete_destination_requests": 0, + "reopened_result": "unknown", + "retained_charges_and_journal_unchanged": true, + "replay_has_no_custody_or_transport": true + } + ] +} \ No newline at end of file diff --git a/bindings/fixtures/gateway/prerequisite-compilation.json b/bindings/fixtures/gateway/prerequisite-compilation.json index d900e7541..280e5492d 100644 --- a/bindings/fixtures/gateway/prerequisite-compilation.json +++ b/bindings/fixtures/gateway/prerequisite-compilation.json @@ -4,9 +4,9 @@ "cases": [ { "recipe": "stripe", - "effect_id_hex": "5e675b6266454fd2e26a019279e65198a17caee853a1266ddf4accbf91f106d4", - "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[44,76,76,119,124,12,254,170,84,180,239,78,82,169,5,152,144,73,41,107,198,101,19,12,254,169,85,44,45,173,39,14],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[94,103,91,98,102,69,79,210,226,106,1,146,121,230,81,152,161,124,174,232,83,161,38,109,223,74,204,191,145,241,6,212],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"5pA-_3_xeyEUZp2xs7DSMf8e9KMgQcQoxf7x5LyrEez7T1p-RoMLy9vA-O5SbBvhquLJZlTOmkgz8WriW5U3Ag\"}", + "effect_id_hex": "a648482e4521b60837475807ababec6b257f19f342ad54acd2bb580beec4da86", + "binding_canonical": "{\"action\":[130,16,32,57,24,3,146,100,193,86,219,200,205,82,66,115,201,191,9,99,240,174,44,132,95,142,96,98,66,78,164,107],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[24,192,78,114,138,21,255,36,152,102,240,210,54,47,70,168,240,15,104,94,90,13,135,251,31,210,85,253,150,118,213,255],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"stripe-refunds\",\"native_authority\":[216,211,60,143,142,32,108,52,83,212,13,60,215,177,58,2,179,95,24,26,133,243,145,184,20,103,23,2,229,36,252,229],\"operation\":\"refund-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[134,28,81,120,70,246,220,81,45,172,238,162,176,173,123,184,203,7,149,129,242,144,64,9,82,130,138,173,19,177,102,224]},\"qualification_policy\":\"optional\",\"recipe\":[91,120,213,86,70,158,69,206,156,244,156,168,238,186,56,135,185,248,95,174,1,203,18,0,27,106,82,248,224,67,30,169],\"reservations\":[{\"amount\":1,\"ceiling\":10,\"key\":[41,99,160,99,100,194,62,104,252,43,194,221,247,202,94,242,30,140,150,36,5,157,62,51,233,190,112,84,94,239,26,6],\"unit\":\"mutation-count\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}},{\"amount\":500,\"ceiling\":10000,\"key\":[126,92,18,248,196,186,59,228,72,195,208,41,175,208,151,238,243,75,224,81,223,57,64,212,189,16,1,42,149,34,79,69],\"unit\":\"mutation-sum\",\"window\":{\"index\":497222,\"kind\":\"fixed\",\"seconds\":3600}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[166,72,72,46,69,33,182,8,55,71,88,7,171,171,236,107,37,127,25,243,66,173,84,172,210,187,88,11,238,196,218,134],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"x-OqDq2pwk2SP8t_XnC5G4Eq0MSa38uvKyMyqZN6g_rOo0ySEmkiK3dmjalymivbkFVuRByaZaUBmxOnDiOEAw\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -152,9 +152,9 @@ }, { "recipe": "airtable-pre-entry", - "effect_id_hex": "49616f4f4aea8e4573c21d8a3a23b7ec57a04e2d19d4753050edf999013457c7", - "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[20,33,228,26,122,175,60,204,91,143,120,61,50,23,104,52,9,58,203,106,130,47,42,151,35,78,47,126,85,149,78,156],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[196,179,204,230,124,199,29,48,184,215,4,134,90,67,177,46,20,54,135,67,193,8,14,33,244,241,131,110,60,9,169,113]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[73,97,111,79,74,234,142,69,115,194,29,138,58,35,183,236,87,160,78,45,25,212,117,48,80,237,249,153,1,52,87,199],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"O_pxvpH8kjf3-O5oVW8wyDXwVRzCJwQbIAGE2CQKQ8Jl_Tn5CXYIvUlNXl2QUFTHAWCj2-Eb5XSCeZO2zWAHBg\"}", + "effect_id_hex": "372e6a9a3ba8eae1f3b4bc9e79e3d197b54c31b08776317087beaa3689aedf3f", + "binding_canonical": "{\"action\":[241,55,220,114,2,66,237,102,229,87,50,46,232,125,187,155,20,184,133,151,87,108,6,247,141,45,42,132,217,130,135,248],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[178,207,131,174,160,81,78,130,201,254,201,230,22,253,189,251,134,120,51,48,111,32,192,120,7,78,80,62,139,186,253,211],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"airtable-demo\",\"native_authority\":[183,101,118,247,15,31,68,162,167,106,17,119,57,194,133,5,48,135,180,180,238,253,158,88,213,152,187,81,133,22,210,160],\"operation\":\"update-1\",\"partition\":\"synthetic-prerequisites\",\"protocol\":{\"kind\":\"mutation\",\"request\":[149,173,153,85,71,98,58,91,124,134,226,237,186,36,254,112,98,118,18,99,28,229,135,206,140,155,86,202,142,229,188,167]},\"qualification_policy\":\"optional\",\"recipe\":[244,47,150,220,136,56,129,190,173,221,44,138,114,244,92,253,229,119,251,5,50,85,134,100,81,116,7,242,214,196,105,62],\"reservations\":[],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "approval_canonical": "{\"request\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"effect\":[55,46,106,154,59,168,234,225,243,180,188,158,121,227,209,151,181,76,49,176,135,118,49,112,135,190,170,54,137,174,223,63],\"expires_at\":1790000060,\"not_before\":1790000000,\"schema\":\"auths.exact-effect-approval/1\"},\"signature_b64\":\"J05y7XF8tqPv0GVY-ruCWzRwKkowh3fvP4JfJqHxnqGqviQy-RfMJsf5pYfgbydNciS3m7KBBj45prIKyyKDDA\"}", "prerequisite_acquisitions": [ { "disclosure": "none", @@ -167,38 +167,38 @@ ], "kind": "pre-entry", "native_authority": [ - 20, - 33, - 228, - 26, - 122, - 175, - 60, - 204, - 91, - 143, - 120, - 61, - 50, - 23, - 104, - 52, - 9, - 58, - 203, + 183, + 101, + 118, + 247, + 15, + 31, + 68, + 162, + 167, 106, - 130, - 47, - 42, - 151, - 35, - 78, - 47, - 126, - 85, - 149, - 78, - 156 + 17, + 119, + 57, + 194, + 133, + 5, + 48, + 135, + 180, + 180, + 238, + 253, + 158, + 88, + 213, + 152, + 187, + 81, + 133, + 22, + 210, + 160 ] }, "request": { diff --git a/bindings/fixtures/gateway/recovery-compilation.json b/bindings/fixtures/gateway/recovery-compilation.json index d8d52c914..a7a8a1ad5 100644 --- a/bindings/fixtures/gateway/recovery-compilation.json +++ b/bindings/fixtures/gateway/recovery-compilation.json @@ -1,16 +1,16 @@ { "schema": "auths.gateway-recovery-compilation-fixture/1", "scope": "native signed read proof and file-derived target; test-only source grant; no acquisition entry or provider claim", - "binding_canonical": "{\"action\":[171,198,202,225,243,203,65,91,5,214,168,65,4,109,110,228,223,140,16,10,188,212,112,248,120,129,3,82,154,100,197,149],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[197,245,160,82,8,110,148,140,240,36,214,36,182,137,105,78,44,176,85,247,151,99,31,116,4,136,208,0,175,104,44,2],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[105,134,52,231,249,30,88,84,230,35,83,29,92,17,43,152,6,214,85,94,244,140,91,183,56,236,34,27,17,189,56,177],\"request\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":16384,\"ceiling\":262144,\"key\":[224,89,127,47,134,10,66,191,228,118,95,64,174,22,174,223,117,65,27,148,166,116,190,81,50,2,61,50,176,5,115,58],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":1,\"ceiling\":16,\"key\":[251,243,131,10,106,52,47,231,117,25,236,226,215,203,59,215,151,56,57,169,180,99,211,142,165,11,9,105,230,75,71,71],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", - "effect_id": "70ac806f6bb2257f44fcb1affacab6355b37db22de02d52ebc6c15f5c749497e", + "binding_canonical": "{\"action\":[196,231,133,186,252,9,29,200,39,5,220,239,56,221,42,132,114,76,172,128,91,8,112,241,248,235,134,10,206,213,123,85],\"approval_policy\":{\"approver\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\"kind\":\"exact\"},\"compiler\":\"auths.gateway-effect-compiler/8\",\"configuration\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\"connection\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\"credential_generation\":1,\"epoch\":1,\"namespace\":\"observer-demo\",\"native_authority\":[115,78,173,145,129,176,106,167,248,222,6,245,157,158,36,213,53,208,213,247,185,20,202,221,70,136,249,49,146,146,214,184],\"operation\":\"read-1\",\"partition\":\"recovery-fixture\",\"protocol\":{\"kind\":\"acquisition\",\"maximum_response_bytes\":16384,\"projection\":[146,169,248,163,73,174,132,80,33,209,169,206,166,79,22,13,252,91,181,177,146,106,213,169,119,198,182,148,25,30,255,37],\"request\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\"qualification_policy\":\"optional\",\"recipe\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\"reservations\":[{\"amount\":1,\"ceiling\":16,\"key\":[4,169,197,171,79,205,205,76,9,179,153,146,149,29,203,79,4,241,56,101,27,224,13,75,8,163,36,186,209,131,76,206],\"unit\":\"acquisition-count\",\"window\":{\"kind\":\"source-lifetime\"}},{\"amount\":16384,\"ceiling\":262144,\"key\":[76,217,128,241,145,52,17,113,115,158,5,195,224,160,60,118,114,117,71,22,38,56,47,213,22,21,234,239,219,127,12,87],\"unit\":\"response-bytes\",\"window\":{\"kind\":\"source-lifetime\"}}],\"schema\":\"auths.bound-effect/3\",\"scope\":{\"kind\":\"unscoped\"}}", + "effect_id": "52389764ff22c88de26736be17dd97d9111f91ac9b1668150f282ead5929a73a", "authorization_call": { "arguments": { "maximum_response_bytes": 16384, "operation_id": "read-1", "operator_namespace": "observer-demo", - "read_contract": "698634e7f91e5854e623531d5c112b9806d6555ef48c5bb738ec221b11bd38b1", + "read_contract": "92a9f8a349ae845021d1a9cea64f160dfc5bb5b1926ad5a977c6b694191eff25", "recipe_digest": "4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8", - "source_effect": "4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f", + "source_effect": "4d8397b6016d41a3c82c74bc99443f1c0f5c2f8e13d5ee0d95d9667a66b1f41d", "source_operation": "source-1" }, "name": "auths_gateway_recovery_read_v1", @@ -18,7 +18,7 @@ "profile_version": 2, "service": "gateway-observer-test" }, - "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"70ac806f6bb2257f44fcb1affacab6355b37db22de02d52ebc6c15f5c749497e\",\n \"binding_canonical\": \"{\\\"action\\\":[171,198,202,225,243,203,65,91,5,214,168,65,4,109,110,228,223,140,16,10,188,212,112,248,120,129,3,82,154,100,197,149],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[197,245,160,82,8,110,148,140,240,36,214,36,182,137,105,78,44,176,85,247,151,99,31,116,4,136,208,0,175,104,44,2],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[105,134,52,231,249,30,88,84,230,35,83,29,92,17,43,152,6,214,85,94,244,140,91,183,56,236,34,27,17,189,56,177],\\\"request\\\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[224,89,127,47,134,10,66,191,228,118,95,64,174,22,174,223,117,65,27,148,166,116,190,81,50,2,61,50,176,5,115,58],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[251,243,131,10,106,52,47,231,117,25,236,226,215,203,59,215,151,56,57,169,180,99,211,142,165,11,9,105,230,75,71,71],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 171,\n 198,\n 202,\n 225,\n 243,\n 203,\n 65,\n 91,\n 5,\n 214,\n 168,\n 65,\n 4,\n 109,\n 110,\n 228,\n 223,\n 140,\n 16,\n 10,\n 188,\n 212,\n 112,\n 248,\n 120,\n 129,\n 3,\n 82,\n 154,\n 100,\n 197,\n 149\n ],\n \"native_authority\": [\n 197,\n 245,\n 160,\n 82,\n 8,\n 110,\n 148,\n 140,\n 240,\n 36,\n 214,\n 36,\n 182,\n 137,\n 105,\n 78,\n 44,\n 176,\n 85,\n 247,\n 151,\n 99,\n 31,\n 116,\n 4,\n 136,\n 208,\n 0,\n 175,\n 104,\n 44,\n 2\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 224,\n 89,\n 127,\n 47,\n 134,\n 10,\n 66,\n 191,\n 228,\n 118,\n 95,\n 64,\n 174,\n 22,\n 174,\n 223,\n 117,\n 65,\n 27,\n 148,\n 166,\n 116,\n 190,\n 81,\n 50,\n 2,\n 61,\n 50,\n 176,\n 5,\n 115,\n 58\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 251,\n 243,\n 131,\n 10,\n 106,\n 52,\n 47,\n 231,\n 117,\n 25,\n 236,\n 226,\n 215,\n 203,\n 59,\n 215,\n 151,\n 56,\n 57,\n 169,\n 180,\n 99,\n 211,\n 142,\n 165,\n 11,\n 9,\n 105,\n 230,\n 75,\n 71,\n 71\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 66,\n 7,\n 73,\n 6,\n 121,\n 132,\n 117,\n 195,\n 238,\n 29,\n 134,\n 42,\n 43,\n 244,\n 234,\n 224,\n 113,\n 249,\n 243,\n 111,\n 126,\n 216,\n 98,\n 129,\n 25,\n 87,\n 60,\n 118,\n 61,\n 28,\n 67,\n 54\n ],\n \"projection\": [\n 105,\n 134,\n 52,\n 231,\n 249,\n 30,\n 88,\n 84,\n 230,\n 35,\n 83,\n 29,\n 92,\n 17,\n 43,\n 152,\n 6,\n 214,\n 85,\n 94,\n 244,\n 140,\n 91,\n 183,\n 56,\n 236,\n 34,\n 27,\n 17,\n 189,\n 56,\n 177\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"abc6cae1f3cb415b05d6a841046d6ee4df8c100abcd470f8788103529a64c595\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"698634e7f91e5854e623531d5c112b9806d6555ef48c5bb738ec221b11bd38b1\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"prerequisite_acquisitions\": [],\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4808e5ed05822ddd1d9244fe6c33b5eaaef0fb8f4624fda7567bd91d4e32182f\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", + "literal_review": "{\n \"schema\": \"auths.private-effect-review/2\",\n \"effect_id_hex\": \"52389764ff22c88de26736be17dd97d9111f91ac9b1668150f282ead5929a73a\",\n \"binding_canonical\": \"{\\\"action\\\":[196,231,133,186,252,9,29,200,39,5,220,239,56,221,42,132,114,76,172,128,91,8,112,241,248,235,134,10,206,213,123,85],\\\"approval_policy\\\":{\\\"approver\\\":[232,218,99,164,12,166,135,200,124,252,224,92,178,74,120,108,126,117,204,73,199,13,181,87,63,2,111,28,106,134,206,170],\\\"kind\\\":\\\"exact\\\"},\\\"compiler\\\":\\\"auths.gateway-effect-compiler/8\\\",\\\"configuration\\\":[12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12],\\\"connection\\\":[51,165,232,152,226,144,194,158,190,140,194,107,99,106,39,36,10,136,122,171,178,54,63,148,95,123,198,1,95,53,195,59],\\\"credential_generation\\\":1,\\\"epoch\\\":1,\\\"namespace\\\":\\\"observer-demo\\\",\\\"native_authority\\\":[115,78,173,145,129,176,106,167,248,222,6,245,157,158,36,213,53,208,213,247,185,20,202,221,70,136,249,49,146,146,214,184],\\\"operation\\\":\\\"read-1\\\",\\\"partition\\\":\\\"recovery-fixture\\\",\\\"protocol\\\":{\\\"kind\\\":\\\"acquisition\\\",\\\"maximum_response_bytes\\\":16384,\\\"projection\\\":[146,169,248,163,73,174,132,80,33,209,169,206,166,79,22,13,252,91,181,177,146,106,213,169,119,198,182,148,25,30,255,37],\\\"request\\\":[66,7,73,6,121,132,117,195,238,29,134,42,43,244,234,224,113,249,243,111,126,216,98,129,25,87,60,118,61,28,67,54]},\\\"qualification_policy\\\":\\\"optional\\\",\\\"recipe\\\":[68,7,238,237,159,243,173,8,184,72,245,187,69,8,157,227,71,18,84,143,251,26,232,160,123,118,234,145,105,190,162,200],\\\"reservations\\\":[{\\\"amount\\\":1,\\\"ceiling\\\":16,\\\"key\\\":[4,169,197,171,79,205,205,76,9,179,153,146,149,29,203,79,4,241,56,101,27,224,13,75,8,163,36,186,209,131,76,206],\\\"unit\\\":\\\"acquisition-count\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}},{\\\"amount\\\":16384,\\\"ceiling\\\":262144,\\\"key\\\":[76,217,128,241,145,52,17,113,115,158,5,195,224,160,60,118,114,117,71,22,38,56,47,213,22,21,234,239,219,127,12,87],\\\"unit\\\":\\\"response-bytes\\\",\\\"window\\\":{\\\"kind\\\":\\\"source-lifetime\\\"}}],\\\"schema\\\":\\\"auths.bound-effect/3\\\",\\\"scope\\\":{\\\"kind\\\":\\\"unscoped\\\"}}\",\n \"binding\": {\n \"schema\": \"auths.bound-effect/3\",\n \"namespace\": \"observer-demo\",\n \"partition\": \"recovery-fixture\",\n \"epoch\": 1,\n \"operation\": \"read-1\",\n \"action\": [\n 196,\n 231,\n 133,\n 186,\n 252,\n 9,\n 29,\n 200,\n 39,\n 5,\n 220,\n 239,\n 56,\n 221,\n 42,\n 132,\n 114,\n 76,\n 172,\n 128,\n 91,\n 8,\n 112,\n 241,\n 248,\n 235,\n 134,\n 10,\n 206,\n 213,\n 123,\n 85\n ],\n \"native_authority\": [\n 115,\n 78,\n 173,\n 145,\n 129,\n 176,\n 106,\n 167,\n 248,\n 222,\n 6,\n 245,\n 157,\n 158,\n 36,\n 213,\n 53,\n 208,\n 213,\n 247,\n 185,\n 20,\n 202,\n 221,\n 70,\n 136,\n 249,\n 49,\n 146,\n 146,\n 214,\n 184\n ],\n \"scope\": {\n \"kind\": \"unscoped\"\n },\n \"recipe\": [\n 68,\n 7,\n 238,\n 237,\n 159,\n 243,\n 173,\n 8,\n 184,\n 72,\n 245,\n 187,\n 69,\n 8,\n 157,\n 227,\n 71,\n 18,\n 84,\n 143,\n 251,\n 26,\n 232,\n 160,\n 123,\n 118,\n 234,\n 145,\n 105,\n 190,\n 162,\n 200\n ],\n \"compiler\": \"auths.gateway-effect-compiler/8\",\n \"connection\": [\n 51,\n 165,\n 232,\n 152,\n 226,\n 144,\n 194,\n 158,\n 190,\n 140,\n 194,\n 107,\n 99,\n 106,\n 39,\n 36,\n 10,\n 136,\n 122,\n 171,\n 178,\n 54,\n 63,\n 148,\n 95,\n 123,\n 198,\n 1,\n 95,\n 53,\n 195,\n 59\n ],\n \"credential_generation\": 1,\n \"qualification_policy\": \"optional\",\n \"configuration\": [\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12,\n 12\n ],\n \"approval_policy\": {\n \"kind\": \"exact\",\n \"approver\": [\n 232,\n 218,\n 99,\n 164,\n 12,\n 166,\n 135,\n 200,\n 124,\n 252,\n 224,\n 92,\n 178,\n 74,\n 120,\n 108,\n 126,\n 117,\n 204,\n 73,\n 199,\n 13,\n 181,\n 87,\n 63,\n 2,\n 111,\n 28,\n 106,\n 134,\n 206,\n 170\n ]\n },\n \"reservations\": [\n {\n \"key\": [\n 4,\n 169,\n 197,\n 171,\n 79,\n 205,\n 205,\n 76,\n 9,\n 179,\n 153,\n 146,\n 149,\n 29,\n 203,\n 79,\n 4,\n 241,\n 56,\n 101,\n 27,\n 224,\n 13,\n 75,\n 8,\n 163,\n 36,\n 186,\n 209,\n 131,\n 76,\n 206\n ],\n \"unit\": \"acquisition-count\",\n \"amount\": 1,\n \"ceiling\": 16,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n },\n {\n \"key\": [\n 76,\n 217,\n 128,\n 241,\n 145,\n 52,\n 17,\n 113,\n 115,\n 158,\n 5,\n 195,\n 224,\n 160,\n 60,\n 118,\n 114,\n 117,\n 71,\n 22,\n 38,\n 56,\n 47,\n 213,\n 22,\n 21,\n 234,\n 239,\n 219,\n 127,\n 12,\n 87\n ],\n \"unit\": \"response-bytes\",\n \"amount\": 16384,\n \"ceiling\": 262144,\n \"window\": {\n \"kind\": \"source-lifetime\"\n }\n }\n ],\n \"protocol\": {\n \"kind\": \"acquisition\",\n \"request\": [\n 66,\n 7,\n 73,\n 6,\n 121,\n 132,\n 117,\n 195,\n 238,\n 29,\n 134,\n 42,\n 43,\n 244,\n 234,\n 224,\n 113,\n 249,\n 243,\n 111,\n 126,\n 216,\n 98,\n 129,\n 25,\n 87,\n 60,\n 118,\n 61,\n 28,\n 67,\n 54\n ],\n \"projection\": [\n 146,\n 169,\n 248,\n 163,\n 73,\n 174,\n 132,\n 80,\n 33,\n 209,\n 169,\n 206,\n 166,\n 79,\n 22,\n 13,\n 252,\n 91,\n 181,\n 177,\n 146,\n 106,\n 213,\n 169,\n 119,\n 198,\n 182,\n 148,\n 25,\n 30,\n 255,\n 37\n ],\n \"maximum_response_bytes\": 16384\n }\n },\n \"installation\": {\n \"provider\": \"airtable\",\n \"alias\": \"synthetic\",\n \"connection_id\": \"conn_AAAAAAAAAAAAAAAAAAAAAA\",\n \"credential_generation\": 1,\n \"connection_contract\": \"auths.gateway-operation/1\"\n },\n \"native\": {\n \"protocol\": \"acquisition\",\n \"actors\": [\n \"key:sha256:tKI26y6V4MRuq3tGZoxJePcW5yzy3YZbqXUvX3MKnZg\"\n ],\n \"action_commitment\": \"c4e785bafc091dc82705dcef38dd2a84724cac805b0870f1f8eb860aced57b55\",\n \"arguments\": {\n \"maximum_response_bytes\": 16384,\n \"operation_id\": \"read-1\",\n \"operator_namespace\": \"observer-demo\",\n \"read_contract\": \"92a9f8a349ae845021d1a9cea64f160dfc5bb5b1926ad5a977c6b694191eff25\",\n \"recipe_digest\": \"4407eeed9ff3ad08b848f5bb45089de34712548ffb1ae8a07b76ea9169bea2c8\",\n \"source_effect\": \"4d8397b6016d41a3c82c74bc99443f1c0f5c2f8e13d5ee0d95d9667a66b1f41d\",\n \"source_operation\": \"source-1\"\n },\n \"method\": \"GET\",\n \"prerequisite_acquisitions\": [],\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4d8397b6016d41a3c82c74bc99443f1c0f5c2f8e13d5ee0d95d9667a66b1f41d\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n }\n },\n \"semantic\": {\n \"contract\": \"auths.gateway-recovery-read/1\",\n \"recovery\": {\n \"schema\": \"auths.gateway-recovery-read/1\",\n \"source_effect\": \"4d8397b6016d41a3c82c74bc99443f1c0f5c2f8e13d5ee0d95d9667a66b1f41d\",\n \"source_operation\": \"source-1\",\n \"request\": {\n \"url\": \"https://api.airtable.com/v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001\",\n \"headers\": [],\n \"maximum_response_bytes\": 16384\n },\n \"json_pointer\": \"/fields/DemoStatus\",\n \"expected\": \"Approved\",\n \"echo_pointer\": \"/fields/auths_echo\",\n \"echo\": \"auths-e1-325bc692d30250d578fd0c2c660c9ff54b93d68fbce1f4b9af0c794c1985e74b\",\n \"maximum_attempts\": 16,\n \"maximum_transport_seconds\": 15,\n \"maximum_evidence_age_seconds\": 30,\n \"disclosure\": \"none\"\n },\n \"consequences\": \"Acquire bounded provider evidence only. This does not repeat the mutation, disclose content, prove exclusive causation, refund capacity or change the original actor.\",\n \"prerequisite_acquisitions\": []\n },\n \"renderer\": \"auths.literal-complete-review/1\"\n}", "refused_changed_fields": [ "source_effect", "source_operation", diff --git a/compliance.toml b/compliance.toml index 05e1475fe..229ccbf41 100644 --- a/compliance.toml +++ b/compliance.toml @@ -1672,6 +1672,15 @@ configuration-compiler = [ "product/runtime/auths-gateway/src/recipe/tests.rs#native_review_contract_fixture_is_current", "product/runtime/auths-gateway/src/recipe/tests.rs#effect_review_contract_is_complete_typed_and_recipe_bound", "product/runtime/auths-gateway/src/effect_review_approval_tests.rs#native_review_changes_require_fresh_authority_and_approval", + "product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs#native_independent_binding_substitutions_require_new_approval", + "product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs#native_file_guarded_mutation_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs#postgres_native_guarded_mutation_crash_fixture_is_current", + "product/runtime/auths-gateway/src/native_partial_upload_tests.rs#native_file_partial_upload_fixture_is_current", + "product/runtime/auths-gateway/src/native_partial_upload_tests.rs#postgres_native_partial_upload_fixture_is_current", + "product/runtime/auths-gateway/src/native_information_journal_tests.rs#native_file_information_journal_fixture_is_current", + "product/runtime/auths-gateway/src/native_information_journal_tests.rs#postgres_native_information_journal_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_journal_tests.rs#native_file_mutation_journal_fixture_is_current", + "product/runtime/auths-gateway/src/native_mutation_journal_tests.rs#postgres_native_mutation_journal_fixture_is_current", "product/runtime/auths-gateway/src/effect_native_tests.rs#native_compilation_approval_and_reverification_keep_exact_request", "product/runtime/auths-gateway/src/configuration.rs#native_configuration_fixture_is_current", "product/runtime/auths-gateway/src/native_epoch_tests.rs#native_file_epoch_fence_fixture_is_current", diff --git a/docs/plans/0074-final-acceptance-audit.md b/docs/plans/0074-final-acceptance-audit.md new file mode 100644 index 000000000..4bff1a2c9 --- /dev/null +++ b/docs/plans/0074-final-acceptance-audit.md @@ -0,0 +1,147 @@ +# AP074 final acceptance audit + +This is the current requirement-to-producer map, superseding stale outstanding +work descriptions in historical checkpoints. It does not supersede the spec, +remove a test or establish that authored checks passed. The final coding batch +is implemented and its artifacts are constructed; exact-head hosted verification +is pending. Every row +below therefore remains **unverified on the completed revision**. + +Native test files below are in `product/runtime/auths-gateway/src/`. The +PostgreSQL lifecycle workflow explicitly runs both durable adapters, including +ignored PostgreSQL selectors, and retains real execution logs. A selector must +execute once with one pass and zero ignored; a skipped or zero-match invocation +is not evidence. Application-owned AP070 remains independent. AP073 is untouched. + +## Architecture and phase deliverables + +| Requirement | Authoritative implementation/deliverable | Required closure evidence | +| --- | --- | --- | +| P0 | Spec ownership map, `docs/adr/0017-bound-effect-and-recovery-ownership.md`, `docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md`, `0074-differential-contracts.md`, maintained field/limit/state tables | Audit native managed owners and independent reference consumers; architecture/compliance gates | +| P1 | `effect.rs`, `effect/`, native approval/private complete review; application protocol and thin Python/TypeScript wrappers | Native signed compilation/review/binding corpus plus installed exact approved request | +| P2 | `store.rs`, typed protocols, `transition.rs`, `entry.rs`, `configuration.rs`; file/PostgreSQL adapters | Actual independent-process capacity, crash, dependency, retention, corrupt-state and durability-fault cohorts | +| P3 | Native acquisition/disclosure, separate source/recipient/channel approval, one-use grants and exact ACK | Real HTTP/Unix transports, independent read/release charges, revocation, lost ACK and late evidence; installed read/release journey | +| P4 | Second recipe, independent reference comparisons, installed journey, private/public audit, formal links, cost producers | All A rows and complete exact-head hosted gates; publication on draft PR213, no merge/deploy | + +## Effect and recovery invariants + +| Requirements | Native owner and independent evidence families | +| --- | --- | +| E01 | Sealed verified command and bound effect; `effect_native_tests.rs`, `native_mutation_replay_tests.rs`, installed owner journey compare actual requests | +| E02 | Complete native binding/authority comparison; `effect_binding_boundary_tests.rs`, `effect_review_approval_tests.rs`, `native_scope_tests.rs`, real retained-input conflicts | +| E03 | Shared operation key and durable binding conflict; native process capacity, retained replay and generated concurrent histories | +| E04 | Native verifier, exact approval and fenced current validation remain separate; all three entry-order matrices exercise expiry/withdrawal after admission | +| E05 | Native review/history projections, strict shared result corpus, public/private audit separation; installed Python/TypeScript/UI and sentinel/privacy cohorts | +| R01 | Shared typed transition owner and transaction contract; architecture/source inventory and source-linked translated predicates | +| R02–R03 | Acknowledged atomic admission and final grant precede permit construction; SIGKILL, sync/rename errors, SQL-prefix aborts and lost COMMIT replies on all protocols | +| R04 | Count/sum/lifetime allocation rows are atomic with admission and retained through uncertainty; actual capacity/fault/cleanup and generated history oracles | +| R05–R06 | Separate response, observation and ACK states; crash/response-loss/partial-upload/late-ACK cases preserve Unknown and charges without retry | +| R07 | All three native entry-order cohorts race connection/configuration/epoch and clock changes under actual adapter fences | +| R08 | Immutable prior record/evidence assertions; exact ACK substitutions and independent recovery history preserve source facts | +| R09 | Independent recovery actor/read approval and bounded acquisition; `native_recovery_actor_tests.rs` and its limits/history children | +| R10 | Strict one-format journal decoder, malformed/obsolete native replay corpus, retention tombstones, shared epoch and independently retained generation floors | + +The six compositional proof/runtime obligations and assumptions are mapped in +`0074-assurance-map.md`. Ranges group requirements sharing producers; no invariant +is waived by grouping. Pure proofs do not establish codecs, signatures, store +durability, deployment isolation, clocks, recipients or external provider truth. + +## Executable acceptance rows + +| Row | Concrete producer families and expected observations | +| --- | --- | +| A01 | Native compilation/approval fixture, mutation replay and installed owner journey: same effect and exact request at review, approval and real send | +| A02 | Independent binding and changed-review signed corpora; native scope/read/release/ACK substitutions: old approval refuses, fresh valid control succeeds or unsupported scope refuses before entry | +| A03 | Native process/capacity, retained replay and generated concurrent histories: at most one entry; same-key changed binding conflicts; fresh-key old approval refuses | +| A04 | Native acquisition, mutation and disclosure budget matrices on file/PostgreSQL: final count/byte/sum capacity admits exactly the permitted total and preserves all prior rows | +| A05 | Native acquisition/mutation/disclosure crash matrices; guarded mutation adds 15 parent and 28 child schedules per adapter; partial-upload relay forwards exactly one approved body byte before SIGKILL, retains Unknown/charges and never resends | +| A06 | All three native file-fault, PostgreSQL partial-batch and real COMMIT-reply-loss cohorts: failed/ambiguous acknowledgement returns no new permit; reopened state is authoritative | +| A07 | Source acquisition then real disclosure worker/operator revocation race: refusal has zero wire bytes after authentication, while grant-first retains delivery semantics | +| A08 | Disclosure crashes, lost ACK/commit replies and genuine late ACK: no redelivery, no refund; exact late evidence refines original history | +| A09 | Native ACK corpus and separate gateway/recipient process corpus: re-signed identity/channel/content/source substitutions leave facts and charges unchanged | +| A10 | Native candidate/recovery/partial-upload and installed projections: denied response, timeout, response loss, HTTP response, state match and declared linkage remain distinct | +| A11 | Recovery limits/history: zero/multiple/unrelated/incomplete matches unresolved; exact supported link adds evidence without writes; exhausted calls/bytes/time, aged evidence and unavailable state retain charges/escalation | +| A12 | Acquisition, mutation and disclosure entry-order matrices: independent operators race revocation, configuration and epoch before/after actual fenced grant; stale worker cannot create a new grant | +| A13 | All three entry-order lock waits plus prerequisite freshness: independent approval, resource and observer expiry is sampled under the lock; original signed bytes/times remain unchanged | +| A14 | Genuine threshold authoring and all three entry-order matrices: proof stays Authorized through another branch but changed selected authority cannot reuse old exact approval | +| A15 | Independent writer/reader recovery and retained history: expired/revoked writer grants no recovery write; bounded separately authorized read preserves attribution and charges | +| A16 | Native managed scope, shared-store partition/recipe tests and binding substitutions: no cross-task/recipe/partition alias; unsupported delegated participants refuse without another authority | +| A17 | Public mutation privacy, sentinel output and installed inventory/audit: private facts stay in operator export; public effect/content references use hiding commitments; no secret/proof/body sentinels in public surfaces | +| A18 | Native binding/review/ACK/frame limits, 209 shared Rust/Python/TypeScript result vectors and new strict journal corpora: canonical positives and malformed/duplicate/obsolete/limit negatives agree at the surfaces exposing each type | +| A19 | `qualification/reference/ap074_differential.py` and `ap074_information_differential.py`: two maintained mutation recipes (28 requests/26 responses), 22 acquisition/disclosure comparisons, unchanged independent references and explicit claim differences | +| A20 | Shipping gateway-kernel transition/order/recovery predicates, pinned Charon/Aeneas translation, compiled Lean audit, Kani, refinement/property/mutation suites and generated real concurrent native histories | +| A21 | Native retention, epoch fence and independent floor: retained terminal/reserved facts survive expired slot cleanup; stale controls and database-only generation rollback cannot recreate entry; missing/malformed floors refuse | +| A22 | Source-free installed demo owner journey, native SDK/content journey and Linux unprivileged complete interface inventory: consent/decline/substitution controls, read/release/write/observation/replay/unknown and truthful UI; no alternate managed credential/permit route | + +This composition does not require every negative through every UI and adapter +combination. It does require each row's actual boundary, both durable adapters +where stated, installed binding/UI integration and complete non-bypassability +inventory. Native authority tests cannot substitute for installed integration; +installed happy paths cannot substitute for native adverse concurrency/faults. + +## Verification and artifact checklist + +1. Finish all coding before any constructor or verification run, per AGENTS.md. +2. Construct the new nine selectors plus the changed dependency/entry/epoch + fixtures and the five stale compilation constructors reported by the CI agent. + Collect every independent failure; repair one coherent batch without weakening + assertions. The four mutation prerequisites are account, two denied reads and + relative ceiling. The onboarding probe is separately candidate-authorized. +3. Refresh gateway semantic closure, generated compliance/API identities and + required release metadata once after the source/fixture batch is complete. + Review generated changes; never copy decoded hosted assertion byte arrays. +4. Run required verification on the completed source. The CI agent owns hosted + inspection and holistic repairs; retain exact source/tree/closure identities, + selector counts, adapter logs, differential reports, cost/history artifact + hashes, installed inventory and formal/release evidence. +5. Resolve required `cargo xtask ci` component gates: formatting, architecture, + repository hygiene, build/tests/Clippy, core/MSRV/ABI, wire/compatibility, + bindings/packages/demos, WASM/fuzz, compliance and applicable release/formal + source freshness/adequacy. Inspect conditional skips for applicability. +6. Audit every row against final exact-head evidence before claiming complete. + Hosted runner capacity cancellations remain missing evidence, not passing + platform coverage. No live provider credential, merge or deployment is needed. + +## Supported claim boundaries + +File storage is a trusted single-host durability/fencing boundary; PostgreSQL +requires the maintained TLS/transaction configuration and participating writers. +SIGKILL and modeled syscall faults do not prove power-loss behavior. The partial +upload test observes application-level prefix delivery, not kernel backpressure +or provider atomicity. Generation rollback detection requires independently +retained floors; restoring the whole store and every anchor together remains +unsupported. Browser automation proves the authenticated owner protocol and UI +controls, not human attention. Local recipe/custody fixtures do not qualify a +live provider. These are explicit premises, not excuses to omit acceptance tests. + +AP070 Google metadata/OAuth/productization remains optional future integration. +Its independent Python/SQLite broker receives no managed permits/credentials and +its receipts carry none of AP074's managed guarantees. + +## Local construction and repair execution + +All 22 planned artifact selectors executed. The first aggregate had 21 passes and +one invalid test signing window. The repair aggregate and final binding constructor +passed after correcting that window and using an existing registered header; the +closed header registry was preserved. All 13 binding dimensions now execute even +when another case fails, before the constructor reports the combined failures. +All new file/TLS PostgreSQL crash, upload, journal, epoch and floor cases passed. + +The complete gateway library run executed 298 passing tests, three failures and +63 ignored tests. Both application failures were stale generated fuzz/frame bytes +transitively using the changed approval fixture; their authoritative constructors +now pass. The other failure was `Unavailable` from a raw file-store race under +concurrent local I/O. The unchanged exact file-store conformance selector passes +in isolation. No production deadline, failure handling or assertion was relaxed. +The final six-selector repair cohort passed, including both dependency adapters +with epoch activation retaining the same approver, both frame constructors, +file-store conformance and source closure. The full concurrent run is not relabeled +as passing. The final hosted broad/adapter/platform cohort remains required. + +Gateway all-target/all-feature Clippy, workspace formatting and semantic freeze +checks passed in the aggregate verification phase. The one subsequent source +change isolates epoch from approver replacement in the acquisition test; its two +adapter constructors passed. Source closure is refreshed after that change. +Release metadata advances only the reported identity/public-SDK/public-surface +subjects to 172/168/431, with freeze431. These local results construct and check +the change; they do not close final exact-head hosted or external qualification. diff --git a/docs/plans/0074-final-coding-checklist.md b/docs/plans/0074-final-coding-checklist.md new file mode 100644 index 000000000..a062137af --- /dev/null +++ b/docs/plans/0074-final-coding-checklist.md @@ -0,0 +1,64 @@ +# AP074 final coding batch + +Execution is deferred until this complete coding batch is written, per the +owner's instruction and AGENTS.md. Do not run individual new tests, artifact +constructors, fixture generators or replacement CI cohorts while authoring it. +The existing CI agent may finish observing the already-running 5acd62b0 cohort. + +## Checks to finish writing + +- [x] **Guarded Stripe and prerequisite crashes (A05/A06/A10/A13).** Extend the + existing native mutation crash harness with the maintained full Stripe recipe, + its credential-prefix/account/denied-read checks and relative ceiling. + The onboarding probe remains in the independent candidate protocol. + Cover all seven existing crash points and all eight reserved-continuation + refusals on file and TLS PostgreSQL. Assert exact writes, separate retained + prerequisite records, no repeated reads/charges and original signed times. +- [x] **Partial provider upload (A05/A10).** Exercise a real local connection + that forwards only an approved request prefix and then disconnects. Persisted + grant/charges remain unknown; fresh process/replay sends nothing again. State + the actual socket/relay boundary without claiming kernel backpressure or + provider atomicity. +- [x] **Independent binding substitutions (A02/A16).** Complete the native + signed corpus for actor, resource/body/header/destination, account, credential + generation, verifier configuration, partition/epoch and approval changes. + Retain existing recipient/channel/source/recipe/scope negatives. Each changed + binding refuses old exact approval or requires fresh native authorization; + unsupported scopes never become a second admission authority. +- [x] **Concurrent epoch/configuration and rollback floors (A12/A21).** Use the + existing dependency/epoch harness to order activation against an old-epoch + grant on both adapters. Verify stale configuration/epoch cannot grant, current + controls can, retained records/charges survive and supported floors refuse + regression. Preserve the explicit whole-store rollback exclusion. +- [x] **Malformed/obsolete journal records (A18/R10).** Add a shared corpus over + retained mutation/acquisition/disclosure records on both adapters: obsolete + schema, duplicate/noncanonical members, revision/type bounds, changed immutable + binding, inconsistent protocol/evidence and oversized state. Reopen refuses + without custody, provider/delivery entry or a regenerated permit. +- [x] **Acceptance reconciliation.** Map P0–P4, E01–E05, R01–R10 and A01–A22 to + exact source/test/artifact producers and explicit assumptions. Resolve stale + historical "remaining" notes against current implementation. Missing behavior + stays open; existing evidence is not discarded merely because an old note is + stale. AP070 stays independent and AP073 stays untouched. + +## Final verification phase — only after coding is complete + +- [x] Construct all new/changed canonical fixtures together, collecting every + independent failure before repairing the complete batch. +- [x] Regenerate the five stale native compilation constructors identified by + the CI agent, covering their fourteen transitive fixture files. Preserve all + assertions; use the authoritative constructors, not decoded CI byte arrays. +- [x] Refresh source closures, compliance/API evidence and required semantic + identities once after the complete source/fixture changes. +- [ ] Run the affected verification as a batch, collect failures, fix them + together, and publish the complete revision. The CI agent owns hosted checks. +- [ ] Audit final exact-head native adapter/concurrency/crash/containment, + installed Python/TypeScript/UI, differential, cost, formal/refinement, + mutation/release and platform evidence. No skipped required gate or merely + authored producer counts as completed acceptance. + +Already written before this batch: public/private audit separation, strict +209-vector result parity, four-path native cost measurement, generated native +concurrent replay histories, six-property assurance map and five signed changed- +review/thirteen incomplete-review cases. Retain these; do not expand their scope +while the remaining checklist is being written. diff --git a/docs/plans/0074-generated-histories.md b/docs/plans/0074-generated-histories.md index 6d8061f3a..eb23dfd22 100644 --- a/docs/plans/0074-generated-histories.md +++ b/docs/plans/0074-generated-histories.md @@ -41,7 +41,12 @@ count/sum capacity, crash durability, hostile-process containment or provider qualification. Those remain the responsibility of the existing source-linked kernel/refinement and file/PostgreSQL fault, capacity, entry, disclosure and independent-recovery evidence. No production decision, journal or retry owner is -added. Hosted execution is pending; this source does not close A20 on its own. +added. The CI agent verified both selectors on source `5acd62b0`, each exactly +once with one pass and zero ignored, retaining ZIP artifact `13359018734` +(SHA256 `2f3572c91035a9cd7a022d489dd38377fb38a278ed417bba3aba49705aef4295`). +Both reports contain all four seeds, 72 workers per backend, actual HTTP/native +counters and preserved replay bytes. This earlier-source evidence cannot qualify +the final changed head or close A20 on its own. Installed trust, signer keys, provider credentials and clock are explicit synthetic fixtures. Ordinary native verification and exact signatures still execute; the diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 3e5bd787a..bdafef3a1 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3460,46 +3460,27 @@ Semantic metadata construction advances freeze421 and only reported changed identity164/public-SDK161/public-surface421 subjects. Formal translation closure remains a002; metadata construction is not new hosted or formal qualification. -## Phase gates +## Current phase and acceptance gates — final coding batch -| Phase | State | Outstanding gate | +The [final acceptance audit](0074-final-acceptance-audit.md) is the current +P0–P4, E01–E05, R01–R10 and A01–A22 producer/requirement map. It supersedes the +stale outstanding-work descriptions in earlier checkpoint tables, without +removing any spec requirement or test. The historical checkpoints above and below +remain provenance, not instructions to reimplement later completed behavior. + +| Phase | Current implementation | Unclosed gate | | --- | --- | --- | -| P0 | Owner decision and limits documented | Keep consumer inventory current during cutover | -| P1 | Binding, approval and native review contract wired; installed write/recovery owner UI executed on74ce | New complete content journey and remaining adversarial review/binding parity evidence | -| P2 | Ordered admission, mutation grant/restart and linked recovery refinement wired | Full public recovery actions, installed fault/race evidence and formal links | -| P3 | Acquisition/disclosure runtime, call authoring and CLI composition wired; installed Python/TypeScript acquisitions and native recipient UI authored | New exact-head installed journey execution and remaining native adverse read/release cases; AP070 stays independent | -| P4 | Partial CLI process journey | Differential, full faults/adapters, installed bindings/UI, formal/performance links and CI | - -## Acceptance ledger - -`Authored` means scenario source exists, not that it passed. `Executed` requires -the exact tested revision and a reproducible result. External qualification is a -separate claim. No complete AP074 acceptance gate is currently closed or externally qualified. - -| Case | Required evidence | Implementation / authored / executed | Limitation or next work | -| --- | --- | --- | --- | -| A01 | Same bound identity and exact request across review/approval/send | Partial / native review/compiler and real mutation replay corpus / ten file/TLS PostgreSQL histories send the exact reviewed PATCH body | Full installed review-completeness and authenticated human/UI evidence pending | -| A02 | Independent mutation of every binding dimension | Partial / bound-effect corpus, native retained-input controls and 58 valid-authority acquisition/disclosure substitutions on file/TLS PostgreSQL / closed scope/contract/source/recipient/channel/delivery substitutions refused without admission or I/O | Complete independent substitutions for every binding dimension and installed surface remain required | -| A03 | Concurrent/restart replay, conflict, approval reuse | Partial / adapter, candidate process and native retained histories / forty file/TLS PostgreSQL replay histories executed, with original/reopened mutation engines and reopened acquisition/disclosure engines | Full native mutation/disclosure concurrent schedules and installed binding evidence remain required | -| A04 | Final count/byte/sum capacity, file and PostgreSQL | Partial / native lifetime/acquisition histories executed; twelve mutation/disclosure count/sum/both contention histories now constructed on both adapters using prefix plus two OS contenders | New-head hosted confirmation and complete dependency-change/adverse grant schedules remain required | -| A05 | Crash at every persistence/transport boundary | Partial / native acquisition and mutation worker matrices plus daemon-recipient ACK loss / fourteen acquisition and sixty mutation/continuation file/TLS PostgreSQL histories executed, including native Stripe count/sum retention and current-authority refusal after restart | Full guarded Stripe/prerequisite and disclosure schedules, partial uploads, ACK persistence and actual durability faults remain | -| A06 | Sync/rename, partial batch, ambiguous commit/CAS | Partial / 47 modeled file-error histories, eleven actual PostgreSQL admission-prefix aborts and twenty committed/aborted reply-loss histories across all protocols | Remaining adverse/installed cases and runtime-refinement/durability assumptions required | -| A07 | Revoke between acquisition and disclosure | Partial / daemon corpus plus native file/TLS PostgreSQL worker/operator release races / withdrawal before final grant produces no post-authentication wire bytes or ACK, while grant-first records exact delivery/ACK | Complete revocation scopes and installed boundary races | -| A08 | ACK loss, restart, no redelivery, late ACK | Partial / daemon/recipient, native crash, commit-reply loss and file-error corpora / fifty-six release crash histories, eight committed/aborted release transactions and eighteen file-error histories retain charges through lost grants and ACK/Unknown persistence; genuine late ACKs never authorize redelivery | Remaining adverse races, runtime links and full installed boundary evidence pending | -| A09 | ACK substitution in every dimension | Partial / signed ACK corpus plus actual gateway/recipient OS-process corpus on both stores / three hundred re-signed/signature substitutions against real retained grants rejected before thirty genuine late ACKs | Remaining installed language/containment and complete negative parity evidence required | -| A10 | Timeout/denial/response/state-match distinction | Partial / candidate HTTP and independent native recovery histories / six candidate process histories plus eight file/TLS PostgreSQL histories distinguish denial, lost/recorded response, state equality and declared echo linkage | Complete installed mutation, observation and disclosure projections | -| A11 | Missing/multiple/unrelated/incomplete reconciliation | Native implementation and file/TLS PostgreSQL HTTP constructors cover zero, multiple, unrelated and incomplete observations; elapsed native transport timeout; lifetime usage, escalation and conservative unavailable-store responses | Current-head hosted confirmation; full installed/interface evidence remains under A22 | -| A12 | Revocation/configuration races with both entries | Partial / socket-file disclosure gate, native acquisition plus 24 mutation and 24 disclosure worker/operator histories / actual file/TLS PostgreSQL writer-fence schedules order withdrawal around final grant | Complete dependency/revocation scopes and installed/adverse races remain required | -| A13 | Lock wait and independent evidence expiries | Partial / prerequisite age and native acquisition/mutation/disclosure proof/approval/observer/threshold lock waits / eligible and expired controls executed on file/TLS PostgreSQL, with zero post-authentication disclosure wire bytes on refusal | Remaining dependency/revocation scopes and installed/adverse evidence required | -| A14 | Valid threshold selection changes | Partial / genuine native 1-of-2 proof and independent worker/operator writer-fence controls across all three protocols / 12 file/TLS PostgreSQL threshold histories preserve Authorized proof while changed selected authority invalidates the old still-current exact approval | Complete installed language/UI and remaining selected-authority/adverse boundaries required | -| A15 | Recovery actor differs; original authority revoked | Native implementation / eight independent writer/reader OS-process histories plus eight retained-history schedules on file/TLS PostgreSQL; writer withdrawal, reader grant/approval expiry and root withdrawal preserve attribution/charges while blocking new entry | Current-head hosted confirmation; further final-entry scopes remain under A12/A13 and installed owner/interface evidence under A22 | -| A16 | Cross-task/recipe/partition substitution | Partial / native valid-authority unscoped negatives and four shared-store file/TLS PostgreSQL partition/recipe histories / foreign approval, retained history and release provenance refused; original facts retained | Complete installed-boundary and remaining scope substitution evidence; no AP073 task implementation required | -| A17 | Sentinel privacy across errors/logs/public bindings | Partial / candidate output sentinels / local acquisition stdout/stderr | Full logs, receipts and binding privacy evidence | -| A18 | Canonical/malformed/duplicate/limit binding corpus | Partial / native tests and cross-language control cases / native closed content-frame corpus executed | Full binding parity and negative corpus execution pending | -| A19 | Stripe/Airtable and acquisition/disclosure differential | Partial / independent mutation and post-authorization information comparisons against unchanged references / hosted74ce mutation 28 requests + 26 responses, information 22 pairs across both adapters and 104 source/parser controls passed | Named A19 contracts audited in the differential-contracts document; final-head confirmation remains required, with AP070 independence and divergent claims retained | -| A20 | Generated histories and shipping predicate refinement | Partial / typed histories, source-linked three-protocol transition/submission refinement, Kani source / 329-statement audit, pinned qualification and four Rust refinement tests executed locally | Full generated concurrent durable histories, mutation campaigns and final hosted formal evidence remain required | -| A21 | Tombstones, stale state, supported rollback floors | Partial / bounded maintenance/shared clock and stable epoch control; native terminal/reserved mutation/disclosure cleanup now constructed on both stores with original authority/approval times still current and unchanged permanent rows | New-head hosted confirmation, concurrent epoch/configuration schedules and supported rollback-floor evidence remain required | -| A22 | Installed single-human/single-agent full journey/UI | Partial / native CLI journey and hosted74ce write/recovery UI; CI subagent reports repaired source-free full Python/TypeScript acquisition/native disclosure/write/observation/unknown reproduction passed against original ab980 package plus repaired payloads | Exact new-head hosted confirmation, complete hostile interface inventory and remaining adverse/negative integration evidence | +| P0 | Native owner/consumer map, ownership ADR, abstraction and independent reference contracts documented | Final source inventory and architecture/compliance audit | +| P1 | Immutable binding, exact approval, complete literal review and installed native request path; independent binding/review substitutions authored | Construct final corpus and verify exact-head native/SDK/UI evidence | +| P2 | Sole typed journal/transition and admission/entry fence; all-protocol adapter races, crashes, faults and recovery; final guarded/partial-upload/journal batch authored | Final artifact construction and exact-head adverse adapter evidence | +| P3 | Native acquisition, separate recipient disclosure/ACK, retained history and thin installed wrappers | Final exact-head installed journey plus adverse read/release evidence | +| P4 | Two-recipe/information differential, installed owner journey, complete restricted interface inventory, public/private audit, translated/formal links, cost and generated histories implemented | Complete final hosted cohort, formal/release/platform gates and requirement audit | + +All A01–A22 remain **unverified on the final revision** until the new batch and +all required exact-head gates execute. The final audit names a concrete producer +and expected boundary observation for every row. Earlier passing source revisions +are useful regression evidence and cannot qualify later changes. External live +provider qualification is a separate, unclaimed deployment property. ## Deployment assumptions retained @@ -4024,3 +4005,75 @@ surface430, only as required by the changed compliance evidence inventory. Hosted execution and complete acceptance closure remain pending. Main has not inspected CI or run local SDK, lint, broad test or formal suites. Semantic metadata construction passed for this review-evidence batch. No complete acceptance row is closed by the constructor alone. + +## Complete final hardening batch authored — verification pending + +The finite [coding checklist](0074-final-coding-checklist.md) is written before +execution, following the owner's batch instruction now recorded in AGENTS.md. +No test, formatter, fixture constructor or new CI cohort ran while authoring it. + +- Full maintained Stripe mutation: four installed prerequisite acquisitions + (account, two denied reads, relative ceiling), 15 parent schedules and 28 child + schedules per durable adapter. Onboarding probe remains candidate-owned. + Completed evidence stays byte-identical. Lost child grants preserve the parent + reservation, do not refetch evidence or create transport, and never refund. +- Actual TCP partial-upload relay forwards one approved body byte, kills the + gateway worker, then disconnects. Reopen retains Unknown and charges, with no + new custody/transport on replay; no kernel-backpressure or provider-atomicity + guarantee is claimed. +- Thirteen independent real-signed binding substitutions plus original/fresh + approval controls. Unsupported namespace/configuration refuses compilation. +- Epoch activation added to all three independent worker/operator entry-order + matrices on both adapters. Native generation-two positive, database-only + regression, same-generation substitution and missing/malformed/obsolete + independent floors retain facts and refuse before custody/entry. +- Shared corrupt-journal corpus over mutation, acquisition, acknowledged release + and lost-ACK release. Each variant preserves writer encoding except explicit + encoding negatives, so canonicalization cannot mask independent checks. + Obsolete, duplicate, malformed, zero/unsafe/fractional/bool revision, changed + immutable bindings/approval/authority and inconsistent evidence refuse before + custody or transport. Exact restored positives pass without replay I/O. + Oversized replacement refuses at the adapter and preserves original bytes. + +The shared journal decoder now requires its existing writer encoding and a +nonzero JSON-safe revision/time. Corrupt history yields typed indeterminate +state rather than manufacturing non-entry. No compatibility reader or second +production interpretation is added. New explicit CI selectors collect every +independent hardening failure before exiting, retaining separate logs without +changing the existing independent-reference log inventory. + +Construction, metadata refresh, combined verification and final hosted audit +are pending. AP070 remains independent and AP073 remains untouched. + +## Final batch construction and aggregate verification + +All planned new artifacts and changed native histories are constructed. Both +maintained adapters passed the 43 guarded parent/prerequisite schedules, both +partial-upload recipes, all corrupt-journal protocol corpora, independent floor +cases and three-protocol epoch races. The 13 signed binding dimensions pass with +original/fresh approval controls. Its fixture now collects independent case +failures rather than stopping at the first one. The epoch-only acquisition race +retains the same approver, keeping epoch and approver changes independent. + +The initial 22-selector construction aggregate passed21/failed1; collected repairs +corrected test-only action/grant validity and a header outside the existing closed +registry, plus five Clippy diagnostics using focused helpers and an enum. No +shipping authority rule or test assertion was weakened. The five previously +reported stale native compilation constructors passed with authoritative outputs. + +Aggregate verification: gateway library298passed/3failed/63ignored; all-target, +all-feature gateway Clippy passed; workspace formatting passed; semantic freeze +passed62entries/43publicRustpackages. Two failures were transitive application +fuzz/frame artifacts using the regenerated native approval. Their constructors +pass after regeneration. The remaining file-store raw race returnedUnavailable +under concurrent local I/O, then passed its unchanged exact selector in isolation. +No production deadline or assertion was relaxed; the full concurrent local run +remains recorded as failed, not silently replaced by a narrow success. + +The final six-selector repair cohort passed both application constructors, both +dependency adapters, unchanged file-store conformance and final source closure. +All new/affected behavioral constructors pass. Metadata construction advances +freeze431 and only reported identity172/publicSDK168/publicsurface431 subjects. +Final hosted broad, adapter, platform, installed, containment, differential, +formal/refinement/release and performance evidence remains the CI agent's job. +The goal remains incomplete until its exact-head completion audit passes. diff --git a/docs/plans/0074-native-cost-evidence.md b/docs/plans/0074-native-cost-evidence.md index 711c6665e..f3ac240e5 100644 --- a/docs/plans/0074-native-cost-evidence.md +++ b/docs/plans/0074-native-cost-evidence.md @@ -57,6 +57,42 @@ and content ceilings remain separately enforced. Eight small test-profile samples characterize these representative paths, not production p95 latency, maximum-population scan cost or worst-case heap usage. The raw distribution must remain available; no latency optimization may weaken -native dependency verification, fresh fence validation or durability. Exact-head -hosted execution and its actual measured values are still pending. These source -changes alone close no acceptance row and do not establish complete P4 closure. +native dependency verification, fresh fence validation or durability. The CI agent verified source `5acd62b0` measurements and retained artifact hashes; +the measured table below is earlier-revision evidence. The final changed head +remains unverified and complete P4 closure is still pending. + + +## Native cost measurements + +Producer [PostgreSQL41903640108/job126832350307](https://github.com/auths-dev/auths-proof/actions/runs/41903640108/job/126832350307), attempt1. Downloaded artifact13358744149 ZIP SHA256 `c2f22d2ed1be9a81a6b9491fe06f88e551acb58c271970288c3fd99318e52825` verified. Raw files below preserve source5acd, merge4906 and gateway closurec461 identities above. Eight small test-profile fixtures per path per adapter; no production SLO or worst-case claim. + +All duration cells are **minimum / median / maximum milliseconds**, calculated directly from retained integer nanoseconds. Compilation includes native verification. Fenced callback and adapter per-call ranges pool the real execution callbacks/calls across eight samples; adapter totals sum elapsed calls within each execution sample. Adapter duration includes wait/load/decision/persistence/unlock; it is not isolated lock-hold time. Callback duration includes native validation and encoding, with no provider/custody I/O. + +| Backend/path | Verification | Compilation | Exact approval | Execution | Fenced callback, per call | Adapter, per call | Adapter total/sample | +|---|---:|---:|---:|---:|---:|---:|---:| +| file/mutation | 0.682 / 0.759 / 0.790 | 2.389 / 2.461 / 2.524 | 0.186 / 0.187 / 0.204 | 30.973 / 35.151 / 52.722 | 3.701 / 4.471 / 5.377 | 0.012 / 0.022 / 24.431 | 11.935 / 14.936 / 31.409 | +| file/recovery | 0.691 / 0.722 / 0.800 | 6.650 / 6.764 / 6.888 | 0.175 / 0.177 / 0.193 | 62.791 / 63.183 / 82.912 | 7.612 / 10.348 / 18.844 | 0.011 / 0.027 / 19.982 | 33.828 / 34.604 / 44.607 | +| file/acquisition | 0.746 / 0.757 / 0.772 | 3.602 / 3.664 / 3.779 | 0.182 / 0.189 / 0.199 | 47.814 / 54.784 / 65.110 | 5.845 / 7.281 / 9.007 | 0.012 / 0.022 / 15.214 | 18.172 / 18.794 / 25.689 | +| file/disclosure | 0.716 / 0.753 / 0.782 | 3.216 / 3.323 / 3.369 | 0.187 / 0.189 / 0.200 | 68.578 / 70.135 / 102.108 | 10.345 / 14.997 / 20.797 | 0.011 / 0.025 / 36.314 | 33.468 / 34.663 / 58.944 | +| postgres/mutation | 0.733 / 0.767 / 0.941 | 3.255 / 3.374 / 5.180 | 0.186 / 0.194 / 0.214 | 38.226 / 38.814 / 40.923 | 3.705 / 4.496 / 5.337 | 0.363 / 0.449 / 7.956 | 18.008 / 18.683 / 20.254 | +| postgres/recovery | 0.694 / 0.714 / 0.902 | 8.021 / 8.125 / 10.153 | 0.174 / 0.181 / 0.202 | 76.172 / 78.377 / 88.508 | 7.647 / 10.447 / 12.775 | 0.363 / 0.484 / 18.087 | 47.319 / 48.335 / 59.375 | +| postgres/acquisition | 0.731 / 0.769 / 1.950 | 4.489 / 4.547 / 5.954 | 0.182 / 0.185 / 0.206 | 52.586 / 68.293 / 83.657 | 5.900 / 7.351 / 8.877 | 0.325 / 0.454 / 11.710 | 25.783 / 31.355 / 36.357 | +| postgres/disclosure | 0.709 / 0.748 / 0.775 | 4.151 / 4.177 / 4.728 | 0.191 / 0.192 / 0.211 | 77.029 / 78.328 / 85.115 | 10.530 / 14.824 / 21.274 | 0.376 / 0.476 / 24.747 | 41.644 / 42.753 / 45.029 | + +Snapshot bytes/records are maximum observed boundary values across compilation and execution, not allocator totals. RSS is Linux whole-process memory, including runtime/provider; high-water is cumulative for the test cohort, not an independent peak per path. + +| Backend/path | Execution adapter calls / callbacks | Max snapshot bytes | Max snapshot records | RSS KiB min/median/max | Cohort high-water KiB | +|---|---:|---:|---:|---:|---:| +| file/mutation | 88 / 16 | 4529 | 3 | 32984 / 33720.0 / 34048 | 34048 | +| file/recovery | 104 / 24 | 12022 | 18 | 33324 / 33778.0 / 34084 | 34084 | +| file/acquisition | 136 / 16 | 7332 | 4 | 34416 / 34970.0 / 35272 | 35272 | +| file/disclosure | 96 / 16 | 16693 | 5 | 34708 / 35024.0 / 35336 | 35336 | +| postgres/mutation | 88 / 16 | 4529 | 3 | 37860 / 38720.0 / 39036 | 39036 | +| postgres/recovery | 104 / 24 | 12022 | 18 | 38308 / 38786.0 / 39080 | 39080 | +| postgres/acquisition | 136 / 16 | 7332 | 4 | 41240 / 41652.0 / 41952 | 41952 | +| postgres/disclosure | 96 / 16 | 16694 | 5 | 41460 / 41696.0 / 42016 | 42016 | + +| Raw artifact member | SHA256 of archived member | +|---|---| +| native-cost-file.json | `22f49ae6d0071091a0dbf09923440ab875bb64b4ae29a88550e3654c60083df0` | +| native-cost-postgres.json | `777c78520adcc125a83a770e1f332015ed7ad2130ecb250e28aec34e96400842` | diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 109a2267e..37ca00e51 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -1203,6 +1203,13 @@ Whole-store rollback is outside ordinary crash recovery. Keep existing commissio Persist sensitive reconstruction data only if necessary and protected. If private content is intentionally not retained, recovery may remain unresolved; it must not refetch or redeliver to manufacture certainty. +Native journal replay accepts only the current native writer encoding. Reject +obsolete schemas, duplicate/unknown members, alternate encodings, zero or +non-JSON-safe revisions/times and inconsistent binding/protocol/evidence before +history can confer any retained execution fact. Corrupt state is indeterminate; +it cannot establish that an operation was not entered. Adapter byte limits apply +before decoding. Runtime must not repair, migrate or re-sign corrupt state. + ## 7. Central implementation surfaces The implementation should expose a small set of Rust-owned operations, with exact names chosen during the source mapping: diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content index 9a8365f15..2d5b23d0b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/content @@ -1 +1 @@ -{"schema":"auths.gateway-content/1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file +{"schema":"auths.gateway-content/1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose index a0b54327b..dfb556a2e 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/disclose @@ -1 +1 @@ -{"schema":"auths.gateway-disclose/1","target":{"source_operation":"fixture-source","recipient_key":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19],"channel":{"schema":"auths.gateway-unix-disclosure-channel/1","gateway_uid":100,"recipient_uid":101,"channel_id":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19]},"delivery_instance":[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20]},"submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file +{"schema":"auths.gateway-disclose/1","target":{"source_operation":"fixture-source","recipient_key":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19],"channel":{"schema":"auths.gateway-unix-disclosure-channel/1","gateway_uid":100,"recipient_uid":101,"channel_id":[19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19]},"delivery_instance":[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20]},"submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover index 852aeddc5..cfddcfd6b 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/recover @@ -1 +1 @@ -{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"}} \ No newline at end of file +{"schema":"auths.gateway-recover/1","source_operation":"source-1","submission":{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit index f389c2de8..733f8be8a 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/submit @@ -1 +1 @@ -{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0"} \ No newline at end of file +{"schema":"auths.gateway-submit/2","proof_b64":"AA","action_b64":"AA","approval_b64":"eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 7dbee0c50..67c5a568b 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"fee59c6c8d7eb3bae2174da4ef806d6d8e18bb6d4db87c27ee703dbbc899785e"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"b478b0db6c2ec09d2bf71b3e294a0906be53bed71fca94a06c197a99e313af1e"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"6e36cda52dadb65bea0e7aac4c8f2a88fd27bb1532d55f0f242d67e03cf42c3a"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"560da89667bd5c7cb78c0d446ce2e38f486e9a54921fa57558197374b5ef3746"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"f941d26f4a29feea4f3d19f6d51cf46e4d9e09509fd59d925c93273550b8539b"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"285ba22c775aa7421df165f376c1d1f0143c25b2f5567c0e140a521c1a5106af"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"bd48b683b79c2800a02ae86170265ecdd655a499b8fdc1393863ea809fc8264a"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"5e8cb6872949278ccd965619ab2d8b49bc9f8496e736cb282846247a7c2cdad1"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"1616b744daf3055fd628829348c9a93de7dacb2c76ec634003dc541b9adfd29b"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"1bc504efd2ea5535d32c6ecf07e47cd7e9669508d2fa819250985604da85f937"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"7847fff1d88c8b1c5c09ecb6a21d4a6f74fc17899f249b1cd3747229313e4948"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"4fb6bc86f8f4e956b95b1ba5575721e8fad6a30bf4dc6ad9c740c7c54385bc21"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"ca1d7950bc766de53b021bc25613fd7ae428898198e34e654f5ed04ee549468a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"0e8497dacefe7943f6da0e8a1f41ec141c04c77c9ac9a61ef37b130c4f2c1450"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"2e975f364e6c63408bb16ad4a975f4020ad07129a29846cf32662b630723eb60"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"13db3dbf6daadb40edc984ae1262235d8991813184c3b65c46777cf44fdcfc31"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"346b0e579489009ff899a168b3468201c2b43194f3a9aef70095e24ee30d1a47"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs b/product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs new file mode 100644 index 000000000..7b05c8029 --- /dev/null +++ b/product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs @@ -0,0 +1,241 @@ +//! Independent real-signed binding substitutions. Compilation and exact approval +//! are exercised through the native owner; this fixture cannot grant transport. +use super::*; +use crate::effect::{BoundEffect, ExactEffectApproval}; +use std::num::NonZeroU64; + +#[derive(Clone, Copy)] +enum Alteration { + None, + Header, + Destination, + Namespace, + Configuration, +} + +#[derive(Clone)] +struct Inputs { + actor: u8, + approver: u8, + account: &'static str, + generation: u64, + partition: &'static str, + epoch: u64, + operation: &'static str, + resource: &'static str, + replacement: &'static str, + alteration: Alteration, +} +impl Inputs { + fn original() -> Self { + Self { + actor: 0x22, + approver: 29, + account: "acct_TESTACCOUNT01", + generation: 1, + partition: "binding-boundary", + epoch: 1, + operation: "binding-1", + resource: "recTEST0000000001", + replacement: "Approved", + alteration: Alteration::None, + } + } +} + +fn compile(input: &Inputs) -> Result { + let mut source: Value = serde_json::from_slice(include_bytes!( + "../../../../bindings/fixtures/gateway/airtable/recipe.json" + )) + .expect("source"); + if matches!(input.alteration, Alteration::Header) { + source["provider_headers"] = json!({"X-GitHub-Api-Version":"2026-01-01"}); + } + if matches!(input.alteration, Alteration::Destination) { + source["origin"] = json!("https://different.example"); + } + let recipe = CompiledRecipe::compile( + &serde_json::to_vec(&source).expect("source"), + include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), + ) + .expect("recipe"); + let call=McpToolCall::new(recipe.review().service(),recipe.review().tool(),json!({ + "operation_id":input.operation,"operator_namespace":if matches!(input.alteration, Alteration::Namespace) {"foreign-namespace"} else {recipe.namespace().as_str()}, + "recipe_digest":recipe.digest_hex(),"record_id":input.resource,"replacement":input.replacement + }).as_object().expect("arguments").clone()).expect("native call"); + let root = signer(h::ROOT_SEED); + let actor = signer(input.actor); + let observer = signer(h::OBSERVER_SEED); + let mut context = h::context_for_tool(&root, &observer.principal, NOW, &call).expect("trust"); + if matches!(input.alteration, Alteration::Configuration) { + context = context + .with_configuration(auths_model::VerifierConfigurationId::new([0x99; 32])) + .expect("explicit required configuration"); + } + let grant = h::grant_for_tool( + &root, + &actor.principal, + None, + window(NOW - 10, NOW + 3600), + &call, + ) + .expect("grant"); + let signed = submission_for_call_during( + &root, + &actor, + &grant, + &call, + &[], + window(NOW - 5, NOW + 300), + ); + let initial = connection_account(&recipe, crate::submit::account_commitment(input.account)); + let connection = ConnectionRecord::new( + initial.provider_kind().clone(), + initial.alias().clone(), + initial.connection_id().clone(), + initial.contract().clone(), + initial.descriptor_schema().clone(), + initial.descriptor().to_vec(), + *initial.account_commitment(), + *initial.credential_reference_commitment(), + NonZeroU64::new(input.generation).expect("nonzero generation"), + initial.state(), + initial.allowed_workloads().to_vec(), + initial.allowed_profiles().to_vec(), + initial.created_at_unix_seconds(), + initial.updated_at_unix_seconds(), + None, + ) + .expect("installed record"); + let public = SigningKey::from_bytes(&[input.approver; 32]) + .verifying_key() + .to_bytes(); + let policy = EffectPolicy::new(input.partition.to_owned(), input.epoch, public) + .expect("installed policy"); + compile_mutation_effect( + &policy.installation( + &recipe, + &context, + &connection, + crate::QualificationPolicy::Optional, + [12; 32], + ), + NOW, + &signed.proof, + &signed.action, + ) +} + +fn approval(effect: &BoundEffect, approver: u8) -> ExactEffectApproval { + let request = effect + .approval_request(NOW, NOW + 300) + .expect("native approval request"); + let signature = SigningKey::from_bytes(&[approver; 32]) + .sign(&request.signing_message().expect("preimage")) + .to_bytes(); + request.with_signature(signature) +} + +#[test] +fn native_independent_binding_substitutions_require_new_approval() { + let original = Inputs::original(); + let baseline = compile(&original).expect("baseline"); + let baseline_id = *baseline.binding().id().as_bytes(); + let old_approval = approval(&baseline, 29); + let mut cases = Vec::new(); + let mut failures = Vec::new(); + for name in [ + "actor", + "account", + "credential-generation", + "partition", + "epoch", + "operation", + "resource", + "body", + "header", + "destination", + "approver", + "namespace", + "verifier-configuration", + ] { + match std::panic::catch_unwind(|| binding_case(name, &original, baseline_id, &old_approval)) + { + Ok(value) => cases.push(value), + Err(_) => failures.push(name), + } + } + baseline + .approve( + old_approval, + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + NOW, + ) + .expect("original control"); + assert!( + failures.is_empty(), + "independent binding failures: {failures:?}" + ); + let bytes=serde_json::to_vec_pretty(&json!({"schema":"auths.native-independent-bindings/1", + "scope":"ordinary native signed proof, compiled effect and exact approval; explicit synthetic trust/connection/clock", + "excluded":["durable entry","provider execution","human presence"],"cases":cases})).expect("artifact"); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../bindings/fixtures/gateway/native-independent-bindings.json"); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("artifact"); + } + assert_eq!(std::fs::read(path).expect("artifact"), bytes); +} + +fn binding_case( + name: &str, + original: &Inputs, + baseline_id: [u8; 32], + old_approval: &ExactEffectApproval, +) -> Value { + let mut changed = original.clone(); + match name { + "actor" => changed.actor = 0x23, + "account" => changed.account = "acct_TESTACCOUNT02", + "credential-generation" => changed.generation = 2, + "partition" => changed.partition = "other-partition", + "epoch" => changed.epoch = 2, + "operation" => changed.operation = "binding-2", + "resource" => changed.resource = "recTEST0000000002", + "body" => changed.replacement = "Pending", + "header" => changed.alteration = Alteration::Header, + "destination" => changed.alteration = Alteration::Destination, + "approver" => changed.approver = 30, + "namespace" => changed.alteration = Alteration::Namespace, + "verifier-configuration" => changed.alteration = Alteration::Configuration, + _ => unreachable!("closed source corpus"), + } + let result = compile(&changed); + if matches!( + changed.alteration, + Alteration::Namespace | Alteration::Configuration + ) { + assert!( + result.is_err(), + "{name} must refuse before approval/admission" + ); + return json!({"case":name,"native_compilation_refused":true}); + } + let effect = result.expect("independently authorized changed action"); + let id = *effect.binding().id().as_bytes(); + assert_ne!(id, baseline_id, "{name}"); + let fresh = approval(&effect, changed.approver); + let public = SigningKey::from_bytes(&[changed.approver; 32]) + .verifying_key() + .to_bytes(); + assert!( + effect.approve(old_approval.clone(), &public, NOW).is_err(), + "{name}" + ); + compile(&changed) + .expect("fresh native control") + .approve(fresh, &public, NOW) + .expect("fresh exact approval"); + json!({"case":name,"baseline_effect":hex::encode(baseline_id),"changed_effect":hex::encode(id), + "old_exact_approval_refused":true,"fresh_native_authority_and_approval_accepted":true}) +} diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 025eda989..8414ecc9e 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -28,6 +28,8 @@ mod prerequisite_tests; #[path = "effect_read_budget_tests.rs"] mod read_budget_tests; +#[path = "effect_binding_boundary_tests.rs"] +mod binding_boundary_tests; #[path = "effect_recovery_prerequisite_tests.rs"] mod recovery_prerequisite_tests; #[path = "effect_review_approval_tests.rs"] diff --git a/product/runtime/auths-gateway/src/lib.rs b/product/runtime/auths-gateway/src/lib.rs index 40e6d15d3..c15718164 100644 --- a/product/runtime/auths-gateway/src/lib.rs +++ b/product/runtime/auths-gateway/src/lib.rs @@ -183,6 +183,9 @@ mod native_postgres_commit_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_information_replay_tests; + +#[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] +mod native_journal_tests; #[cfg(all(test, unix, feature = "loopback-provider", feature = "testkit-harness"))] mod native_mutation_replay_tests; diff --git a/product/runtime/auths-gateway/src/native_crash_tests.rs b/product/runtime/auths-gateway/src/native_crash_tests.rs index 856eb0034..59a2ff466 100644 --- a/product/runtime/auths-gateway/src/native_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_crash_tests.rs @@ -140,7 +140,7 @@ impl CrashProtocol { } pub(super) struct PausedStore { - operation: &'static str, + operation: Option<&'static str>, protocol: CrashProtocol, inner: Arc, key: GatewayAttemptKey, @@ -160,19 +160,34 @@ impl PausedStore { Self { inner, key, - operation, + operation: Some(operation), protocol, point, port, fired: AtomicBool::new(false), } } + pub(super) fn selected( + inner: Arc, + key: GatewayAttemptKey, + protocol: CrashProtocol, + point: Point, + port: u16, + ) -> Self { + let mut store = Self::new(inner, key, "", protocol, Some(point), port); + store.operation = None; + store + } fn target(&self, kind: GatewayRecordKind, key: GatewayAttemptKey) -> bool { kind == GatewayRecordKind::Attempt && key == self.key } fn phase(&self, bytes: &[u8]) -> String { - Self::phase_for(self.protocol, self.operation, bytes) + let value: Value = serde_json::from_slice(bytes).expect("native record"); + let operation = self + .operation + .unwrap_or_else(|| value["operation_id"].as_str().expect("native operation")); + Self::phase_for(self.protocol, operation, bytes) } pub(super) fn phase_for(protocol: CrashProtocol, operation: &str, bytes: &[u8]) -> String { let value: Value = serde_json::from_slice(bytes).expect("native record"); diff --git a/product/runtime/auths-gateway/src/native_dependency_tests.rs b/product/runtime/auths-gateway/src/native_dependency_tests.rs index 339da4184..4cf55f9b3 100644 --- a/product/runtime/auths-gateway/src/native_dependency_tests.rs +++ b/product/runtime/auths-gateway/src/native_dependency_tests.rs @@ -35,6 +35,7 @@ const OPERATION: &str = "dependency-read"; pub(super) enum Scenario { Revoke, Configuration, + Epoch, ApprovalValid, ApprovalExpired, AuthorityValid, @@ -287,6 +288,7 @@ fn run_worker(race: &Race, store: &TestAttempts) { clock, recipe: None, trust: None, + credential: None, }; let runtime = runtime(); let (engine, _) = runtime.block_on(load_controlled_engine( @@ -326,12 +328,24 @@ fn run_operator(race: &Race, store: &TestAttempts) { // publication, not the opening/recovery of a new host's store handle. let runtime = runtime(); let mut controls = EngineControls::baseline(); - if matches!(race.scenario, Scenario::Configuration) { + if matches!(race.scenario, Scenario::Configuration | Scenario::Epoch) { use ed25519_dalek::SigningKey; controls.policy = crate::effect::EffectPolicy::new( "test-partition".to_owned(), - 1, - SigningKey::from_bytes(&[30; 32]).verifying_key().to_bytes(), + if matches!(race.scenario, Scenario::Epoch) { + 2 + } else { + 1 + }, + SigningKey::from_bytes( + &[if matches!(race.scenario, Scenario::Epoch) { + 29 + } else { + 30 + }; 32], + ) + .verifying_key() + .to_bytes(), ) .expect("new operator policy"); } @@ -375,7 +389,7 @@ fn run_operator(race: &Race, store: &TestAttempts) { auths_connections::ConnectionState::Revoked ); } - Scenario::Configuration => { + Scenario::Configuration | Scenario::Epoch => { engine .activate_effect_configuration(reviewed) .expect("native activation"); @@ -746,6 +760,8 @@ fn dependency_matrix(backend: Backend) { (Scenario::Revoke, Order::GrantFirst), (Scenario::Configuration, Order::ChangeFirst), (Scenario::Configuration, Order::GrantFirst), + (Scenario::Epoch, Order::ChangeFirst), + (Scenario::Epoch, Order::GrantFirst), (Scenario::ApprovalValid, Order::LockWait), (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), diff --git a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs index a95757d4b..7c7264b1a 100644 --- a/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs @@ -44,6 +44,7 @@ impl Race { Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, Scenario::Revoke | Scenario::Configuration + | Scenario::Epoch | Scenario::ObserverValid | Scenario::ObserverExpired | Scenario::ThresholdValid @@ -254,7 +255,7 @@ fn worker(race: &Race, store: &TestAttempts) { fn operator(race: &Race, store: &TestAttempts) { let runtime = runtime(); - let candidate_controls = controls( + let mut candidate_controls = controls( Arc::new(FixedClock::at(NOW)), if matches!(race.scenario, Scenario::Configuration) { 30 @@ -262,6 +263,14 @@ fn operator(race: &Race, store: &TestAttempts) { 29 }, ); + if matches!(race.scenario, Scenario::Epoch) { + candidate_controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 2, + SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + ) + .expect("next epoch shares the partition fence"); + } let attempts = GatewayAttempts::new(store.raw(), candidate_controls.policy.clone()) .expect("candidate policy"); let (engine, record) = runtime.block_on(load_controlled_engine( @@ -307,7 +316,7 @@ fn operator(race: &Race, store: &TestAttempts) { .block_on(shared.replace(¤t, &revoked)) .expect("operator CAS"); } - Scenario::Configuration => { + Scenario::Configuration | Scenario::Epoch => { engine .activate_effect_configuration(reviewed) .expect("operator activation"); @@ -652,6 +661,8 @@ fn matrix(backend: Backend) { (Scenario::Revoke, Order::GrantFirst), (Scenario::Configuration, Order::ChangeFirst), (Scenario::Configuration, Order::GrantFirst), + (Scenario::Epoch, Order::ChangeFirst), + (Scenario::Epoch, Order::GrantFirst), (Scenario::ApprovalValid, Order::LockWait), (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), diff --git a/product/runtime/auths-gateway/src/native_epoch_tests.rs b/product/runtime/auths-gateway/src/native_epoch_tests.rs index d20378267..0b83ec2dd 100644 --- a/product/runtime/auths-gateway/src/native_epoch_tests.rs +++ b/product/runtime/auths-gateway/src/native_epoch_tests.rs @@ -236,6 +236,7 @@ fn retained_history( fn matrix(backend: Backend) { let artifact = serde_json::to_vec_pretty(&json!({"schema":"auths.native-epoch-fence/1", "adapter":backend.label(), "case":one_case(backend), + "independent_generation_floor":generation_floor_case(backend), "scope":"actual native proofs and exact approvals, shared activation fence, real HTTP and two engine/store instances; public fixture keys and maintained clock", "excluded":["malicious store rollback without an independent anchor", "all protocol race schedules", "hostile OS and live-provider qualification"]})).expect("artifact"); let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( @@ -248,6 +249,113 @@ fn matrix(backend: Backend) { assert_eq!(std::fs::read(path).expect("fixture"), artifact); } +fn generation_floor_case(backend: Backend) -> Value { + use crate::native_process_tests::load_controlled_engine_at_generation; + use std::num::NonZeroU64; + let fixture = Fixture::new(backend); + let template = crate::harness::fixture_connection(&recipe()).expect("template"); + let shared = SharedConnection::new( + fixture.store.raw(), + template.provider_kind().clone(), + template.alias().clone(), + ); + let current = fixture + .runtime + .block_on(shared.load()) + .expect("load") + .expect("connection"); + let floor = crate::GenerationFloor::new(fixture.setup.root.clone()); + floor + .initialize(current.record()) + .expect("independent initial floor"); + let key = crate::connection::connection_key(template.provider_kind(), template.alias()); + let old = fixture + .store + .raw() + .load(GatewayRecordKind::Connection, &key) + .expect("load") + .expect("connection"); + let (next, record) = fixture + .runtime + .block_on(load_controlled_engine_at_generation( + &fixture.setup, + "generation-two", + fixture.store.attempts().clone(), + controls(fixture.clock.clone(), 29), + NonZeroU64::new(2).expect("generation"), + )); + let next = next.with_generation_floor(floor.clone()); + fixture + .runtime + .block_on(shared.replace(¤t, &record)) + .expect("generation-two install"); + let signed = fixture.runtime.block_on(input(&next, "floor-positive")); + let accepted = fixture + .runtime + .block_on(acquire(&next, &signed)) + .expect("current floor positive"); + assert_eq!(accepted.stage, crate::AcquisitionStage::ResponseRecorded); + let raw = fixture.store.raw(); + let newer = raw + .load(GatewayRecordKind::Connection, &key) + .expect("load") + .expect("new connection"); + let floor_path = fixture.setup.root.join("connection-floor.json"); + let retained_floor = std::fs::read(&floor_path).expect("accepted independent floor"); + let records = fixture.records(); + let witness = next.execution_witness(); + // Restore only the database connection. The separately retained floor is + // deliberately not restored; this is the supported backup premise. + raw.replace(GatewayRecordKind::Connection, &key, &newer, &old) + .expect("isolated connection rollback"); + let mut checks = Vec::new(); + for name in [ + "older-connection", + "same-generation-substitution", + "missing-floor", + "malformed-floor", + "obsolete-floor", + ] { + if name == "same-generation-substitution" { + raw.replace(GatewayRecordKind::Connection, &key, &old, &newer) + .expect("restore current generation"); + } + change_floor(name, &floor_path, &retained_floor); + assert!( + fixture + .runtime + .block_on(next.compile_content_action(&signed.proof, &signed.action)) + .is_err(), + "{name}" + ); + assert_eq!(next.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + assert_eq!(fixture.records(), records); + checks.push( + json!({"case":name,"refused_before_custody_and_entry":true,"attempts_unchanged":true}), + ); + // Only the test operator restores the independent anchor. Runtime may + // never bootstrap a missing floor from a restored database record. + if name == "missing-floor" { + assert!(!floor_path.exists()); + } + std::fs::write(&floor_path, &retained_floor).expect("operator restores exact anchor"); + std::fs::set_permissions(&floor_path, std::fs::Permissions::from_mode(0o600)) + .expect("private floor"); + } + assert_eq!( + fixture + .runtime + .block_on(acquire(&next, &signed)) + .expect("retained exact replay"), + accepted + ); + assert_eq!(next.execution_witness(), witness); + json!({"current_generation":2,"current_positive_provider_reads":1,"cases":checks, + "premise":"host-local independent floor survives database backup/restore", + "excluded":"rollback of both the complete store and every independent floor"}) +} + #[test] fn native_file_epoch_fence_fixture_is_current() { matrix(Backend::File); @@ -259,3 +367,22 @@ fn postgres_native_epoch_fence_fixture_is_current() { assert!(postgres_configured()); matrix(Backend::Postgres); } + +fn change_floor(name: &str, path: &Path, retained: &[u8]) { + match name { + "same-generation-substitution" | "obsolete-floor" => { + let mut value: Value = serde_json::from_slice(retained).expect("floor"); + if name == "same-generation-substitution" { + value["record_sha256"] = json!("00".repeat(32)); + } else { + value["schema"] = json!("auths.gateway-generation-floor/0"); + } + std::fs::write(path, serde_json::to_vec(&value).expect("floor")) + .expect("changed floor"); + } + "missing-floor" => std::fs::remove_file(path).expect("remove floor"), + "malformed-floor" => std::fs::write(path, b"{").expect("malformed"), + "older-connection" => {} + _ => unreachable!("closed floor corpus"), + } +} diff --git a/product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs b/product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs new file mode 100644 index 000000000..15240d83e --- /dev/null +++ b/product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs @@ -0,0 +1,260 @@ +//! Full maintained Stripe guards and independently journaled prerequisite reads. +//! All pauses wrap the real adapters or actual HTTP responses; no decision is +//! replaced. Fixed public keys, synthetic credential and clock are explicit. +use super::*; +use std::collections::BTreeMap; +use std::net::TcpStream; + +pub(super) fn serve_read(stream: &mut TcpStream, line: &str, header: &str, pause: Option) { + assert!( + header + .to_ascii_lowercase() + .contains("stripe-version: 2025-03-31.basil\r\n") + ); + let (status, body) = match line { + "GET /v1/account HTTP/1.1" => (200, json!({"id":"acct_TESTHARNESS01"})), + "GET /v1/customers HTTP/1.1" | "GET /v1/payouts HTTP/1.1" => (403, json!({})), + "GET /v1/payment_intents/pi_public_crash_fixture HTTP/1.1" => { + assert!( + header + .to_ascii_lowercase() + .contains("stripe-account: acct_testharness01\r\n") + ); + (200, json!({"amount_received":2000,"currency":"usd"})) + } + _ => panic!("undeclared prerequisite request: {line}"), + }; + let body = serde_json::to_vec(&body).expect("response"); + stream.write_all(format!("HTTP/1.1 {status} Fixture\r\nContent-Type: application/json\r\nStripe-Version: 2025-03-31.basil\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",body.len()).as_bytes()).expect("response header"); + if let Some(port) = pause { + stream.write_all(&body[..1]).expect("response prefix"); + pause_at(port); + let _ = stream.write_all(&body[1..]); + } else { + stream.write_all(&body).expect("response body"); + } +} + +fn children(case: &Case) -> BTreeMap> { + let raw = case.store.raw(); + raw.attempt_keys(16) + .expect("bounded inventory") + .into_iter() + .filter(|candidate| *candidate != key(Flavor::StripeGuarded)) + .map(|key| { + ( + hex::encode(key.as_bytes()), + raw.load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("retained child"), + ) + }) + .collect() +} + +fn parent_case(backend: Backend, point: Point, gate: ResumeGate) -> Value { + let case = Case::new(backend, Flavor::StripeGuarded, point, gate); + assert_eq!(case.authorization.prerequisites, vec![0, 1, 2, 3]); + assert_eq!(case.provider.read_calls(), 0); + case.crash(); + let before = children(&case); + let reads_at_kill = case.provider.read_calls(); + let early = matches!( + point, + Point::BeforeReservationCommit | Point::AfterReservationCommit + ); + assert_eq!(reads_at_kill, if early { 0 } else { 4 }); + assert_eq!(before.len(), reads_at_kill); + let mut result = case.reopen(); + let after = children(&case); + assert_eq!( + after.len(), + if case.may_continue() { 4 } else { before.len() } + ); + for (key, bytes) in &before { + assert_eq!(after.get(key), Some(bytes)); + } + assert_eq!( + case.provider.read_calls(), + if case.may_continue() { + 4 + } else { + reads_at_kill + } + ); + result["prerequisite_reads_at_kill"] = json!(reads_at_kill); + result["prerequisite_reads_after_replay"] = json!(case.provider.read_calls()); + result["retained_prerequisite_records"] = json!(after.len()); + result["prerequisite_evidence_not_refetched_or_retimestamped"] = json!(true); + result +} + +fn unchanged_children( + case: &Case, + index: u8, + point: Point, + before: &BTreeMap>, + after: &BTreeMap>, +) { + for (position, plan) in case.authorization.prerequisites.iter().enumerate() { + let key = hex::encode( + crate::store::fixture_prerequisite_key(key(Flavor::StripeGuarded), *plan).as_bytes(), + ); + if position < usize::from(index) + || matches!(point, Point::AfterResponseCommit) && position == usize::from(index) + { + assert_eq!( + after.get(&key), + before.get(&key), + "retained complete evidence is immutable" + ); + } + } +} + +fn child_case(backend: Backend, index: u8, point: Point) -> Value { + let mut case = Case::new(backend, Flavor::StripeGuarded, point, ResumeGate::Current); + case.setup.prerequisite = Some(index); + assert_eq!(case.authorization.prerequisites, vec![0, 1, 2, 3]); + if matches!(point, Point::DuringResponse) { + *case.provider.pause.lock().expect("pause") = Some(ProviderPause::Read { + index: usize::from(index), + port: case.setup.installation.barrier_port, + }); + } + case.crash(); + let before = children(&case); + let slots = case.slots(true); + let parent_before = case.raw().expect("parent reservation"); + assert_eq!( + PausedStore::phase_for(CrashProtocol::Mutation, OPERATION, &parent_before), + "reserved" + ); + let child_key = crate::store::fixture_prerequisite_key(key(Flavor::StripeGuarded), index); + let selected = case + .store + .raw() + .load(GatewayRecordKind::Attempt, &child_key) + .expect("child"); + let expected_stage = match point { + Point::BeforeReservationCommit => None, + Point::AfterReservationCommit | Point::BeforeEntryCommit => Some("reserved"), + Point::AfterResponseCommit => Some("response-recorded"), + _ => Some("entry-granted"), + }; + assert_eq!( + selected + .as_ref() + .map(|bytes| { + let value: Value = serde_json::from_slice(bytes).expect("child"); + value["state"]["facts"]["phase"]["stage"] + .as_str() + .expect("phase") + .to_owned() + }) + .as_deref(), + expected_stage + ); + let read_entered = matches!( + point, + Point::DuringResponse | Point::BeforeResponseCommit | Point::AfterResponseCommit + ); + let reads_at_kill = usize::from(index) + usize::from(read_entered); + assert_eq!(case.provider.read_calls(), reads_at_kill); + let resumable = point.resumable() || matches!(point, Point::AfterResponseCommit); + let engine = case.reopened_engine(); + let result = case + .runtime + .block_on(submit(&engine, &case.setup.installation.root)); + if resumable { + assert_eq!( + result, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + } else { + assert!( + matches!(result, GatewaySubmitResult::Reserved { .. }), + "unresolved child preserves the parent reservation" + ); + } + assert_eq!(case.provider.calls(), usize::from(resumable)); + assert_eq!( + case.provider.read_calls(), + if resumable { 4 } else { reads_at_kill } + ); + assert_eq!(case.slots(true), slots); + let after = children(&case); + unchanged_children(&case, index, point, &before, &after); + let record = case.raw().expect("retained parent"); + let witness = engine.execution_witness(); + assert_eq!( + case.runtime + .block_on(submit(&engine, &case.setup.installation.root)), + result + ); + let replay_witness = engine.execution_witness(); + assert_eq!( + replay_witness.read_transport_entries, + witness.read_transport_entries + ); + assert_eq!( + replay_witness.write_transport_entries, + witness.write_transport_entries + ); + if resumable { + assert_eq!(replay_witness, witness); + } + assert_eq!(case.raw().expect("parent"), record); + assert_eq!(children(&case), after); + assert_eq!(case.slots(true), slots); + json!({"prerequisite_index":index,"pause":point,"sigkill":true,"child_stage_at_kill":expected_stage, + "provider_reads_at_kill":reads_at_kill,"provider_reads_after_replays":case.provider.read_calls(), + "provider_writes_after_replays":case.provider.calls(),"native_result":result, + "parent_charges_preserved":true,"completed_child_evidence_immutable":true,"replay_creates_no_transport_entry":true,"unresolved_child_preserves_parent_reservation":!resumable}) +} + +fn matrix(backend: Backend) { + let mut parents = Vec::new(); + for point in Point::ALL { + parents.push(parent_case(backend, point, ResumeGate::Current)); + } + for point in [Point::AfterReservationCommit, Point::BeforeEntryCommit] { + for gate in [ + ResumeGate::ApprovalExpired, + ResumeGate::AuthorityExpired, + ResumeGate::Revoked, + ResumeGate::ConfigurationReplaced, + ] { + parents.push(parent_case(backend, point, gate)); + } + } + let mut prerequisites = Vec::new(); + for index in 0..4 { + for point in Point::ALL { + prerequisites.push(child_case(backend, index, point)); + } + } + let bytes=serde_json::to_vec_pretty(&json!({"schema":"auths.native-guarded-mutation-crash/1","adapter":backend.label(), + "scope":"maintained full Stripe recipe, real HTTP credential/relative reads and mutation, OS SIGKILL, native proof/approval and durable adapters; synthetic credential/key/clock", + "parent_cases":parents,"prerequisite_cases":prerequisites, + "excluded":["live provider qualification","power loss","hostile OS","human presence"]})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-guarded-mutation-crash-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("artifact"); + } + assert_eq!(std::fs::read(path).expect("artifact"), bytes); +} + +#[test] +fn native_file_guarded_mutation_crash_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires maintained TLS PostgreSQL fixture"] +fn postgres_native_guarded_mutation_crash_fixture_is_current() { + assert!(postgres_configured(), "TLS PostgreSQL fixture is required"); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_information_journal_tests.rs b/product/runtime/auths-gateway/src/native_information_journal_tests.rs new file mode 100644 index 000000000..9993e8d85 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_information_journal_tests.rs @@ -0,0 +1,119 @@ +//! Malformed persisted read/disclosure facts never become current capabilities. +use super::*; + +fn one(backend: Backend, protocol: Protocol) -> Value { + let fixture = Fixture::new(backend); + let input = fixture + .runtime + .block_on(Input::content(&fixture.engine, Change::None)); + let acquired = fixture + .runtime + .block_on(fixture.engine.acquire_content_action( + &input.proof, + &input.action, + input.approval.clone(), + )) + .expect("native read"); + let history = prepare_release(&fixture, protocol, Change::None); + let operation = LogicalOperationId::parse(if history.is_some() { RELEASE } else { SOURCE }) + .expect("operation"); + let key = crate::GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &operation, + ) + .expect("key"); + let raw = fixture.store.raw(); + let original = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"); + let reopened = fixture.change_and_reopen(Change::None); + let witness = reopened.execution_witness(); + let cases = crate::native_journal_tests::exercise( + &*raw, + key, + &original, + || { + fixture.runtime.block_on(async { + if let Some(history) = &history { + let (server, mut client) = UnixStream::pair().expect("channel"); + assert!( + reopened + .disclose( + &history.target, + &history.input.proof, + &history.input.action, + history.input.approval.clone(), + crate::disclosure_transport::DisclosureConnection::new( + server, + history.policy.clone() + ) + ) + .await + .is_err() + ); + let mut byte = [0]; + assert_eq!(client.read(&mut byte).await.expect("closed channel"), 0); + } else { + assert!( + reopened + .acquire_content_action( + &input.proof, + &input.action, + input.approval.clone() + ) + .await + .is_err() + ); + } + assert!(reopened.content_history(operation.as_str()).await.is_err()); + }); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + }, + || { + fixture.runtime.block_on(async { + if let Some(history) = &history { + replay_release(&reopened, history).await; + } else { + replay_content(&reopened, &input, &acquired).await; + } + }); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + }, + ); + json!({"protocol":protocol.label(),"cases":cases,"real_provider_reads":1, + "exact_retained_charges_preserved":true,"disclosure_replay_sends_zero_bytes":true}) +} + +fn matrix(backend: Backend) { + let cases = [ + Protocol::Acquisition, + Protocol::Acknowledged, + Protocol::LostAcknowledgement, + ] + .map(|protocol| one(backend, protocol)); + let bytes=serde_json::to_vec_pretty(&json!({"schema":"auths.native-information-journal/1","adapter":backend.label(), + "scope":"native signed acquisition/disclosure, real HTTP and authenticated Unix delivery, reopened engine and adapter; isolated privileged record corruption", + "excluded":["hostile store rewriting every correlated record","whole-store rollback without independent anchor","power loss"],"cases":cases})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-information-journal-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("artifact"); + } + assert_eq!(std::fs::read(path).expect("artifact"), bytes); +} +#[test] +fn native_file_information_journal_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires maintained TLS PostgreSQL fixture"] +fn postgres_native_information_journal_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_information_replay_tests.rs b/product/runtime/auths-gateway/src/native_information_replay_tests.rs index 5543f576b..395737bee 100644 --- a/product/runtime/auths-gateway/src/native_information_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_replay_tests.rs @@ -487,3 +487,6 @@ fn postgres_native_information_retained_replay_fixture_is_current() { assert!(postgres_configured()); matrix(Backend::Postgres); } + +#[path = "native_information_journal_tests.rs"] +mod journal_tests; diff --git a/product/runtime/auths-gateway/src/native_journal_tests.rs b/product/runtime/auths-gateway/src/native_journal_tests.rs new file mode 100644 index 000000000..c523ec13d --- /dev/null +++ b/product/runtime/auths-gateway/src/native_journal_tests.rs @@ -0,0 +1,126 @@ +//! Shared hostile journal corpus. Every alteration preserves the native writer's +//! encoding except the explicitly named encoding negatives, avoiding one broken +//! canonicalization check masking independent binding/evidence checks. +use crate::{GatewayAttemptKey, GatewayAttemptStore, GatewayRecordKind}; +use serde_json::{Value, json}; + +fn member(bytes: &[u8], name: &str, replacement: &Value) -> Vec { + let text = std::str::from_utf8(bytes).expect("native JSON"); + let needle = format!("\"{name}\":"); + let start = text.find(&needle).expect("native member") + needle.len(); + let mut stream = serde_json::Deserializer::from_slice(&bytes[start..]).into_iter::(); + stream.next().expect("value").expect("native value"); + let end = start + stream.byte_offset(); + let mut changed = bytes[..start].to_vec(); + changed.extend(serde_json::to_vec(replacement).expect("replacement")); + changed.extend_from_slice(&bytes[end..]); + changed +} + +pub(super) fn exercise( + store: &dyn GatewayAttemptStore, + key: GatewayAttemptKey, + original: &[u8], + mut refuse: impl FnMut(), + mut positive: impl FnMut(), +) -> Vec { + positive(); + let source: Value = serde_json::from_slice(original).expect("native record"); + let mut variants = vec![ + ( + "obsolete-schema", + member(original, "schema", &json!("auths.obsolete-journal/0")), + ), + ("revision-zero", member(original, "revision", &json!(0))), + ( + "revision-unsafe-integer", + member(original, "revision", &json!(1_u64 << 53)), + ), + ( + "revision-boolean", + member(original, "revision", &json!(true)), + ), + ( + "revision-fractional", + member(original, "revision", &json!(1.5)), + ), + ( + "signed-time-unsafe-integer", + member(original, "evaluated_at", &json!(1_u64 << 53)), + ), + ( + "changed-operation", + member(original, "operation_id", &json!("unrelated-operation")), + ), + ( + "changed-binding", + member(original, "binding_canonical", &json!("{}")), + ), + ( + "changed-authority", + member(original, "authority_canonical_b64", &json!("e30=")), + ), + ( + "changed-approval", + member(original, "approval_canonical", &json!("{}")), + ), + ( + "missing-entry-evidence", + member(original, "entry", &Value::Null), + ), + ( + "inconsistent-protocol", + member(original, "state", &json!({"protocol":"obsolete"})), + ), + ("truncated", original[..original.len() - 1].to_vec()), + ( + "noncanonical-whitespace", + [b" ".as_slice(), original].concat(), + ), + ]; + variants.push(( + "duplicate-member", + [ + format!("{{\"revision\":{},", source["revision"]).as_bytes(), + &original[1..], + ] + .concat(), + )); + variants.push(( + "unknown-member", + [b"{\"obsolete_authority\":true,".as_slice(), &original[1..]].concat(), + )); + let mut cases = Vec::new(); + for (name, bytes) in variants { + store + .replace(GatewayRecordKind::Attempt, &key, original, &bytes) + .expect("isolated corruption injection"); + refuse(); + assert_eq!( + store.load(GatewayRecordKind::Attempt, &key).expect("load"), + Some(bytes.clone()), + "refusal cannot repair or re-sign {name}" + ); + store + .replace(GatewayRecordKind::Attempt, &key, &bytes, original) + .expect("restore exact owned record"); + positive(); + cases.push(json!({"case":name,"refused_without_custody_or_transport":true,"bytes_unchanged":true,"restored_exact_positive":true})); + } + let oversized = vec![b' '; auths_stores::MAX_GATEWAY_RECORD_BYTES + 1]; + assert!( + store + .replace(GatewayRecordKind::Attempt, &key, original, &oversized) + .is_err(), + "adapter enforces the journal byte bound" + ); + assert_eq!( + store.load(GatewayRecordKind::Attempt, &key).expect("load"), + Some(original.to_vec()) + ); + positive(); + cases.push( + json!({"case":"record-limit-plus-one","refused_at_adapter":true,"original_preserved":true}), + ); + cases +} diff --git a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs index a22dd94e0..85d77d46b 100644 --- a/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_crash_tests.rs @@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use std::{ io::{Read as _, Write as _}, - net::TcpListener, + net::{TcpListener, TcpStream}, os::unix::fs::PermissionsExt as _, path::{Path, PathBuf}, sync::{ @@ -34,6 +34,10 @@ const OPERATION: &str = "crash-write"; const RESPONSE: &[u8] = b"{\"id\":\"public-crash-response\"}"; const ENVIRONMENT: &str = "AUTHS_AP074_MUTATION_CRASH_PEER"; +#[path = "native_guarded_mutation_crash_tests.rs"] +mod guarded_tests; +#[path = "native_partial_upload_tests.rs"] +mod partial_upload_tests; #[path = "native_mutation_budget_tests.rs"] mod window_capacity_tests; @@ -42,12 +46,14 @@ mod window_capacity_tests; enum Flavor { Airtable, StripePlain, + StripeGuarded, } impl Flavor { const fn label(self) -> &'static str { match self { Self::Airtable => "airtable", Self::StripePlain => "stripe-plain", + Self::StripeGuarded => "stripe-guarded", } } fn recipe(self) -> CompiledRecipe { @@ -57,12 +63,16 @@ impl Flavor { include_bytes!("../../../../bindings/fixtures/gateway/airtable/profile.lock.json"), ) .expect("maintained Airtable recipe"), - Self::StripePlain => { + Self::StripePlain | Self::StripeGuarded => { let corpus: Value = serde_json::from_slice(include_bytes!( "../../../../bindings/fixtures/gateway/hostile-recipes-v2.json" )) .expect("maintained recipe corpus"); - let base = &corpus["bases"]["stripe-plain"]; + let base = &corpus["bases"][if matches!(self, Self::StripeGuarded) { + "stripe" + } else { + "stripe-plain" + }]; CompiledRecipe::compile( &serde_json::to_vec(&base["recipe"]).expect("source"), &serde_json::to_vec(&base["lock"]).expect("lock"), @@ -82,6 +92,9 @@ impl Flavor { let mut controls = EngineControls::baseline(); controls.trust = Some(tools_context(&[call], NOW).expect("native trust")); controls.recipe = Some(recipe); + if matches!(self, Self::StripeGuarded) { + controls.credential = Some(self.credential()); + } controls } fn call(self) -> McpToolCall { @@ -92,9 +105,13 @@ impl Flavor { arguments["record_id"] = json!("recTEST0000000001"); arguments["replacement"] = json!("Approved"); } - Self::StripePlain => { + Self::StripePlain | Self::StripeGuarded => { arguments["payment_intent"] = json!("pi_public_crash_fixture"); arguments["amount"] = json!(500); + if matches!(self, Self::StripeGuarded) { + arguments["currency"] = json!("usd"); + arguments["connect_account"] = json!("acct_TESTHARNESS01"); + } } } McpToolCall::new( @@ -105,19 +122,46 @@ impl Flavor { .expect("call") } fn policy(self) -> Option { - matches!(self, Self::StripePlain).then(|| { - ArgumentCeilingPolicy::new("amount", 500, 3600, 2) + self.is_stripe().then(|| { + let policy = ArgumentCeilingPolicy::new("amount", 500, 3600, 2) .expect("count policy") - .with_sum(1000, None) - .expect("sum policy") + .with_sum( + 1000, + if matches!(self, Self::StripeGuarded) { + Some(crate::ListedValues::new("currency", &["usd"]).expect("partition")) + } else { + None + }, + ) + .expect("sum policy"); + if matches!(self, Self::StripeGuarded) { + policy + .with_scope( + crate::ListedValues::new("connect_account", &["acct_TESTHARNESS01"]) + .expect("account scope"), + ) + .expect("scoped policy") + } else { + policy + } }) } + const fn is_stripe(self) -> bool { + !matches!(self, Self::Airtable) + } + const fn credential(self) -> &'static [u8] { + if matches!(self, Self::StripeGuarded) { + b"rk_test_public-native-process-fixture" + } else { + b"public-native-process-fixture" + } + } const fn request_line(self) -> &'static str { match self { Self::Airtable => { "PATCH /v0/appTEST0000000001/tblTEST0000000001/recTEST0000000001 HTTP/1.1" } - Self::StripePlain => "POST /v1/refunds HTTP/1.1", + Self::StripePlain | Self::StripeGuarded => "POST /v1/refunds HTTP/1.1", } } } @@ -151,6 +195,8 @@ struct CrashSetup { point: Point, flavor: Flavor, gate: ResumeGate, + #[serde(default)] + prerequisite: Option, } #[derive(Debug, Eq, PartialEq)] @@ -161,9 +207,16 @@ struct Request { struct Provider { port: u16, requests: Arc>>, + reads: Arc>>, + pause: Arc>>, stop: Arc, task: Option>, } +#[derive(Clone, Copy)] +enum ProviderPause { + Write(u16), + Read { index: usize, port: u16 }, +} impl Provider { fn new(flavor: Flavor, pause: Option) -> Self { let listener = TcpListener::bind("127.0.0.1:0").expect("provider"); @@ -171,10 +224,13 @@ impl Provider { let port = listener.local_addr().expect("address").port(); let requests = Arc::new(Mutex::new(Vec::new())); let captured = requests.clone(); + let reads = Arc::new(Mutex::new(Vec::new())); + let observed_reads = Arc::clone(&reads); + let pause = Arc::new(Mutex::new(pause.map(ProviderPause::Write))); + let response_pause = Arc::clone(&pause); let stop = Arc::new(AtomicBool::new(false)); let done = stop.clone(); let task = thread::spawn(move || { - let mut pause = pause; while !done.load(Ordering::SeqCst) { let (mut stream, _) = match listener.accept() { Ok(pair) => pair, @@ -199,54 +255,96 @@ impl Provider { header.push(byte[0]); } let header = String::from_utf8(header).expect("header UTF8"); + assert!(header.to_ascii_lowercase().contains(&format!( + "authorization: bearer {}\r\n", + std::str::from_utf8(flavor.credential()).expect("synthetic credential") + ))); + let line = header.lines().next().expect("request line"); + if matches!(flavor, Flavor::StripeGuarded) && line.starts_with("GET ") { + let index = observed_reads.lock().expect("reads").len(); + observed_reads.lock().expect("reads").push(line.to_owned()); + let pause = { + let mut armed = response_pause.lock().expect("response pause"); + match *armed { + Some(ProviderPause::Read { + index: selected, + port, + }) if selected == index => { + *armed = None; + Some(port) + } + _ => None, + } + }; + guarded_tests::serve_read(&mut stream, line, &header, pause); + continue; + } assert_eq!( - header.lines().next(), - Some(flavor.request_line()), - "no implicit reads" + line, + flavor.request_line(), + "only the exact closed mutation or declared prerequisite" ); - assert!( - header - .to_ascii_lowercase() - .contains("authorization: bearer public-native-process-fixture\r\n") - ); - let value = |name: &str| { - header.lines().find_map(|line| { - let (key, value) = line.split_once(':')?; - key.eq_ignore_ascii_case(name) - .then(|| value.trim().to_owned()) - }) - }; - let length: usize = value("content-length") - .expect("body length") - .parse() - .expect("length"); - assert!(length <= 65536); - let mut body = vec![0; length]; - stream.read_exact(&mut body).expect("body"); - captured.lock().expect("requests").push(Request { - body, - idempotency: value("idempotency-key"), - }); - stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",RESPONSE.len()).as_bytes()).expect("response header"); - if let Some(port) = pause.take() { - stream.write_all(&RESPONSE[..1]).expect("partial response"); - pause_at(port); - let _ = stream.write_all(&RESPONSE[1..]); - } else { - stream.write_all(RESPONSE).expect("response body"); - } + Self::serve_mutation(&mut stream, &header, &captured, &response_pause); } }); Self { port, requests, + reads, + pause, stop, task: Some(task), } } + fn serve_mutation( + stream: &mut TcpStream, + header: &str, + captured: &Mutex>, + response_pause: &Mutex>, + ) { + let value = |name: &str| { + header.lines().find_map(|line| { + let (key, value) = line.split_once(':')?; + key.eq_ignore_ascii_case(name) + .then(|| value.trim().to_owned()) + }) + }; + let length: usize = value("content-length") + .expect("body length") + .parse() + .expect("length"); + assert!(length <= 65536); + let mut body = vec![0; length]; + stream.read_exact(&mut body).expect("body"); + captured.lock().expect("requests").push(Request { + body, + idempotency: value("idempotency-key"), + }); + stream.write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nStripe-Version: 2025-03-31.basil\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",RESPONSE.len()).as_bytes()).expect("response header"); + let pause = { + let mut armed = response_pause.lock().expect("response pause"); + match *armed { + Some(ProviderPause::Write(port)) => { + *armed = None; + Some(port) + } + _ => None, + } + }; + if let Some(port) = pause { + stream.write_all(&RESPONSE[..1]).expect("partial response"); + pause_at(port); + let _ = stream.write_all(&RESPONSE[1..]); + } else { + stream.write_all(RESPONSE).expect("response body"); + } + } fn calls(&self) -> usize { self.requests.lock().expect("requests").len() } + fn read_calls(&self) -> usize { + self.reads.lock().expect("reads").len() + } } impl Drop for Provider { fn drop(&mut self) { @@ -290,14 +388,23 @@ fn native_mutation_crash_peer() { Backend::parse(&setup.installation.backend), &setup.installation.location, ); - let wrapped = Arc::new(PausedStore::new( - attached.raw(), - key(setup.flavor), - OPERATION, - CrashProtocol::Mutation, - Some(setup.point), - setup.installation.barrier_port, - )); + let wrapped = Arc::new(match setup.prerequisite { + Some(index) => PausedStore::selected( + attached.raw(), + crate::store::fixture_prerequisite_key(key(setup.flavor), index), + CrashProtocol::Acquisition, + setup.point, + setup.installation.barrier_port, + ), + None => PausedStore::new( + attached.raw(), + key(setup.flavor), + OPERATION, + CrashProtocol::Mutation, + Some(setup.point), + setup.installation.barrier_port, + ), + }); let attempts = GatewayAttempts::new(wrapped, crate::effect::fixture_policy().expect("policy")) .expect("attempts"); let runtime = runtime(); @@ -318,6 +425,7 @@ fn native_mutation_crash_peer() { struct Authorization { request: Request, counters: Vec, + prerequisites: Vec, } struct Counter { kind: GatewayRecordKind, @@ -373,35 +481,42 @@ async fn authorize(engine: &GatewayEngine, setup: &CrashSetup) -> Authorization } }) .collect::>(); - assert_eq!( - counters.len(), - if matches!(setup.flavor, Flavor::StripePlain) { - 2 - } else { - 0 - } - ); + assert_eq!(counters.len(), if setup.flavor.is_stripe() { 2 } else { 0 }); let approval = effect .approval_request(NOW, NOW + 300) .expect("exact review"); let signature = SigningKey::from_bytes(&[29; 32]) .sign(&approval.signing_message().expect("preimage")) .to_bytes(); + let approval = approval.with_signature(signature); + let approved = effect + .approve( + approval.clone(), + &SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + NOW, + ) + .expect("approved effect"); + let prerequisites = approved + .prerequisite_plans() + .expect("native prerequisite plans") + .iter() + .map(crate::effect::PrerequisitePlan::index) + .collect(); for (name, bytes) in [ ("write.proof", signed.proof), ("write.action", signed.action), ( "write.approval", - approval - .with_signature(signature) - .to_private_bytes() - .expect("approval") - .to_vec(), + approval.to_private_bytes().expect("approval").to_vec(), ), ] { private(&setup.installation.root.join(name), &bytes); } - Authorization { request, counters } + Authorization { + request, + counters, + prerequisites, + } } struct Case { @@ -430,6 +545,7 @@ impl Case { flavor, point, gate, + prerequisite: None, installation: Setup { backend: backend.label().to_owned(), location: store.location(), @@ -501,7 +617,14 @@ impl Case { .write_all(b"G") .expect("release provider after SIGKILL"); } - assert_eq!(self.provider.calls(), self.setup.point.provider_calls()); + assert_eq!( + self.provider.calls(), + if self.setup.prerequisite.is_some() { + 0 + } else { + self.setup.point.provider_calls() + } + ); } fn history(&self, attempts: &GatewayAttempts) -> Option { self.runtime @@ -560,6 +683,16 @@ impl Case { assert_eq!( self.store.raw().attempt_keys(8).expect("keys").len(), usize::from(bytes.is_some()) + + if matches!(self.setup.flavor, Flavor::StripeGuarded) + && !matches!( + self.setup.point, + Point::BeforeReservationCommit | Point::AfterReservationCommit + ) + { + 4 + } else { + 0 + } ); if let Some(snapshot) = self.history(&self.store.reopen()) { assert_eq!(snapshot.evaluated_at(), NOW); @@ -670,7 +803,13 @@ impl Case { ); assert_eq!( resumed.read_transport_entries - witness.read_transport_entries, - 0 + if matches!(self.setup.flavor, Flavor::StripeGuarded) + && !matches!(self.setup.point, Point::BeforeEntryCommit) + { + 4 + } else { + 0 + } ); } else { assert_eq!( @@ -710,8 +849,8 @@ impl Case { json!({"recipe":self.setup.flavor.label(), "pause":self.setup.point, "sigkill":true, "resume_gate":self.setup.gate, "provider_writes_at_kill":self.setup.point.provider_calls(), "native_result_after_reopen":result, "prior_grant_absent":self.setup.point.resumable(), "continued_after_fresh_authorization":self.may_continue(), "provider_writes_after_replays":calls, - "native_count_slots":usize::from(matches!(self.setup.flavor, Flavor::StripePlain)), - "native_sum_units":if matches!(self.setup.flavor, Flavor::StripePlain) { 500 } else { 0 }, + "native_count_slots":usize::from(self.setup.flavor.is_stripe()), + "native_sum_units":if self.setup.flavor.is_stripe() { 500 } else { 0 }, "same_reviewed_request_and_declared_idempotency":true, "subsequent_replays_leave_journal_slots_and_execution_witness_unchanged":true}) } diff --git a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs index c436c053a..379f9b5bd 100644 --- a/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_entry_tests.rs @@ -44,6 +44,7 @@ impl Race { Scenario::AuthorityValid | Scenario::AuthorityExpired => Change::AuthorityExpiry, Scenario::Revoke | Scenario::Configuration + | Scenario::Epoch | Scenario::ObserverValid | Scenario::ObserverExpired | Scenario::ThresholdValid @@ -119,7 +120,7 @@ fn worker(race: &Race, store: &TestAttempts) { fn operator(race: &Race, store: &TestAttempts) { let runtime = runtime(); - let candidate_controls = controls( + let mut candidate_controls = controls( Arc::new(FixedClock::at(NOW)), if matches!(race.scenario, Scenario::Configuration) { 30 @@ -127,6 +128,14 @@ fn operator(race: &Race, store: &TestAttempts) { 29 }, ); + if matches!(race.scenario, Scenario::Epoch) { + candidate_controls.policy = crate::effect::EffectPolicy::new( + "test-partition".to_owned(), + 2, + SigningKey::from_bytes(&[29; 32]).verifying_key().to_bytes(), + ) + .expect("next epoch shares the partition fence"); + } let attempts = GatewayAttempts::new(store.raw(), candidate_controls.policy.clone()) .expect("operator candidate policy"); let (engine, record) = runtime.block_on(load_controlled_engine( @@ -172,7 +181,7 @@ fn operator(race: &Race, store: &TestAttempts) { .block_on(shared.replace(¤t, &revoked)) .expect("operator CAS"); } - Scenario::Configuration => { + Scenario::Configuration | Scenario::Epoch => { engine .activate_effect_configuration(reviewed) .expect("operator activation"); @@ -488,6 +497,8 @@ fn matrix(backend: Backend) { (Scenario::Revoke, Order::GrantFirst), (Scenario::Configuration, Order::ChangeFirst), (Scenario::Configuration, Order::GrantFirst), + (Scenario::Epoch, Order::ChangeFirst), + (Scenario::Epoch, Order::GrantFirst), (Scenario::ApprovalValid, Order::LockWait), (Scenario::ApprovalExpired, Order::LockWait), (Scenario::AuthorityValid, Order::LockWait), diff --git a/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs b/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs new file mode 100644 index 000000000..ac6db84db --- /dev/null +++ b/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs @@ -0,0 +1,109 @@ +//! The mutation replay path consumes the same strict journal decoder. +use super::*; + +fn one(backend: Backend) -> Value { + let directory = tempfile::tempdir().expect("directory"); + let root = std::fs::canonicalize(directory.path()).expect("canonical"); + std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).expect("private"); + let store = TestAttempts::open(backend); + let provider = Provider::start(); + let setup = Setup { + backend: backend.label().to_owned(), + location: store.location(), + root, + provider_port: provider.port, + barrier_port: 0, + }; + let clock = Arc::new(FixedClock::at(NOW)); + let runtime = runtime(); + let (engine, connection) = runtime.block_on(load_controlled_engine( + &setup, + "original", + store.attempts().clone(), + controls(clock.clone(), 29), + )); + let shared = SharedConnection::new( + store.raw(), + connection.provider_kind().clone(), + connection.alias().clone(), + ); + runtime + .block_on(shared.insert(&connection)) + .expect("connection"); + engine.initialize_effect_configuration().expect("config"); + let input = runtime.block_on(Input::author(&engine, Change::None)); + let expected = runtime.block_on(input.submit(&engine)); + assert_eq!( + expected, + GatewaySubmitResult::ResponseRecorded { status: 200 } + ); + let operation = LogicalOperationId::parse(OPERATION).expect("operation"); + let key = crate::GatewayAttemptKey::for_operation( + &crate::effect::fixture_policy().expect("policy"), + recipe().namespace(), + &operation, + ) + .expect("key"); + let raw = store.raw(); + let original = raw + .load(GatewayRecordKind::Attempt, &key) + .expect("load") + .expect("record"); + let reopened = reopened_engine(Change::None, &runtime, &setup, &store, &clock); + let witness = reopened.execution_witness(); + let cases = crate::native_journal_tests::exercise( + &*raw, + key, + &original, + || { + assert_eq!( + runtime.block_on(input.submit(&reopened)), + GatewaySubmitResult::Indeterminate { + code: "gateway.attempt.state-unavailable".to_owned() + } + ); + assert!( + runtime + .block_on(store.attempts().read(recipe().namespace(), &operation)) + .is_err() + ); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!( + *provider.bodies.lock().expect("requests"), + vec![input.body.clone()] + ); + }, + || { + assert_eq!(runtime.block_on(input.submit(&reopened)), expected); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!( + *provider.bodies.lock().expect("requests"), + vec![input.body.clone()] + ); + }, + ); + json!({"protocol":"mutation-response","cases":cases,"real_provider_writes":1,"retained_charges_preserved":true}) +} +fn matrix(backend: Backend) { + let bytes=serde_json::to_vec_pretty(&json!({"schema":"auths.native-mutation-journal/1","adapter":backend.label(), + "scope":"native signed mutation, real HTTP, reopened engine and adapter; isolated privileged record corruption", + "excluded":["hostile store rewriting every correlated record","whole-store rollback without independent anchor","power loss"],"case":one(backend)})).expect("artifact"); + let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-mutation-journal-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("artifact"); + } + assert_eq!(std::fs::read(path).expect("artifact"), bytes); +} +#[test] +fn native_file_mutation_journal_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires maintained TLS PostgreSQL fixture"] +fn postgres_native_mutation_journal_fixture_is_current() { + assert!(postgres_configured()); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs index 48cb0956d..eb269f3f2 100644 --- a/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_replay_tests.rs @@ -562,3 +562,6 @@ fn postgres_native_mutation_retained_replay_fixture_is_current() { assert!(postgres_configured()); matrix(Backend::Postgres); } + +#[path = "native_mutation_journal_tests.rs"] +mod journal_tests; diff --git a/product/runtime/auths-gateway/src/native_partial_upload_tests.rs b/product/runtime/auths-gateway/src/native_partial_upload_tests.rs new file mode 100644 index 000000000..e8f9cd414 --- /dev/null +++ b/product/runtime/auths-gateway/src/native_partial_upload_tests.rs @@ -0,0 +1,155 @@ +//! Real TCP relay drops a request after forwarding one approved body byte. +//! The destination observes a partial request; no provider atomicity or kernel +//! backpressure claim is inferred from that application-level observation. +use super::*; +use std::net::TcpStream; + +fn socket(stream: &TcpStream) { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .expect("read deadline"); + stream + .set_write_timeout(Some(Duration::from_secs(5))) + .expect("write deadline"); +} + +fn header(stream: &mut TcpStream) -> Vec { + let mut bytes = Vec::new(); + while !bytes.ends_with(b"\r\n\r\n") { + assert!(bytes.len() < 16_384); + let mut byte = [0]; + stream.read_exact(&mut byte).expect("header"); + bytes.push(byte[0]); + } + bytes +} + +fn one(backend: Backend, flavor: Flavor) -> Value { + let mut case = Case::new(backend, flavor, Point::DuringResponse, ResumeGate::Current); + let destination = TcpListener::bind("127.0.0.1:0").expect("destination"); + let destination_port = destination.local_addr().expect("port").port(); + let listener = TcpListener::bind("127.0.0.1:0").expect("relay"); + case.setup.installation.provider_port = listener.local_addr().expect("port").port(); + let expected = case.authorization.request.body.clone(); + assert!(expected.len() > 1); + let destination_task = thread::spawn(move || { + let (mut stream, _) = destination.accept().expect("provider accept"); + socket(&stream); + let head = header(&mut stream); + let text = std::str::from_utf8(&head).expect("HTTP"); + assert_eq!(text.lines().next(), Some(flavor.request_line())); + let length = text + .lines() + .find_map(|line| { + line.split_once(':') + .filter(|(name, _)| name.eq_ignore_ascii_case("content-length")) + .map(|(_, value)| value.trim().parse::().expect("length")) + }) + .expect("content length"); + assert_eq!(length, expected.len()); + let mut received = Vec::new(); + stream.take(16_385).read_to_end(&mut received).expect("EOF"); + assert_eq!(received, expected[..1]); + (length, received.len()) + }); + let pause_port = case.setup.installation.barrier_port; + let relay_task = thread::spawn(move || { + let (mut incoming, _) = listener.accept().expect("relay accept"); + socket(&incoming); + let mut outgoing = + TcpStream::connect(("127.0.0.1", destination_port)).expect("destination connect"); + socket(&outgoing); + let head = header(&mut incoming); + outgoing.write_all(&head).expect("forward header"); + let mut first = [0]; + incoming + .read_exact(&mut first) + .expect("approved body prefix"); + outgoing.write_all(&first).expect("forward one body byte"); + pause_at(pause_port); + // Drop both sockets without forwarding any buffered remainder. + }); + let input = case + .setup + .installation + .root + .join("partial-upload-input.json"); + private(&input, &serde_json::to_vec(&case.setup).expect("setup")); + let mut peer = Peer::start( + &input, + "native_mutation_crash_tests::native_mutation_crash_peer", + ENVIRONMENT, + ); + let mut paused = peer.await_pause(&case.listener); + assert!( + !case + .setup + .installation + .root + .join("caller-result.json") + .exists() + ); + peer.kill(); + paused + .write_all(b"G") + .expect("drop connection after SIGKILL"); + relay_task.join().expect("relay"); + let (declared, received) = destination_task.join().expect("destination"); + let before = case.raw().expect("durable grant"); + assert_eq!( + PausedStore::phase_for(CrashProtocol::Mutation, OPERATION, &before), + "entry-granted" + ); + let slots = case.slots(true); + let engine = case.reopened_engine(); + let witness = engine.execution_witness(); + for _ in 0..2 { + assert_eq!( + case.runtime + .block_on(submit(&engine, &case.setup.installation.root)), + GatewaySubmitResult::Unknown + ); + } + assert_eq!( + engine.execution_witness(), + witness, + "partial upload never authorizes another entry" + ); + assert_eq!(case.raw().expect("retained"), before); + assert_eq!(case.slots(true), slots); + assert_eq!( + case.provider.calls(), + 0, + "the unused complete-request double received no request" + ); + json!({"recipe":flavor.label(),"sigkill_during_request":true,"destination_connections":1, + "declared_native_body_bytes":declared,"destination_consumed_body_bytes":received, + "exact_approved_prefix":true,"complete_destination_requests":0, + "reopened_result":"unknown","retained_charges_and_journal_unchanged":true,"replay_has_no_custody_or_transport":true}) +} + +fn matrix(backend: Backend) { + let cases = [Flavor::Airtable, Flavor::StripePlain].map(|flavor| one(backend, flavor)); + let bytes=serde_json::to_vec_pretty(&json!({"schema":"auths.native-partial-upload/1","adapter":backend.label(), + "scope":"real gateway worker, approved request, TCP relay/destination, SIGKILL, maintained durable store", + "excluded":["kernel backpressure","provider atomicity or known non-effect","power loss","live provider qualification"],"cases":cases})).expect("artifact"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!( + "../../../bindings/fixtures/gateway/native-partial-upload-{}.json", + backend.label() + )); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("fixture"); + } + assert_eq!(std::fs::read(path).expect("fixture"), bytes); +} + +#[test] +fn native_file_partial_upload_fixture_is_current() { + matrix(Backend::File); +} +#[test] +#[ignore = "requires maintained TLS PostgreSQL fixture"] +fn postgres_native_partial_upload_fixture_is_current() { + assert!(postgres_configured(), "TLS PostgreSQL fixture is required"); + matrix(Backend::Postgres); +} diff --git a/product/runtime/auths-gateway/src/native_process_tests.rs b/product/runtime/auths-gateway/src/native_process_tests.rs index ecb96fcfd..a0614e005 100644 --- a/product/runtime/auths-gateway/src/native_process_tests.rs +++ b/product/runtime/auths-gateway/src/native_process_tests.rs @@ -82,6 +82,8 @@ pub(super) struct EngineControls { pub(super) clock: Arc, pub(super) recipe: Option, pub(super) trust: Option>, + /// Explicit public synthetic credential for a recipe's real prefix guard. + pub(super) credential: Option<&'static [u8]>, } impl EngineControls { pub(super) fn baseline() -> Self { @@ -90,6 +92,7 @@ impl EngineControls { clock: Arc::new(crate::FixedClock::at(NOW)), recipe: None, trust: None, + credential: None, } } } @@ -136,7 +139,8 @@ pub(super) async fn load_controlled_engine_at_generation( .install( initial.connection_id(), generation, - SecretBytes::new(SECRET.to_vec()).expect("synthetic credential"), + SecretBytes::new(controls.credential.unwrap_or(SECRET).to_vec()) + .expect("synthetic credential"), ) .await .expect("credential install"); diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index a4bc0f0f9..726ad564b 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "a00efd11f811f045119cfef58ea049b73bdb6848f3eabfbfed9dc94e9d55d3b8"; + "6313af76a8be501ada02f126b5d30713d5baffe49704066b11cd95e59596c159"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index ebfee033c..736086c00 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -701,7 +701,10 @@ impl Record { pre_entry.decode()?; } } - if self.schema != SCHEMA + if self.revision == 0 + || self.revision > MAX_JSON_INTEGER + || self.evaluated_at > MAX_JSON_INTEGER + || self.schema != SCHEMA || self.nonce.len() != 32 || !self .nonce @@ -1404,6 +1407,11 @@ impl GatewayRecordEntry { } } +#[cfg(test)] +pub(crate) fn fixture_prerequisite_key(parent: GatewayAttemptKey, index: u8) -> GatewayAttemptKey { + acquisition::prerequisite_key(parent, index) +} + fn validate_batch(entries: &[GatewayRecordEntry]) -> Result<(), GatewayAttemptError> { let mechanism: Vec<_> = entries.iter().map(GatewayRecordEntry::mechanism).collect(); auths_stores::validate_gateway_batch(&mechanism).map_err(postgres_error) @@ -3224,6 +3232,11 @@ fn decode_protocol(bytes: &[u8]) -> Result, GatewayAttempt } let record: Record = serde_json::from_slice(bytes).map_err(|_| GatewayAttemptError::Corrupt)?; + // The journal has one writer encoding. Refuse alternate encodings before + // history lookup can turn restored bytes into a retained execution fact. + if canonical(&record)?.as_slice() != bytes { + return Err(GatewayAttemptError::Corrupt); + } record.validate_header()?; match &record.state { ProtocolState::Disclosure(_) => { diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 70297323a..ec68ece0d 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 430 +freeze_version = 431 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -45,7 +45,7 @@ freeze_version = 430 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-create/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/subscription-modify/v1/manifest.sha256.json" = 1 "auths.frozen-bytes/product/integrations/auths-stripe/fixtures/v1/manifest.sha256.json" = 1 -"auths.identity.protocol" = 171 +"auths.identity.protocol" = 172 "auths.modular-components" = 22 "auths.portable-abi-bindings" = 130 "auths.product.bounded-domains" = 19 @@ -60,11 +60,11 @@ freeze_version = 430 "auths.product.mcp-closed-execution" = 32 "auths.product.mechanism-profile-conformance" = 13 "auths.product.operations" = 5 -"auths.product.public-sdk-contract" = 167 +"auths.product.public-sdk-contract" = 168 "auths.product.receipts" = 13 "auths.product.release-assurance" = 7 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 "auths.release.evolution-contract" = 84 -"auths.release.public-surface" = 430 +"auths.release.public-surface" = 431 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index dac77bd9e..5a1e51d82 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 430, + "freezeVersion": 431, "publicSurface": { "rustRoots": [ "auths", @@ -550,7 +550,7 @@ }, { "id": "auths.identity.protocol", - "version": 171, + "version": 172, "classification": "frozen-meaning", "categories": [ "identity-protocol-versions", @@ -573,7 +573,7 @@ "core/fixtures/identity/v1/vectors.json", "core/spec/identity/v1" ], - "sha256": "8c2d8909c9aea852fd65ccb4fc99c5bc8087f62627deb21f9a909af26bff7e73" + "sha256": "5b587f9952bf116d9384ccb074644561a2d705060eadf6dcf5214198a1aaebbb" }, { "id": "auths.modular-components", @@ -871,7 +871,7 @@ }, { "id": "auths.product.public-sdk-contract", - "version": 167, + "version": 168, "classification": "frozen-meaning", "categories": [ "rust-sdk-contract", @@ -889,7 +889,7 @@ "product/runtime/auths-runtime/src", "product/sdk/auths-sdk/src" ], - "sha256": "da7bd251822a3fc1805792b64e71df80322f53c4fef28b27157146eaafda5adb" + "sha256": "8a4939badc5a1743ec9b5ae308a7f7c29038f2a8086a70914a5447d62d01252f" }, { "id": "auths.product.receipts", @@ -1011,7 +1011,7 @@ }, { "id": "auths.release.public-surface", - "version": 430, + "version": 431, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "9a3bcd9ae0a0a673542f6f2d109a909807fc066495113fc804468f7d965ff79a" + "sha256": "4478474e980688c87472c61191dc8971ba46ae307f8fb2a93f9c08729c394825" } ] } From 909193d6576e4035464d062d593bd0fafb8d1e5f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 06:30:52 +0900 Subject: [PATCH 128/136] fix(gateway): enforce the declared operation event limit --- .../native-information-journal-file.json | 39 +++++++ .../native-information-journal-postgres.json | 39 +++++++ .../gateway/native-mutation-journal-file.json | 13 +++ .../native-mutation-journal-postgres.json | 13 +++ docs/plans/0074-final-acceptance-audit.md | 25 +++++ docs/plans/0074-implementation-status.md | 26 +++++ .../0009-bound-effect-and-recovery.md | 28 ++++- ...ound-effects-and-recovery-state-machine.md | 12 +- .../auths-gateway/semantic-closure.json | 2 +- .../src/native_information_journal_tests.rs | 51 +++++++++ .../auths-gateway/src/native_journal_tests.rs | 104 ++++++++++++------ .../src/native_mutation_journal_tests.rs | 11 ++ .../auths-gateway/src/semantic_closure.rs | 2 +- product/runtime/auths-gateway/src/store.rs | 47 ++++++-- .../src/store/acquisition/recovery.rs | 7 +- 15 files changed, 361 insertions(+), 58 deletions(-) diff --git a/bindings/fixtures/gateway/native-information-journal-file.json b/bindings/fixtures/gateway/native-information-journal-file.json index 03bcb110a..822c7bf3d 100644 --- a/bindings/fixtures/gateway/native-information-journal-file.json +++ b/bindings/fixtures/gateway/native-information-journal-file.json @@ -11,6 +11,13 @@ { "protocol": "acquisition-response", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -23,6 +30,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, @@ -120,6 +133,13 @@ { "protocol": "disclosure-acknowledged", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -132,6 +152,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, @@ -229,6 +255,13 @@ { "protocol": "disclosure-unknown", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -241,6 +274,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, diff --git a/bindings/fixtures/gateway/native-information-journal-postgres.json b/bindings/fixtures/gateway/native-information-journal-postgres.json index 4cbe028fe..bb212f1c6 100644 --- a/bindings/fixtures/gateway/native-information-journal-postgres.json +++ b/bindings/fixtures/gateway/native-information-journal-postgres.json @@ -11,6 +11,13 @@ { "protocol": "acquisition-response", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -23,6 +30,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, @@ -120,6 +133,13 @@ { "protocol": "disclosure-acknowledged", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -132,6 +152,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, @@ -229,6 +255,13 @@ { "protocol": "disclosure-unknown", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -241,6 +274,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, diff --git a/bindings/fixtures/gateway/native-mutation-journal-file.json b/bindings/fixtures/gateway/native-mutation-journal-file.json index 51dbd707d..07ea37d95 100644 --- a/bindings/fixtures/gateway/native-mutation-journal-file.json +++ b/bindings/fixtures/gateway/native-mutation-journal-file.json @@ -10,6 +10,13 @@ "case": { "protocol": "mutation-response", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -22,6 +29,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, diff --git a/bindings/fixtures/gateway/native-mutation-journal-postgres.json b/bindings/fixtures/gateway/native-mutation-journal-postgres.json index 8c27f5e69..9d9a1852f 100644 --- a/bindings/fixtures/gateway/native-mutation-journal-postgres.json +++ b/bindings/fixtures/gateway/native-mutation-journal-postgres.json @@ -10,6 +10,13 @@ "case": { "protocol": "mutation-response", "cases": [ + { + "case": "revision-exact-limit", + "revision": 64, + "native_history_accepted": true, + "read_only_replay": true, + "bytes_unchanged": true + }, { "case": "obsolete-schema", "refused_without_custody_or_transport": true, @@ -22,6 +29,12 @@ "bytes_unchanged": true, "restored_exact_positive": true }, + { + "case": "revision-limit-plus-one", + "refused_without_custody_or_transport": true, + "bytes_unchanged": true, + "restored_exact_positive": true + }, { "case": "revision-unsafe-integer", "refused_without_custody_or_transport": true, diff --git a/docs/plans/0074-final-acceptance-audit.md b/docs/plans/0074-final-acceptance-audit.md index 4bff1a2c9..869dd4134 100644 --- a/docs/plans/0074-final-acceptance-audit.md +++ b/docs/plans/0074-final-acceptance-audit.md @@ -145,3 +145,28 @@ adapter constructors passed. Source closure is refreshed after that change. Release metadata advances only the reported identity/public-SDK/public-surface subjects to 172/168/431, with freeze431. These local results construct and check the change; they do not close final exact-head hosted or external qualification. + +## Final source audit correction — event bound + +The P0 abstraction case declared64events per operation, while the native journal +previously admitted any positive JSON-safe revision. The final correction shares +one64-revision advancement check across all native protocol/grant/refinement +writers and enforces it in decoding and read-evidence references. Exact64 retains +terminal read-only history;65 is corrupt and cannot become a new grant. All +checks are authored before artifact construction/verification. The source audit +also reconciles the P0 table's stale five-second lock and1,024-entry inventory +claims with the stricter maintained two-second deadlines and separately bounded +inventory/expiry scans. The translated kernel and existing security tests remain +unchanged; final construction and hosted verification of this correction remain +pending. + +The complete revision-bound correction cohort passed six exact selectors: +all legal/terminal arithmetic boundaries, file/TLS PostgreSQL retained information +and mutation journals, and source closure. Every selector matched once with one +pass and zero ignored tests. Exact64 histories produced no custody, provider or +recipient entry;65 refused and preserved bytes. All-target/all-feature gateway +Clippy passed (10.02s), and semantic metadata construction passed without further +identity changes. Final correction closure is +`71ff1dcdd7464474a0d1b12f661f7277d665775a6a192128bbbc5870ff9231eb`. +The correction is committed for integration with the CI agent's combined actual +977 repair roots; final hosted acceptance remains unverified until that cohort. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index bdafef3a1..0abd7dd9a 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -4077,3 +4077,29 @@ freeze431 and only reported identity172/publicSDK168/publicsurface431 subjects. Final hosted broad, adapter, platform, installed, containment, differential, formal/refinement/release and performance evidence remains the CI agent's job. The goal remains incomplete until its exact-head completion audit passes. + +## Final source-audit correction batch — authored + +Final requirement inspection found the P0 table's64-event promise was not enforced +by the private journal's wider JSON-safe revision check. The complete correction +is authored before any runs: one shared native revision advancement function, +header/read-link bound checks, every legal increment and terminal overflow unit +cases, and exact64/65 native replay on both adapters across all four retained +protocol outcomes. At the cap, terminal history remains available while any +further event fails before persistence or grant. P0's stale lock/inventory table +values are reconciled to actual stricter maintained constants. No kernel/formal +source, public result encoding, production deadline or existing assertion is +relaxed. Artifact construction and verification run only after this entire batch. +The CI agent is collecting977ae61f's actual roots and holds publication so these +changes can join one combined repair cohort. + +The complete revision-bound correction cohort passed six exact selectors: +all legal/terminal arithmetic boundaries, file/TLS PostgreSQL retained information +and mutation journals, and source closure. Every selector matched once with one +pass and zero ignored tests. Exact64 histories produced no custody, provider or +recipient entry;65 refused and preserved bytes. All-target/all-feature gateway +Clippy passed (10.02s), and semantic metadata construction passed without further +identity changes. Final correction closure is +`71ff1dcdd7464474a0d1b12f661f7277d665775a6a192128bbbc5870ff9231eb`. +The correction is committed for integration with the CI agent's combined actual +977 repair roots; final hosted acceptance remains unverified until that cohort. diff --git a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md index a699f3f84..cb0ad54b4 100644 --- a/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md +++ b/docs/research/domains/abstraction-cases/0009-bound-effect-and-recovery.md @@ -67,26 +67,26 @@ that lookup. Optional task-free scope has an explicit tag distinct from task sco | Resource / recipient / channel / scope label | One per operation, each at most 512 UTF-8 bytes | | Compiler write body | Existing 16,384 bytes | | Recipe source / lock | Existing 65,536 bytes each | -| Path / template | Existing 16 segments, 64 nodes, depth 6; bounded final URL 8,192 bytes | +| Path / template | Existing 16 segments, 64 nodes, depth 6; encoded path at most 8,192 bytes, with the separately validated origin bounded by the 65,536-byte recipe source. Content transport additionally caps the full URL at 8,192 bytes. | | Headers | Existing recipe maximum two provider headers; total compiled headers at most 8, names 64 and values 1,024 bytes | | Selected branches/evidence | Native configured collection bounds; total effect encoding bound also applies | | Reservations | Existing maximum 34 counters; typed units and exact window | | Provider response / private retained bytes | 65,536 bytes per operation; content not retained by default | | Pre-entry observations | Existing 4, each native maximum 4,096 bytes | | Journal record / atomic batch | Existing 262,144 bytes / 64 entries | -| Events / ACK | 64 events per operation / 4,096 canonical bytes per ACK | +| Events / ACK | 64 durable operation revisions, including admission; one fixed typed snapshot, no unbounded event list / 4,096 canonical bytes per ACK | | Exact human approval | 4,096 canonical bytes; at most 3,600 seconds, with exclusive expiry | | Installed effect policy | `MAX_EFFECT_POLICY_BYTES`: 4,096 canonical bytes before decoding; partition at most 512 bytes; explicit nonzero safe-integer epoch; valid nonweak Ed25519 approver | | Private human review | 131,072 bytes including exact request and binding; never a public receipt | | Demo owner HTTP interface | One pending review; eight handlers; 1,024-byte commands; native 131,072-byte envelope; five-second I/O, 900-second session and 600-second consent wait; no native expiry extension | | Demo private review sockets | Existing source-only requests remain 1,024 bytes; separate mutation proof/action frame at most 4 MiB, followed by native proof/action limits; finite closed labels/attempt counts | | Observation attempts | At most 16 explicitly admitted linked operations | -| Transaction lock deadline | 5 seconds; sample time after lock; refuse on deadline | +| Transaction lock / fenced decision | Separate two-second lock and cooperative decision bounds (`auths_stores::{GATEWAY_LOCK_TIMEOUT,GATEWAY_FENCE_DEADLINE}`); sample native time after lock; refuse before publication on deadline | | Native verification work | Native configured work-unit limit plus transaction deadline | | Driver | Existing 64 steps | | Transport | Existing 15-second maximum; no redirects or write retries | | Claim contention / file recovery | Existing 32 claim rounds / 8 recovery rounds | -| Recovery scan / public receipt | 1,024 records per page / 16,384 bytes | +| Recovery inventory / expiry maintenance / public evidence | At most 4,096 inventory keys, 16,384 scanned file entries plus one overflow probe; expiry scans at most 4,096 entries and runtime sweep requests at most 1,024 deletions; all stop under the cooperative two-second bound. Signed native observations are at most 4,096 canonical CBOR bytes; the enclosing application protocol has its separate 8 MiB frame ceiling. | Tighter existing limits win. New limits above are implementation requirements, not claims that baseline code enforces them. Bounds must be checked before @@ -948,3 +948,23 @@ Opaque wire capture, raw file/charge comparisons, native reauthorization and historical ACK refinement exercise the existing owners. This is test-only parity under simulated syscall returns, not extraction of a shipping lifecycle mechanism or qualification of kernel/device/power-loss behavior. + +### Final event-bound audit + +The declared 64-event limit is enforced as operation revisions 1 through 64 by +`store::next_operation_revision`, shared by grant publication, typed protocol +advancement and recovery refinement. Current journal decoding and linked read +revision validation reject values above that bound. A terminal record at revision +64 remains readable and replayable without any new capability; advancing it +fails before persistence. Configuration revisions are a distinct shared-control +sequence and are not operation events. + +The native corrupt-journal corpus exercises exact64 terminal replay and65 refusal +for mutation, acquisition, acknowledged disclosure and lost-ACK disclosure on +both adapters. The shared arithmetic boundary test covers every legal increment, +zero,64,65,JSON maximum and u64 maximum. Native validation is stricter than the +translated generic JSON-safe transition predicate; every concrete replacement +still calls full native record validation. No kernel theorem or durability +assumption is weakened. No bounded-upfront consent mode is exposed: all maintained +managed operations require native exact approval, while the retained AP070 +reference's different consent semantics remain independent. diff --git a/docs/specs/0074-bound-effects-and-recovery-state-machine.md b/docs/specs/0074-bound-effects-and-recovery-state-machine.md index 37ca00e51..1490d0b36 100644 --- a/docs/specs/0074-bound-effects-and-recovery-state-machine.md +++ b/docs/specs/0074-bound-effects-and-recovery-state-machine.md @@ -1204,10 +1204,14 @@ Whole-store rollback is outside ordinary crash recovery. Keep existing commissio Persist sensitive reconstruction data only if necessary and protected. If private content is intentionally not retained, recovery may remain unresolved; it must not refetch or redeliver to manufacture certainty. Native journal replay accepts only the current native writer encoding. Reject -obsolete schemas, duplicate/unknown members, alternate encodings, zero or -non-JSON-safe revisions/times and inconsistent binding/protocol/evidence before -history can confer any retained execution fact. Corrupt state is indeterminate; -it cannot establish that an operation was not entered. Adapter byte limits apply +obsolete schemas, duplicate/unknown members, alternate encodings, operation +revisions outside `1..=64`, non-JSON-safe event times and inconsistent +binding/protocol/evidence before history can confer any retained execution fact. +Admission is durable revision 1; +all operation advancement, including entry and recovery refinement, shares the +64-revision cap. At the exact limit terminal history remains replayable without +I/O; further advancement fails before persistence or capability publication. +Corrupt state is indeterminate; it cannot establish that an operation was not entered. Adapter byte limits apply before decoding. Runtime must not repair, migrate or re-sign corrupt state. ## 7. Central implementation surfaces diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 67c5a568b..7f1c58a3f 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"ca1d7950bc766de53b021bc25613fd7ae428898198e34e654f5ed04ee549468a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"0e8497dacefe7943f6da0e8a1f41ec141c04c77c9ac9a61ef37b130c4f2c1450"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"2e975f364e6c63408bb16ad4a975f4020ad07129a29846cf32662b630723eb60"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"13db3dbf6daadb40edc984ae1262235d8991813184c3b65c46777cf44fdcfc31"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"346b0e579489009ff899a168b3468201c2b43194f3a9aef70095e24ee30d1a47"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"59c7893e9401262fbf2b66d89dd662f4987fd69054ddb6a968018a20b528c59b"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"ca1d7950bc766de53b021bc25613fd7ae428898198e34e654f5ed04ee549468a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"dd0821e8337e56189708496ca85cc2f2da2d6a4ea8b53db5aa0412beead69864"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"d803ff53f90ce2a8c29808b4f874cd81954a3a5c52e19b519ab22f0543808fe1"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"181bf0a196805e50944cff4fe2315459eba877e7d7b5b90bf3c99e3353a8cad7"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"fdf746572649f554f24089d0dd6322d964be1c12d1695dd5d9f8d86079b23a82"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"87363b666c16cef5f4566db25b3cbec93f3083b2bf8508a5c55ce78667bc4a6c"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/native_information_journal_tests.rs b/product/runtime/auths-gateway/src/native_information_journal_tests.rs index 9993e8d85..4e262f808 100644 --- a/product/runtime/auths-gateway/src/native_information_journal_tests.rs +++ b/product/runtime/auths-gateway/src/native_information_journal_tests.rs @@ -83,6 +83,16 @@ fn one(backend: Backend, protocol: Protocol) -> Value { assert_eq!(reopened.execution_witness(), witness); assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); }, + || { + fixture.runtime.block_on(replay_at_limit( + &reopened, + &input, + history.as_ref(), + &acquired, + )); + assert_eq!(reopened.execution_witness(), witness); + assert_eq!(fixture.provider.calls.load(Ordering::SeqCst), 1); + }, ); json!({"protocol":protocol.label(),"cases":cases,"real_provider_reads":1, "exact_retained_charges_preserved":true,"disclosure_replay_sends_zero_bytes":true}) @@ -117,3 +127,44 @@ fn postgres_native_information_journal_fixture_is_current() { assert!(postgres_configured()); matrix(Backend::Postgres); } + +async fn replay_at_limit( + engine: &GatewayEngine, + input: &Input, + history: Option<&ReleaseHistory>, + acquired: &crate::AcquisitionSnapshot, +) { + if let Some(history) = history { + let (server, mut client) = UnixStream::pair().expect("read-only replay channel"); + let mut expected = history.snapshot.clone(); + expected.revision = crate::store::MAX_OPERATION_REVISIONS; + assert_eq!( + engine + .disclose( + &history.target, + &history.input.proof, + &history.input.action, + history.input.approval.clone(), + crate::disclosure_transport::DisclosureConnection::new( + server, + history.policy.clone() + ) + ) + .await + .expect("terminal history at limit"), + expected + ); + let mut byte = [0]; + assert_eq!(client.read(&mut byte).await.expect("closed channel"), 0); + } else { + let mut expected = acquired.clone(); + expected.revision = crate::store::MAX_OPERATION_REVISIONS; + assert_eq!( + engine + .acquire_content_action(&input.proof, &input.action, input.approval.clone()) + .await + .expect("terminal history at limit"), + expected + ); + } +} diff --git a/product/runtime/auths-gateway/src/native_journal_tests.rs b/product/runtime/auths-gateway/src/native_journal_tests.rs index c523ec13d..2a1e593e1 100644 --- a/product/runtime/auths-gateway/src/native_journal_tests.rs +++ b/product/runtime/auths-gateway/src/native_journal_tests.rs @@ -23,15 +23,85 @@ pub(super) fn exercise( original: &[u8], mut refuse: impl FnMut(), mut positive: impl FnMut(), + mut limit_replay: impl FnMut(), ) -> Vec { positive(); let source: Value = serde_json::from_slice(original).expect("native record"); + let at_limit = member( + original, + "revision", + &json!(crate::store::MAX_OPERATION_REVISIONS), + ); + assert_eq!( + crate::store::fixture_journal_revision(&at_limit), + Ok(crate::store::MAX_OPERATION_REVISIONS) + ); + store + .replace(GatewayRecordKind::Attempt, &key, original, &at_limit) + .expect("isolated boundary state"); + limit_replay(); + assert_eq!( + store.load(GatewayRecordKind::Attempt, &key).expect("load"), + Some(at_limit.clone()) + ); + store + .replace(GatewayRecordKind::Attempt, &key, &at_limit, original) + .expect("restore exact record"); + positive(); + let variants = corruptions(original, &source); + let mut cases = vec![ + json!({"case":"revision-exact-limit","revision":crate::store::MAX_OPERATION_REVISIONS, + "native_history_accepted":true,"read_only_replay":true,"bytes_unchanged":true}), + ]; + for (name, bytes) in variants { + store + .replace(GatewayRecordKind::Attempt, &key, original, &bytes) + .expect("isolated corruption injection"); + refuse(); + assert_eq!( + store.load(GatewayRecordKind::Attempt, &key).expect("load"), + Some(bytes.clone()), + "refusal cannot repair or re-sign {name}" + ); + store + .replace(GatewayRecordKind::Attempt, &key, &bytes, original) + .expect("restore exact owned record"); + positive(); + cases.push(json!({"case":name,"refused_without_custody_or_transport":true,"bytes_unchanged":true,"restored_exact_positive":true})); + } + let oversized = vec![b' '; auths_stores::MAX_GATEWAY_RECORD_BYTES + 1]; + assert!( + store + .replace(GatewayRecordKind::Attempt, &key, original, &oversized) + .is_err(), + "adapter enforces the journal byte bound" + ); + assert_eq!( + store.load(GatewayRecordKind::Attempt, &key).expect("load"), + Some(original.to_vec()) + ); + positive(); + cases.push( + json!({"case":"record-limit-plus-one","refused_at_adapter":true,"original_preserved":true}), + ); + cases +} + +fn corruptions(original: &[u8], source: &Value) -> Vec<(&'static str, Vec)> { let mut variants = vec![ ( "obsolete-schema", member(original, "schema", &json!("auths.obsolete-journal/0")), ), ("revision-zero", member(original, "revision", &json!(0))), + ( + "revision-limit-plus-one", + member( + original, + "revision", + &json!(crate::store::MAX_OPERATION_REVISIONS + 1), + ), + ), ( "revision-unsafe-integer", member(original, "revision", &json!(1_u64 << 53)), @@ -90,37 +160,5 @@ pub(super) fn exercise( "unknown-member", [b"{\"obsolete_authority\":true,".as_slice(), &original[1..]].concat(), )); - let mut cases = Vec::new(); - for (name, bytes) in variants { - store - .replace(GatewayRecordKind::Attempt, &key, original, &bytes) - .expect("isolated corruption injection"); - refuse(); - assert_eq!( - store.load(GatewayRecordKind::Attempt, &key).expect("load"), - Some(bytes.clone()), - "refusal cannot repair or re-sign {name}" - ); - store - .replace(GatewayRecordKind::Attempt, &key, &bytes, original) - .expect("restore exact owned record"); - positive(); - cases.push(json!({"case":name,"refused_without_custody_or_transport":true,"bytes_unchanged":true,"restored_exact_positive":true})); - } - let oversized = vec![b' '; auths_stores::MAX_GATEWAY_RECORD_BYTES + 1]; - assert!( - store - .replace(GatewayRecordKind::Attempt, &key, original, &oversized) - .is_err(), - "adapter enforces the journal byte bound" - ); - assert_eq!( - store.load(GatewayRecordKind::Attempt, &key).expect("load"), - Some(original.to_vec()) - ); - positive(); - cases.push( - json!({"case":"record-limit-plus-one","refused_at_adapter":true,"original_preserved":true}), - ); - cases + variants } diff --git a/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs b/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs index ac6db84db..deb4d3f80 100644 --- a/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs +++ b/product/runtime/auths-gateway/src/native_mutation_journal_tests.rs @@ -81,6 +81,17 @@ fn one(backend: Backend) -> Value { vec![input.body.clone()] ); }, + || { + assert_eq!(runtime.block_on(input.submit(&reopened)), expected); + assert_eq!( + runtime + .block_on(store.attempts().read(recipe().namespace(), &operation)) + .expect("history at limit") + .expect("record") + .revision(), + crate::store::MAX_OPERATION_REVISIONS + ); + }, ); json!({"protocol":"mutation-response","cases":cases,"real_provider_writes":1,"retained_charges_preserved":true}) } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 726ad564b..d73af08b9 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "6313af76a8be501ada02f126b5d30713d5baffe49704066b11cd95e59596c159"; + "71ff1dcdd7464474a0d1b12f661f7277d665775a6a192128bbbc5870ff9231eb"; #[cfg(test)] mod tests { diff --git a/product/runtime/auths-gateway/src/store.rs b/product/runtime/auths-gateway/src/store.rs index 736086c00..75e64aec7 100644 --- a/product/runtime/auths-gateway/src/store.rs +++ b/product/runtime/auths-gateway/src/store.rs @@ -66,6 +66,40 @@ const MAX_REFUSAL_BYTES: usize = 128; const MAX_LOCATOR_VALUES: usize = 2; const MAX_LOCATOR_VALUE_BYTES: usize = 255; const MAX_JSON_INTEGER: u64 = (1 << 53) - 1; +/// Admission is revision one; at most 64 durable events belong to one operation. +pub(crate) const MAX_OPERATION_REVISIONS: u64 = 64; + +fn next_operation_revision(revision: u64) -> Result { + if revision == 0 || revision >= MAX_OPERATION_REVISIONS { + return Err(GatewayAttemptError::InvalidTransition); + } + Ok(revision + 1) +} + +#[cfg(test)] +#[test] +fn operation_revision_limit_preserves_last_event_without_wrap_or_restart() { + for revision in 1..MAX_OPERATION_REVISIONS { + assert_eq!(next_operation_revision(revision), Ok(revision + 1)); + } + for revision in [ + 0, + MAX_OPERATION_REVISIONS, + MAX_OPERATION_REVISIONS + 1, + MAX_JSON_INTEGER, + u64::MAX, + ] { + assert_eq!( + next_operation_revision(revision), + Err(GatewayAttemptError::InvalidTransition) + ); + } +} + +#[cfg(test)] +pub(crate) fn fixture_journal_revision(bytes: &[u8]) -> Result { + Ok(decode_protocol(bytes)?.revision) +} /// Conservative gateway attempt stages; a response is not effect evidence. #[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)] @@ -702,7 +736,7 @@ impl Record { } } if self.revision == 0 - || self.revision > MAX_JSON_INTEGER + || self.revision > MAX_OPERATION_REVISIONS || self.evaluated_at > MAX_JSON_INTEGER || self.schema != SCHEMA || self.nonce.len() != 32 @@ -727,10 +761,7 @@ impl Record { if self.entry.is_some() || authorization_started_at < self.evaluated_at { return Err(GatewayAttemptError::InvalidTransition); } - self.revision = self - .revision - .checked_add(1) - .ok_or(GatewayAttemptError::InvalidTransition)?; + self.revision = next_operation_revision(self.revision)?; self.entry = Some(EntryAudit { revision: self.revision, authorization_started_at, @@ -2795,11 +2826,7 @@ impl Attempt { /// Persists `next` only as a valid stage change from the exact stored /// record; a concurrent change by another process is a conflict. async fn advance(mut self, mut next: Record) -> Result { - next.revision = self - .record - .revision - .checked_add(1) - .ok_or(GatewayAttemptError::InvalidTransition)?; + next.revision = next_operation_revision(self.record.revision)?; if !valid_transition(&self.record, &next)? { return Err(GatewayAttemptError::InvalidTransition); } diff --git a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs index afd6732f8..012c34310 100644 --- a/product/runtime/auths-gateway/src/store/acquisition/recovery.rs +++ b/product/runtime/auths-gateway/src/store/acquisition/recovery.rs @@ -217,7 +217,7 @@ impl RecoveryEvidenceLink { digest_bytes(&self.acquisition_effect)?; digest_bytes(&self.response_digest)?; if operation.as_str() == source.operation_id - || !(3..=MAX_JSON_INTEGER).contains(&self.acquisition_revision) + || !(3..=MAX_OPERATION_REVISIONS).contains(&self.acquisition_revision) || self.received_at < source.evaluated_at || self.recorded_at > MAX_JSON_INTEGER || !fresh(self.received_at, self.recorded_at) @@ -352,10 +352,7 @@ fn refinement( } } next.state.recovery_evidence = Some(link); - next.revision = next - .revision - .checked_add(1) - .ok_or(GatewayAttemptError::InvalidTransition)?; + next.revision = next_operation_revision(next.revision)?; if !valid_transition(source, &next)? { return Err(GatewayAttemptError::InvalidTransition); } From 08b972f581a33adf47e8ff0c98ba20d08d99207b Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 06:38:58 +0900 Subject: [PATCH 129/136] fix(ci): repair final gateway evidence producers --- .github/workflows/postgres-lifecycle.yml | 4 +- .github/workflows/recipe-qualification.yml | 14 ++- .../gateway/application-content-cli.json | 2 +- .../gateway/application-recovery-cli.json | 2 +- docs/plans/0074-hosted-evidence-5acd62b0.md | 101 ++++++++++++++++++ docs/plans/0074-hosted-evidence-977ae61f.md | 51 +++++++++ .../auths-gateway/semantic-closure.json | 2 +- .../auths-gateway/src/effect_native_tests.rs | 1 + .../auths-gateway/src/semantic_closure.rs | 2 +- 9 files changed, 173 insertions(+), 6 deletions(-) create mode 100644 docs/plans/0074-hosted-evidence-5acd62b0.md create mode 100644 docs/plans/0074-hosted-evidence-977ae61f.md diff --git a/.github/workflows/postgres-lifecycle.yml b/.github/workflows/postgres-lifecycle.yml index 07eaf8fa1..b4e52f2a5 100644 --- a/.github/workflows/postgres-lifecycle.yml +++ b/.github/workflows/postgres-lifecycle.yml @@ -118,7 +118,7 @@ jobs: log="target/ap074-final-hardening/${selector//::/__}.log" if ! cargo test --locked -p auths-gateway --features loopback-provider,testkit-harness --lib -- "${extra[@]}" --exact "$selector" 2>&1 | tee "$log"; then failures=$((failures + 1)) - elif ! rg -q 'test result: ok\. 1 passed; 0 failed; 0 ignored;' "$log"; then + elif ! grep -Fq 'test result: ok. 1 passed; 0 failed; 0 ignored;' "$log"; then echo "Required selector did not execute exactly once: $selector" failures=$((failures + 1)) fi @@ -132,6 +132,8 @@ jobs: native_mutation_replay_tests::journal_tests::native_file_mutation_journal_fixture_is_current native_mutation_replay_tests::journal_tests::postgres_native_mutation_journal_fixture_is_current observed_tests::effect_native_tests::binding_boundary_tests::native_independent_binding_substitutions_require_new_approval + observed_tests::effect_native_tests::review_approval_tests::native_review_changes_require_fresh_authority_and_approval + store::operation_revision_limit_preserves_last_event_without_wrap_or_restart SELECTORS test "$failures" -eq 0 - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 diff --git a/.github/workflows/recipe-qualification.yml b/.github/workflows/recipe-qualification.yml index fef4cfc24..243b37c6f 100644 --- a/.github/workflows/recipe-qualification.yml +++ b/.github/workflows/recipe-qualification.yml @@ -260,7 +260,19 @@ jobs: - name: Build the portable simulation harness run: | mkdir -p target - cargo test --locked -p auths-gateway --features loopback-provider --lib --no-run --message-format=json > target/qualification-harness-build.jsonl + if ! cargo test --locked -p auths-gateway --features loopback-provider --lib --no-run --message-format=json > target/qualification-harness-build.jsonl; then + python - <<'PY' + import json + import sys + from pathlib import Path + + for line in Path("target/qualification-harness-build.jsonl").read_text().splitlines(): + event = json.loads(line) + if event.get("reason") == "compiler-message": + print(event["message"].get("rendered") or event["message"]["message"], file=sys.stderr) + PY + exit 1 + fi python qualification/simulation/pack.py --build-report target/qualification-harness-build.jsonl --out target/qualification-candidate-kit - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 with: diff --git a/bindings/fixtures/gateway/application-content-cli.json b/bindings/fixtures/gateway/application-content-cli.json index 44d832a6a..54a0ec7e7 100644 --- a/bindings/fixtures/gateway/application-content-cli.json +++ b/bindings/fixtures/gateway/application-content-cli.json @@ -10,7 +10,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ" } }, "response": { diff --git a/bindings/fixtures/gateway/application-recovery-cli.json b/bindings/fixtures/gateway/application-recovery-cli.json index 248508961..c22aa561e 100644 --- a/bindings/fixtures/gateway/application-recovery-cli.json +++ b/bindings/fixtures/gateway/application-recovery-cli.json @@ -8,7 +8,7 @@ "schema": "auths.gateway-submit/2", "proof_b64": "AA", "action_b64": "AA", - "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOlsxODQsMTM1LDE3MiwyMTYsMSwyMSwxNDAsOTcsMTU5LDEwNiwyMDQsMTA1LDE1MSw4LDYwLDQ2LDE4OSwzNSw5MSw1MSwyNDUsMTM5LDE0LDY0LDIzLDMsMTEwLDIwOCwxNjYsNTAsMTU5LDYzXSwiZXhwaXJlc19hdCI6MTc5MDAwMDAzMCwibm90X2JlZm9yZSI6MTc5MDAwMDAwMCwic2NoZW1hIjoiYXV0aHMuZXhhY3QtZWZmZWN0LWFwcHJvdmFsLzEifSwic2lnbmF0dXJlX2I2NCI6ImxoWVhBQ0hLN1BueXpMVEpYTmxxVlIxdmFGYjJySGZiUmdVTkluSXlWdGF4TUlWOWIxQUd2OXZLWFZ1aUo3MFJ4M1ZycmRwYi0yYjhyRDdoWFVjZERnIn0" + "approval_b64": "eyJyZXF1ZXN0Ijp7ImFwcHJvdmVyIjpbMjMyLDIxOCw5OSwxNjQsMTIsMTY2LDEzNSwyMDAsMTI0LDI1MiwyMjQsOTIsMTc4LDc0LDEyMCwxMDgsMTI2LDExNywyMDQsNzMsMTk5LDEzLDE4MSw4Nyw2MywyLDExMSwyOCwxMDYsMTM0LDIwNiwxNzBdLCJlZmZlY3QiOls2MSwyMjcsNDIsODIsMjgsNzMsMTA5LDEyOCwxNDUsNzEsMTMxLDE5MSwxOTgsMTgzLDIxMywxMzgsMjIzLDk5LDIyNCwxMTQsMTc2LDAsMTIwLDI0LDg4LDE5MSw2OCwxODMsMTU2LDE4Niw4NiwxNjhdLCJleHBpcmVzX2F0IjoxNzkwMDAwMDMwLCJub3RfYmVmb3JlIjoxNzkwMDAwMDAwLCJzY2hlbWEiOiJhdXRocy5leGFjdC1lZmZlY3QtYXBwcm92YWwvMSJ9LCJzaWduYXR1cmVfYjY0IjoiRGFiTjY1azlocWRLTFEwSE5aWHNWZ0ppMGJmT0tyWFZ6aHRpamdRUkFCSFpKNFpqdzIyZ2h3VGVwTEI3SlhVX3JrMjVNR0ZFMUpETlQzOVpLSnBTQ3cifQ" } }, "response": { diff --git a/docs/plans/0074-hosted-evidence-5acd62b0.md b/docs/plans/0074-hosted-evidence-5acd62b0.md new file mode 100644 index 000000000..64ea0f1b7 --- /dev/null +++ b/docs/plans/0074-hosted-evidence-5acd62b0.md @@ -0,0 +1,101 @@ +# AP074 hosted evidence: 5acd62b0 + +Published source `5acd62b0cac44edd80956d7d16eaf15483240a38`, open draft PR213. Non-force publication verified against origin and PR. PR merge producer `4906b8bdef467c6367c35ab9776dbb500a0f03dd`; source and merge both tree `8909ce2164f39f1f87c0427b5f482e253887eb15`. Merge parents: `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b`, source5acd62b0. + +Outgoing commits: aa7cfc76 generated concurrency cohort;5acd62b0 holistic repair plus workspace-anchored cost/history artifacts and source metadata. Previous46989 cohort was fully terminal before publication; no healthy work cancelled/restarted. Prior report `/tmp/ap074-ci-46989-repair-report.md` and snapshot `/tmp/ap074-ci-46989-terminal-checks.json` retain all limitations. + +Current cohort is live, not qualified. Expected PostgreSQL execution is48ordinary native selectors plus2cost and2generated-history selectors. Actual metric/history JSON,22information pairs, restore, SDK platform matrix and authoritative formal gates remain required. Published repository semantic closure `c46116f44bcab92337597ef95fc499dd79488a214584135c60135fb82c44150a`, freeze429 unchanged. + +Run handles: CI41903640319, PG41903640108, Python41903640032, TS41903640364, SDKrecipes41903640292, recipe41903639997, Airtable41903639933, Stripe41903640179, isolation41903640206, operator41903639815, Google reference41903640081, Git41903640142, branch41903640057, custody41903640054 conditionally skipped. Skipped custody/live provider work is no evidence of qualification. + +CI ownership stays isolated in `/tmp/auths-ap074-ci-resumed-20261105`; no main/AP070/AP073 changes. + +## Verified execution checkpoint + +PostgreSQL job126832350307 succeeded through all stages. All52 exact selectors matched actual log once each,1passed/0failed/0ignored:48ordinary+2cost+2generated. Cost test durations file3.17s/PG3.81s; generated file2.02s/PG7.42s. Downloaded ZIPs verified: cost13358744149 SHA256c2f22d2ed1be9a81a6b9491fe06f88e551acb58c271970288c3fd99318e52825; histories13359018734 SHA2562f3572c91035a9cd7a022d489dd38377fb38a278ed417bba3aba49705aef4295; information13359384484 SHA25666ae2f66e06a09d99c338f3e44388b11951f7f02c5d2d64eb80a0c638abda5ee. + +Both cost files retain8samples for each of4paths, actual adapter timing/bytes/callbacks and Linux RSS. Inventory cohorts cover3..17mutation/recovery attempts and2..16acquisition/disclosure attempts, declared4096limit; this is small test-profile measurement, not4096worst-case or production latency. Both generated reports retain4seeds,8positive rounds and one negative pair per seed,72real worker processes/backend,4distinct entries per seed plus baseline. Actual HTTP entries equal independent model and native witness; replay bytes preserved; fresh operation with old approval absent/refused. All cost/history reports bind source5acd, merge4906 and closurec461. + +Information report has22pairs, five matching source hashes and run41903640108 attempt1; its source_commit labels actual merge4906, proven tree-equivalent to5acd. Installed native SDK/reference and physical backup/point-in-time restore both passed. Restore explicitly makes no rollback replay-continuity claim. + +Python source126832350777 passes439tests/11skips, focused extra1test,ruff,strict adapter mypy,public API snapshot/docs. Native mutation28request26response artifact13360215005 ZIP SHA2568087b02580f4e8364aa82ca1c4f970fedc5d2cf8d2b2bef9d6ba1ad9107a9121verified, all7source hashes match. + +Linux isolation126832351540 passed. Artifact13358043624 ZIP SHA2565e0693aa49406acfd3a9a4ed372f8d6c99034f021bcb6e76598c7a5beb9268f0verified: exactsource5acd,33app/12admin/53CLI/5privateCLI, distinctUID, all private/canary/native recipient controls, export0600/1verifiedentry/overwrite refusal. No hostileOS/root or liveprovider claim. + +Whole cohort remains live. No source failure observed at this checkpoint; formal/platform and installeddemo completion still required. + + +## Native cost measurements + +Producer [PostgreSQL41903640108/job126832350307](https://github.com/auths-dev/auths-proof/actions/runs/41903640108/job/126832350307), attempt1. Downloaded artifact13358744149 ZIP SHA256 `c2f22d2ed1be9a81a6b9491fe06f88e551acb58c271970288c3fd99318e52825` verified. Raw files below preserve source5acd, merge4906 and gateway closurec461 identities above. Eight small test-profile fixtures per path per adapter; no production SLO or worst-case claim. + +All duration cells are **minimum / median / maximum milliseconds**, calculated directly from retained integer nanoseconds. Compilation includes native verification. Fenced callback and adapter per-call ranges pool the real execution callbacks/calls across eight samples; adapter totals sum elapsed calls within each execution sample. Adapter duration includes wait/load/decision/persistence/unlock; it is not isolated lock-hold time. Callback duration includes native validation and encoding, with no provider/custody I/O. + +| Backend/path | Verification | Compilation | Exact approval | Execution | Fenced callback, per call | Adapter, per call | Adapter total/sample | +|---|---:|---:|---:|---:|---:|---:|---:| +| file/mutation | 0.682 / 0.759 / 0.790 | 2.389 / 2.461 / 2.524 | 0.186 / 0.187 / 0.204 | 30.973 / 35.151 / 52.722 | 3.701 / 4.471 / 5.377 | 0.012 / 0.022 / 24.431 | 11.935 / 14.936 / 31.409 | +| file/recovery | 0.691 / 0.722 / 0.800 | 6.650 / 6.764 / 6.888 | 0.175 / 0.177 / 0.193 | 62.791 / 63.183 / 82.912 | 7.612 / 10.348 / 18.844 | 0.011 / 0.027 / 19.982 | 33.828 / 34.604 / 44.607 | +| file/acquisition | 0.746 / 0.757 / 0.772 | 3.602 / 3.664 / 3.779 | 0.182 / 0.189 / 0.199 | 47.814 / 54.784 / 65.110 | 5.845 / 7.281 / 9.007 | 0.012 / 0.022 / 15.214 | 18.172 / 18.794 / 25.689 | +| file/disclosure | 0.716 / 0.753 / 0.782 | 3.216 / 3.323 / 3.369 | 0.187 / 0.189 / 0.200 | 68.578 / 70.135 / 102.108 | 10.345 / 14.997 / 20.797 | 0.011 / 0.025 / 36.314 | 33.468 / 34.663 / 58.944 | +| postgres/mutation | 0.733 / 0.767 / 0.941 | 3.255 / 3.374 / 5.180 | 0.186 / 0.194 / 0.214 | 38.226 / 38.814 / 40.923 | 3.705 / 4.496 / 5.337 | 0.363 / 0.449 / 7.956 | 18.008 / 18.683 / 20.254 | +| postgres/recovery | 0.694 / 0.714 / 0.902 | 8.021 / 8.125 / 10.153 | 0.174 / 0.181 / 0.202 | 76.172 / 78.377 / 88.508 | 7.647 / 10.447 / 12.775 | 0.363 / 0.484 / 18.087 | 47.319 / 48.335 / 59.375 | +| postgres/acquisition | 0.731 / 0.769 / 1.950 | 4.489 / 4.547 / 5.954 | 0.182 / 0.185 / 0.206 | 52.586 / 68.293 / 83.657 | 5.900 / 7.351 / 8.877 | 0.325 / 0.454 / 11.710 | 25.783 / 31.355 / 36.357 | +| postgres/disclosure | 0.709 / 0.748 / 0.775 | 4.151 / 4.177 / 4.728 | 0.191 / 0.192 / 0.211 | 77.029 / 78.328 / 85.115 | 10.530 / 14.824 / 21.274 | 0.376 / 0.476 / 24.747 | 41.644 / 42.753 / 45.029 | + +Snapshot bytes/records are maximum observed boundary values across compilation and execution, not allocator totals. RSS is Linux whole-process memory, including runtime/provider; high-water is cumulative for the test cohort, not an independent peak per path. + +| Backend/path | Execution adapter calls / callbacks | Max snapshot bytes | Max snapshot records | RSS KiB min/median/max | Cohort high-water KiB | +|---|---:|---:|---:|---:|---:| +| file/mutation | 88 / 16 | 4529 | 3 | 32984 / 33720.0 / 34048 | 34048 | +| file/recovery | 104 / 24 | 12022 | 18 | 33324 / 33778.0 / 34084 | 34084 | +| file/acquisition | 136 / 16 | 7332 | 4 | 34416 / 34970.0 / 35272 | 35272 | +| file/disclosure | 96 / 16 | 16693 | 5 | 34708 / 35024.0 / 35336 | 35336 | +| postgres/mutation | 88 / 16 | 4529 | 3 | 37860 / 38720.0 / 39036 | 39036 | +| postgres/recovery | 104 / 24 | 12022 | 18 | 38308 / 38786.0 / 39080 | 39080 | +| postgres/acquisition | 136 / 16 | 7332 | 4 | 41240 / 41652.0 / 41952 | 41952 | +| postgres/disclosure | 96 / 16 | 16694 | 5 | 41460 / 41696.0 / 42016 | 42016 | + +| Raw artifact member | SHA256 of archived member | +|---|---| +| native-cost-file.json | `22f49ae6d0071091a0dbf09923440ab875bb64b4ae29a88550e3654c60083df0` | +| native-cost-postgres.json | `777c78520adcc125a83a770e1f332015ed7ad2130ecb250e28aec34e96400842` | + +## Installed demos + +Both source-free installed demo jobs succeeded on5acd. Airtable artifact13360335706 ZIP SHA256 `583802fba557720b70fd3eb98ed419f329eb959428a9823a61db4d8747501686` verified:36simulation cases,private audit13verified/0inconsistent/0unverified; all owner-journey positive controls true, private recipient mode0600, native Python/TypeScript acquisition and independent disclosure/ACK, withheld consent/decline/substitution protection, exact write/read/replay/unknown/fresh-process controls. Browser-simulated authenticated owner and local provider only; human attention, production custody, hostile OS and live provider excluded. + +Stripe artifact13359404577 ZIP SHA256 `b81dde3506490e7c678dbf083bc18b602802b273e3f6db3038843c0631b3fbe0` verified:23simulation cases,private audit6verified/0inconsistent/0unverified. Both artifacts explicitly bind source5acd and production_qualification=false. + +## Actual failure and deferred final-batch repair + +[Authoritative implementation126837641476](https://github.com/auths-dev/auths-proof/actions/runs/41903640319/job/126837641476) failed the gateway library suite:290passed,5failed,59ignored. All five failures are native golden-byte comparisons, not refusals/assertions weakened by this triage. Dependent authoritative rollup126843264528 reflects implementation failure. + +Hosted assertion arrays were decoded read-only for forensic field comparison; retained fixture is the LEFT side, newly generated bytes the RIGHT. Files in `/tmp/ap074-ci-5acd-native_*-{retained-left,generated-right}.json` are forensic only and must not be copied into the repository as substitutes for authoritative generators. Shared root:7807 changed `observed_tests::outcome_requirement` from outcome/2 and commitment to outcome/3 and effect-reference. `NativeAuthority::verified` commits normalized installed trust, so the new context propagates to native_authority, effect IDs, approval signatures and source-linked recovery contracts. Candidate/content changes are only authority commitment and dependent identifiers. Prerequisite changes also include the dependent request commitment. Recovery source/action/projection changes follow the new source effect; reservation sorting changes with derived keys, while both unit/amount/ceiling/window tuples remain unchanged: acquisition-count1/16source-lifetime and response-bytes16384/262144source-lifetime. + +The five constructors below fan out to14fixture files (later comparisons were unreachable after first mismatch): content-compilation.json; effect-binding.json,effect-policy.json,effect-approval-request.json,effect-approval.json; recovery-compilation.json,recovery-entry.json,recovery-policy-budgets.json,recovery-refinement.json; prerequisite-compilation.json,prerequisite-entry.json; candidate-compilation.json,candidate-journal.json,candidate-staging.json. Preserve every negative/positive assertion and native identity binding. + +At the user's instruction, NO new local test/reproduction/generator run or hosted rerun was started. Authoritative regeneration and verification are deferred until the complete implementation batch is coded. For that final phase only, each exact selector uses `AUTHS_UPDATE_FIXTURES=1 cargo test --locked -p auths-gateway --features loopback-provider,testkit-harness --lib -- --exact SELECTOR`: + +- observed_tests::effect_native_tests::content_tests::native_content_compilation_fixture_is_current +- observed_tests::effect_native_tests::native_compilation_approval_and_reverification_keep_exact_request +- observed_tests::effect_native_tests::native_recovery_acquisition_fixture_is_current +- observed_tests::effect_native_tests::prerequisite_tests::native_prerequisite_compilation_fixture_is_current +- observed_tests::effect_native_tests::candidate_tests::native_candidate_compilation_fixture_is_current + +Then review all generated differences, regenerate required source/release metadata and perform the coordinated final checks. No new publication is authorized until parent coordinates complete-batch readiness. + +## Platform capacity limitation + +Installed CPython3.13 macOS job126837943621 and3.14 macOS job126837943795 were cancelled with zero steps. GitHub annotations explicitly report hosted runner acquisition failure after multiple attempts and macOS arm64 capacity limits. These are infrastructure casualties, not test success or a source defect. No rerun initiated and coverage remains mandatory in the final batch. All other completed platform jobs are retained; formal translation is still running at this checkpoint. + +## Final terminal result + +The superseded5acd cohort is terminal:96checks,80success,2failure,6cancelled,8conditional skips. The only source failure is the five native golden constructors described above, plus authoritative rollup126843264528. Parent reports their14transitive outputs were regenerated through native constructors in the completed977ae61f batch; that changed head requires its own hosted verification. + +Two cancellations are macOS3.13/3.14runner-acquisition failures with zero steps. The other four are authoritative Lean126858353087, formal evidence126869045258, formal-translation rollup126869048360 and CI-qualified126869048259. Lean was still running when the completed977ae61f head was published, then this superseded cohort was cancelled. No completed authoritative Lean/final formal qualification is claimed for5acd. This CI agent did not cancel/restart any job or publish the new977head. + +Fresh pinned translation126837641240 did complete successfully: two byte-identical reproductions, production closure5c243bbe3196b6f20772b2d90b397ae43d7545312f1fe07a3b05be795fa471e9, generated artifacts c09f533647b96a11cf4bc6b5afad4c6dc326913d1b36cb00437e690ea505c367. This was executed, not reused. Kani126837641513 completed all49harnesses (5+2+7+7+8+20), zero failures. Formal-fast126834539925 completed successfully; feedback evidence is distinct from authoritative Lean. + +Downloaded/verified formal ZIPs: translation qualification13361779128 SHA256f8c0c30d91c7067672b1e5c15f92bc259a684ce19b2cdeb2127ceb81202a0c44; translation phase13362601795 SHA2561e7e897b9c2e1464a6b0045e35d949e7ac2ccd47632e58704e99bc4720499989; Kani phase13362140373 SHA25669847b3f289d075a325a494b8e60ef93b194fed8579d10a6b9e8dca505d3acee; proof-fast13361690575 SHA256b0b3c41d00d0465bde9c201dd263a23771835e24af37f92dbeca3481ca664c7e. Phase manifests bind exact5acd source/run41903640319 attempt1, toolchain closurebaff1cabbf9c83ffca0f4bdb1b8dda685a5ac59638e95d6d12e57f5d5bda9633 and lock0c45a8a08ac06e313d775e669749097bd3a0abfb8e3395c69416ba0238770d53. + +Final raw check snapshot: /tmp/ap074-ci-5acd-final-checks.json. Whole specification acceptance remains dependent on completed-source977ae61f hosted evidence; partial passes and conditional skips are not a waiver. diff --git a/docs/plans/0074-hosted-evidence-977ae61f.md b/docs/plans/0074-hosted-evidence-977ae61f.md new file mode 100644 index 000000000..649f69e59 --- /dev/null +++ b/docs/plans/0074-hosted-evidence-977ae61f.md @@ -0,0 +1,51 @@ +# AP074 hosted evidence and repair batch: 977ae61f + +Published source `977ae61f568ea1144d2f8788280bb98f3dbacd55`; PR merge producer `9ae68069aabedbb48cb84e35f79d4e28c33bb435`. Both verified tree `f071d85c7de4f76411db90dec6d7be68f6f5fa2d`; merge parents e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b and source977ae61f. Main published the completed batch; this CI agent does not claim publication of this head. + +Read `docs/plans/0074-final-acceptance-audit.md`, `0074-final-coding-checklist.md` and updated AGENTS.md batching policy. Native closure6313af76a8be501ada02f126b5d30713d5baffe49704066b11cd95e59596c159; freeze431/identity172/publicSDK168/surface431. Expected PG exact execution is61 selectors:48ordinary,9final-hardening,2cost,2generated-history. Count the9heredoc selectors separately from shell --exact "$selector". Existing library ignored tests do not establish these passes. + +Current14workflow handles: CI41914022680, PG41914023238, Python41914022972, TS41914022951, SDKrecipes41914022783, recipe41914022949, Airtable41914022598, Stripe41914022922, isolation41914023196, operator41914022762, Google reference41914022851, Git41914022750, branch41914022619, custody41914022898conditionally skipped. Final qualification remains pending. + +No new local tests/reproductions or workflow reruns during initial triage. Collect all actual roots, complete coherent repairs and only then run the affected batch; no piecemeal verification or weakened assertions/deadlines/platforms. AP070/AP073 untouched, main checkout untouched. + +## Confirmed repair roots and execution limits + +The PostgreSQL lifecycle job [126868788825](https://github.com/auths-dev/auths-proof/actions/runs/41914023238/job/126868788825) and recipe simulation job [126868788411](https://github.com/auths-dev/auths-proof/actions/runs/41914022949/job/126868788411) expose two root causes. The new review-approval test module imports feature-gated `harness::authoring` without its own matching feature guard, breaking ordinary/loopback-only library test builds. The final-hardening runner additionally requires an unavailable `rg` executable after every successful native selector. Authored repairs guard the module, retain its execution as a new explicit harness-enabled review selector, preserve the exact one-pass/no-ignore assertion through portable `grep -Fq`, and expose rendered Cargo compiler diagnostics before the qualification build fails. No native assertion or coverage is removed. Repair validation has not started while the cohort is still exposing independent roots. + +Retained PostgreSQL artifact 13365141010 has verified ZIP SHA-256 `99fff0461d934d43cd18f76beb8442eb2a04927a48adc0e4044fa23b9e3b13ce`. It contains the native log only: all 48 ordinary required native selectors executed exactly once with one pass and zero failed/ignored; the separate production-process connection test also passed. The final-hardening artifact 13363718099 has verified ZIP SHA-256 `3355e513ea52617b5eb2c38d724bc6d7b2da51c47095159ff332ed4d847e428a`: all nine required native selectors likewise passed once without ignores. Their shell postchecks failed solely because `rg` was absent. The cost, generated-history, independent information comparison and backup/restore stages were skipped downstream; their execution is not established on this head. The repaired inventory will add the review and operation-revision-limit selectors, becoming 48 ordinary + 11 hardening + 2 cost + 2 generated = 63 explicit native selectors. + +## Verified retained successes so far + +The independently compared mutation artifact 13364970704 has ZIP SHA-256 `a87ff2a8c25c6241f17c7ea40b3330bbbcd7616e5f0a4d4f26dd744f7707e4bc`; all seven source hashes match this published checkout. Its unchanged contract remains 28 request and 26 response comparisons. + +The actual distinct-UID Linux artifact 13364741168 has ZIP SHA-256 `2ae4f17ad88620937c8b1e0a47b7ca4e0c870f606b999a919e8288e5a150628b` and source977ae61f. It records 33 application cases, 12 admin commands, 53 CLI routes and five private CLI refusals; 45 initial/49 replay private files are inaccessible. Source journal bytes are preserved, unauthorized direct-provider requests return401, recipient UID/key guards and trusted positive control hold, public channels exclude plaintext/encoding/raw-digest canaries, and private export is0600 with one verified audit entry and overwrite refusal. + +Stripe installed evidence artifact13364616512 has ZIP SHA-256 `ac6288adff74707b8852a07c4fea830231681bbbb7fe6ae604db938597b7ee50`, source977ae61f,23 simulation cases, six verified private audit entries and zero inconsistent/unverified entries. Production qualification is false; this is installed simulation evidence, not live-provider/human-attention qualification. + +Airtable installed artifact13364786785 has verified ZIP SHA-256 `69c328abc9a431a34cb6654404a17f4b36f81b71c474bb459e9ea3974b15a495`, source977ae61f. It retains36 simulation cases and13 verified private-audit entries with zero inconsistent/unverified entries. The separate source-free owner browser report has every positive assertion true: unchanged native renderer, approvals withheld until consent, decline/substitution refusal, private owner credentials isolated, one exact write and independent read, installed Python/TypeScript acquisition, separately consented native disclosure with retained recipient ACK, no public HTTP private content, no replay redelivery, same actor read/disclosure/write, unknown response loss without reentry and fresh-process replay without new consent/execution. Production qualification and independent-human-trial remain false. + +Formal translation job126874540607 passed using validated same-PR reuse from source5acd62b0, run41903640319 attempt1; it is not a new translation reproduction. Current retained phase artifact13364504382 ZIP SHA-256 `e8a6d15494faebafecbfba0ad7773db50dedf9231c6e3620dee745c2727fc8b7` explicitly records current source977/run41914022680/attempt1 and `execution=reused-pr-run`. Qualification artifact13364957697 ZIP SHA-256 `6c0a539386ccc7d5219ffd45aa9c0bab98ff338203260e33a43df1bbaf0482c2` preserves production closure `5c243bbe3196b6f20772b2d90b397ae43d7545312f1fe07a3b05be795fa471e9` and generated-artifact hash `c09f533647b96a11cf4bc6b5afad4c6dc326913d1b36cb00437e690ea505c367`. The matching translated closure permits reuse; separate authoritative Lean/final evidence remains required. + +## Authoritative transitive fixture failure + +Authoritative implementation job [126874540692](https://github.com/auths-dev/auths-proof/actions/runs/41914022680/job/126874540692) reached the complete gateway library: **301 passed, zero failed,63 ignored** in62.39s. This clears the earlier broad-run file-store conformance concern for published977 without changing its deadline or assertion. Separately required ignored native cases remain evidenced only by their explicit producer runs. + +The workspace then failed `native_application_content_cli_fixture_is_current` at application_content_cli.rs:130. Offline decoding of the actual hosted assertion arrays establishes exactly one differing JSON leaf: `cases[0].request.submission.approval_b64`. Both actual captured CLI request and response equality assertions passed. The real frame corpus had been regenerated for native authority changes, but its downstream CLI golden still carried the previous approval. A search across every tracked file found the old exact approval in only two remaining consumers: `application-content-cli.json` and `application-recovery-cli.json`; both differ from their respective frame corpus only in this approval field. Repair regenerates both through their existing production-CLI/real-Unix-socket constructors, not by copying assertion bytes. No proof, approval, framing, response or fixture assertion is relaxed. The authoritative rollup failure is derivative of this root. + +The parent correction909193d6 (amended fromf659217c, identical code/artifacts) enforces the declared64operation-revision limit and corrects bound-table/spec language. The combined repair preserves it and explicitly requires `store::operation_revision_limit_preserves_last_event_without_wrap_or_restart` alongside the18-case review selector. Current release identities remain freeze431 unless the combined native generator requires a change. + +## Focused repair verification + +All three root causes are repaired together, with parent909193d6's revision bound preserved. Local failed-check reproductions and required artifact construction were completed after the corresponding batch was authored: + +- `cargo test --locked -p auths-gateway --lib --no-run`: passed20.80s. +- `cargo test --locked -p auths-gateway --features loopback-provider --lib --no-run --message-format=json`: passed19.96s, preserving the qualification packer's structured build report. +- Harness-enabled exact review and revision-bound tests: one passed/zero failed/zero ignored each. Review command took24.58s including build; revision command0.54s. +- Native semantic-closure update and rebuilt unchanged check: one passed/zero failed/zero ignored each. Final closure `61173a0020911d7fb40fe9870a81b9b19a3641b1f5c406c0eeb9b9db3a3b88aa`. +- `AUTHS_UPDATE_FIXTURES=1 cargo test --locked -p auths-gateway --all-features --test application_content_cli --test application_recovery_cli`: both constructors passed, total16.50s including build. Same command without update passed both in1.01s. Structural comparison confirms each generated golden changes only the stale approval packet. +- Both changed workflow shell bodies pass `bash -n`. The portable success assertion accepts all nine actual retained hardening logs and rejects absent, failed and zero-pass/ignored evidence. +- `cargo fmt --all` and `git diff --check` passed. Final `cargo xtask semantic-freeze --update` passed4.50s without changing any release counter or inventory; freeze431 remains. + +Logs and machine-readable local results: `/tmp/ap074-ci-977-verification`. These focused results do not replace the required next-head hosted workspace, formal, SDK, installed and PostgreSQL gates. No broad suite was redundantly rerun locally, no workflow restarted, and no time bound, assertion or platform coverage was weakened. + +At2026-11-04 21:38UTC, the observed cohort has77 successful,4 failed (three implementation jobs plus authoritative rollup),8 skipped and2 in-progress check records. Kani and formal-fast are still live; dependent authoritative Lean/final formal checks are not yet established. This section is a checkpoint, not a terminal all-green claim. Publication is held to preserve healthy formal work. The current-head cost/generated/info/restore gaps and three repaired root causes must be verified on the combined next head. diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 7f1c58a3f..8386d6aec 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"ca1d7950bc766de53b021bc25613fd7ae428898198e34e654f5ed04ee549468a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"dd0821e8337e56189708496ca85cc2f2da2d6a4ea8b53db5aa0412beead69864"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"d803ff53f90ce2a8c29808b4f874cd81954a3a5c52e19b519ab22f0543808fe1"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"181bf0a196805e50944cff4fe2315459eba877e7d7b5b90bf3c99e3353a8cad7"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"fdf746572649f554f24089d0dd6322d964be1c12d1695dd5d9f8d86079b23a82"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"87363b666c16cef5f4566db25b3cbec93f3083b2bf8508a5c55ce78667bc4a6c"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"cf7263f6b3d5f5749a76d970f0c73d3a0410832ac8f47d8770b4a4754928f21a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"dd0821e8337e56189708496ca85cc2f2da2d6a4ea8b53db5aa0412beead69864"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"d803ff53f90ce2a8c29808b4f874cd81954a3a5c52e19b519ab22f0543808fe1"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"181bf0a196805e50944cff4fe2315459eba877e7d7b5b90bf3c99e3353a8cad7"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"fdf746572649f554f24089d0dd6322d964be1c12d1695dd5d9f8d86079b23a82"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"87363b666c16cef5f4566db25b3cbec93f3083b2bf8508a5c55ce78667bc4a6c"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/effect_native_tests.rs b/product/runtime/auths-gateway/src/effect_native_tests.rs index 8414ecc9e..da2fb2af9 100644 --- a/product/runtime/auths-gateway/src/effect_native_tests.rs +++ b/product/runtime/auths-gateway/src/effect_native_tests.rs @@ -32,6 +32,7 @@ mod read_budget_tests; mod binding_boundary_tests; #[path = "effect_recovery_prerequisite_tests.rs"] mod recovery_prerequisite_tests; +#[cfg(feature = "testkit-harness")] #[path = "effect_review_approval_tests.rs"] mod review_approval_tests; diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index d73af08b9..316070f31 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "71ff1dcdd7464474a0d1b12f661f7277d665775a6a192128bbbc5870ff9231eb"; + "61173a0020911d7fb40fe9870a81b9b19a3641b1f5c406c0eeb9b9db3a3b88aa"; #[cfg(test)] mod tests { From ee7975be5efe8ba93a62570a67b660b816b7ac45 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 4 Nov 2026 22:04:00 +0000 Subject: [PATCH 130/136] chore(formal): regenerate qualification artifacts Source-SHA: 977ae61f568ea1144d2f8788280bb98f3dbacd55 Workflow-Run: 41914022680 --- formal/assurance-manifest-v1.toml | 118 +++++++++++++++--------------- 1 file changed, 59 insertions(+), 59 deletions(-) diff --git a/formal/assurance-manifest-v1.toml b/formal/assurance-manifest-v1.toml index b34c2d9e1..14f263628 100644 --- a/formal/assurance-manifest-v1.toml +++ b/formal/assurance-manifest-v1.toml @@ -8733,7 +8733,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-055" @@ -8854,7 +8854,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-056" @@ -8989,7 +8989,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-104" @@ -10463,7 +10463,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-263" @@ -10559,7 +10559,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-264" @@ -10658,7 +10658,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-186" @@ -10918,7 +10918,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-237" @@ -11014,7 +11014,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-238" @@ -11113,7 +11113,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-175" @@ -15601,7 +15601,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-211" @@ -15696,7 +15696,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-212" @@ -15792,7 +15792,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-213" @@ -15888,7 +15888,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-214" @@ -15984,7 +15984,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-232" @@ -16083,7 +16083,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-233" @@ -16179,7 +16179,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-234" @@ -16275,7 +16275,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-235" @@ -16371,7 +16371,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-249" @@ -17038,7 +17038,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-257" @@ -17137,7 +17137,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-258" @@ -17236,7 +17236,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-259" @@ -17332,7 +17332,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-260" @@ -17431,7 +17431,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-070" @@ -24429,7 +24429,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-189" @@ -24525,7 +24525,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-190" @@ -24621,7 +24621,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-191" @@ -24717,7 +24717,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-192" @@ -24812,7 +24812,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-193" @@ -24911,7 +24911,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-194" @@ -25010,7 +25010,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-195" @@ -25111,7 +25111,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-196" @@ -25215,7 +25215,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-197" @@ -25320,7 +25320,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-198" @@ -25416,7 +25416,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-199" @@ -25521,7 +25521,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-200" @@ -25616,7 +25616,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-201" @@ -25711,7 +25711,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-271" @@ -25807,7 +25807,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-272" @@ -25903,7 +25903,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-273" @@ -26002,7 +26002,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-274" @@ -26101,7 +26101,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-275" @@ -26202,7 +26202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-276" @@ -26302,7 +26302,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-277" @@ -26401,7 +26401,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-278" @@ -26501,7 +26501,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-279" @@ -26600,7 +26600,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-280" @@ -26701,7 +26701,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-281" @@ -26801,7 +26801,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-282" @@ -26901,7 +26901,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-283" @@ -27001,7 +27001,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-284" @@ -27100,7 +27100,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-285" @@ -27202,7 +27202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-306" @@ -27298,7 +27298,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-307" @@ -27397,7 +27397,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-308" @@ -27493,7 +27493,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-309" @@ -27592,7 +27592,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-310" @@ -27692,7 +27692,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-311" @@ -27791,7 +27791,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" [[claims]] claim_id = "AP-FORMAL-RICH-312" @@ -27892,4 +27892,4 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "c5bd79140d3b3b79a6113d73f00e426a130b8eb8de5f45126deac80a1d30b9b8" +sha256 = "1b923e6c0d5c99cf7892e4bd6e3d736339a1edddb6193cb208fa75d13d99828d" From 20b7610b13c540d2501a202b1c5d06d98aa8d337 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 07:19:33 +0900 Subject: [PATCH 131/136] fix(ci): scope Lean producer discovery before bounding runs --- .github/ci/README.md | 3 ++- .github/scripts/reuse-formal-lean.py | 3 ++- .github/scripts/test_reuse_formal_lean.py | 17 ++++++++++++++++- docs/plans/0074-lean-reuse-contract.md | 16 ++++++++++++++++ 4 files changed, 36 insertions(+), 3 deletions(-) diff --git a/.github/ci/README.md b/.github/ci/README.md index d823e714b..f3f9a5f0f 100644 --- a/.github/ci/README.md +++ b/.github/ci/README.md @@ -113,6 +113,7 @@ Kani remains a separate current-head gate; it is not skipped by Lean reuse. Legacy records lack the complete-input field and are intentionally ineligible. The initial rollout therefore requires fresh verification. Later unchanged-input follow-ups can use that successful producer. The search is bounded to ten of the -latest fifty same-branch PR runs and one hundred artifacts/jobs per candidate; +latest fifty same-branch PR runs of this exact CI workflow (other workflows do +not consume that bound) and one hundred artifacts/jobs per candidate; no eligible retained producer means another fresh run. This availability limit never converts missing proof evidence into a passing skipped gate. diff --git a/.github/scripts/reuse-formal-lean.py b/.github/scripts/reuse-formal-lean.py index 42e95ac5b..d35d6fd32 100644 --- a/.github/scripts/reuse-formal-lean.py +++ b/.github/scripts/reuse-formal-lean.py @@ -133,6 +133,7 @@ def discover(environment, api=gh, verify=verify_current): current = api(f"repos/{repo}/actions/runs/{current_id}") if ( current["id"] != current_id + or not positive(current["workflow_id"]) or current["event"] != "pull_request" or current["path"] != WORKFLOW or current["repository"]["full_name"] != repo @@ -141,7 +142,7 @@ def discover(environment, api=gh, verify=verify_current): ): return False query = urlencode({"branch": current["head_branch"], "event": "pull_request", "per_page": 50}) - runs = api(f"repos/{repo}/actions/runs?{query}")["workflow_runs"] + runs = api(f"repos/{repo}/actions/workflows/{current['workflow_id']}/runs?{query}")["workflow_runs"] for run in runs[:10]: try: if not trusted_run(run, current, number): diff --git a/.github/scripts/test_reuse_formal_lean.py b/.github/scripts/test_reuse_formal_lean.py index ecebdf45b..816c64a07 100644 --- a/.github/scripts/test_reuse_formal_lean.py +++ b/.github/scripts/test_reuse_formal_lean.py @@ -63,13 +63,17 @@ def __init__(self): self.verified = [] self.accept = True self.tamper_archive = False + self.workflow_runs = [self.current, self.run] def api(self, path, archive=False): self.calls.append(path) if path.endswith("/runs/100"): return self.current + if "/actions/workflows/4/runs?" in path: + return {"workflow_runs": self.workflow_runs} if "/actions/runs?" in path: - return {"workflow_runs": [self.run]} + # A real push creates14 unrelated workflows ahead of any prior CI. + return {"workflow_runs": [dict(self.current, workflow_id=5)] * 14 + [self.run]} raw = self.raw if self.raw is not None else json.dumps(self.phase) data = zipped(raw, self.member) self.artifact.setdefault("digest", "sha256:" + hashlib.sha256(data).hexdigest()) @@ -103,6 +107,17 @@ def test_success_preserves_actual_producer_attempt_and_artifact(self): self.assertEqual(producer["AUTHS_REUSED_ARTIFACT_ID"], "88") self.assertIn("/attempts/1/jobs?per_page=100", " ".join(fixture.calls)) + def test_discovery_queries_only_the_current_workflow_before_bounding(self): + fixture = Evidence() + self.assertTrue(fixture.discover()) + self.assertIn("repos/owner/repo/actions/workflows/4/runs?branch=feature&event=pull_request&per_page=50", fixture.calls) + self.assertFalse(any("/actions/runs?" in path for path in fixture.calls)) + # The tenth CI run is reachable; the eleventh is a bounded cold miss. + fixture = Evidence(); fixture.workflow_runs = [fixture.current] * 9 + [fixture.run] + self.assertTrue(fixture.discover()) + fixture = Evidence(); fixture.workflow_runs = [fixture.current] * 10 + [fixture.run] + self.assertFalse(fixture.discover()); self.assertFalse(fixture.verified) + def test_untrusted_or_different_run_is_ineligible(self): changes = [ ("id", 100), ("workflow_id", 5), ("path", "other.yml"), diff --git a/docs/plans/0074-lean-reuse-contract.md b/docs/plans/0074-lean-reuse-contract.md index 6a71e85bd..5e9e93a39 100644 --- a/docs/plans/0074-lean-reuse-contract.md +++ b/docs/plans/0074-lean-reuse-contract.md @@ -50,3 +50,19 @@ source citations and preserved the entire remaining typed assurance structure. Release inventory requires freeze432, assurance bytes62, source-closure bytes107, evolution85 and public surface432; other identities remain unchanged. Hosted fresh bootstrap and a subsequent genuine warm hit remain required evidence. + +A post-publication read of actual GitHub discovery metadata exposed a bounded +lookup defect: each push creates14 workflows, so the first ten repository-wide +runs contained only the current head. This safely fell back to fresh Lean but +could prevent every warm hit. Discovery now queries the current CI workflow ID +before applying the ten-candidate limit. Regression controls reproduce the14 +unrelated runs, prove the exact endpoint, and preserve the tenth/eleventh +candidate boundary. This controller correction invalidates the initial proof key; +the corrected head, rather than f5e9, must establish the fresh bootstrap. + +The complete lookup correction passed all10 offline provenance tests; the native +metadata constructor passed with zero citation changes and byte-identical release +inventory. The actual workflow-scoped GitHub endpoint returns current f5e9, +previous ee797 and original977 CI runs, unlike the repository-wide first ten. +No early f5e9 failed check was observed before this correction. Real bootstrap +and warm-hit results remain pending; no hosted proof success is inferred. From eb44d8f7082db6ed9ab46c1bf5319e8e736d7b28 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 07:23:18 +0900 Subject: [PATCH 132/136] fix(ci): bind Lean provenance to immutable producer revisions --- .github/ci/README.md | 5 +++++ .github/scripts/reuse-formal-lean.py | 3 ++- .github/scripts/test_reuse_formal_lean.py | 13 +++++++++++++ docs/plans/0074-lean-reuse-contract.md | 18 ++++++++++++++++++ 4 files changed, 38 insertions(+), 1 deletion(-) diff --git a/.github/ci/README.md b/.github/ci/README.md index f3f9a5f0f..d2fd5579a 100644 --- a/.github/ci/README.md +++ b/.github/ci/README.md @@ -117,3 +117,8 @@ latest fifty same-branch PR runs of this exact CI workflow (other workflows do not consume that bound) and one hundred artifacts/jobs per candidate; no eligible retained producer means another fresh run. This availability limit never converts missing proof evidence into a passing skipped gate. + +GitHub's run-associated PR object contains a mutable current head snapshot. It +establishes PR/repository membership, not the historical source SHA. The immutable +run, exact-attempt successful job, artifact metadata and phase record must all +agree on the producer source; changing any one remains a cold miss. diff --git a/.github/scripts/reuse-formal-lean.py b/.github/scripts/reuse-formal-lean.py index d35d6fd32..da5264e16 100644 --- a/.github/scripts/reuse-formal-lean.py +++ b/.github/scripts/reuse-formal-lean.py @@ -64,11 +64,12 @@ def trusted_run(run, current, number): and run["head_repository"]["full_name"] == repo["full_name"] and run["head_branch"] == current["head_branch"] and hexadecimal(run["head_sha"], 40) + # GitHub keeps this PR association but updates its head snapshot. + # Historical source identity comes from the run/job/artifact/phase. and any( pr["number"] == number and pr["base"]["repo"]["id"] == repo["id"] and pr["head"]["repo"]["id"] == repo["id"] - and pr["head"]["sha"] == run["head_sha"] for pr in run["pull_requests"] ) ) diff --git a/.github/scripts/test_reuse_formal_lean.py b/.github/scripts/test_reuse_formal_lean.py index 816c64a07..6d62eee0d 100644 --- a/.github/scripts/test_reuse_formal_lean.py +++ b/.github/scripts/test_reuse_formal_lean.py @@ -118,6 +118,19 @@ def test_discovery_queries_only_the_current_workflow_before_bounding(self): fixture = Evidence(); fixture.workflow_runs = [fixture.current] * 10 + [fixture.run] self.assertFalse(fixture.discover()); self.assertFalse(fixture.verified) + def test_current_pr_snapshot_does_not_replace_immutable_producer_revision(self): + fixture = Evidence() + fixture.run["pull_requests"][0]["head"]["sha"] = "e" * 40 + self.assertTrue(fixture.discover()) + self.assertEqual(fixture.verified[0][1]["AUTHS_REUSED_HEAD_SHA"], "d" * 40) + for owner in ["run", "job", "artifact", "phase"]: + with self.subTest(owner=owner): + fixture = Evidence() + fixture.run["pull_requests"][0]["head"]["sha"] = "e" * 40 + target = fixture.artifact["workflow_run"] if owner == "artifact" else getattr(fixture, owner) + target["head_sha"] = "e" * 40 + self.assertFalse(fixture.discover()); self.assertFalse(fixture.verified) + def test_untrusted_or_different_run_is_ineligible(self): changes = [ ("id", 100), ("workflow_id", 5), ("path", "other.yml"), diff --git a/docs/plans/0074-lean-reuse-contract.md b/docs/plans/0074-lean-reuse-contract.md index 5e9e93a39..c8d7a4301 100644 --- a/docs/plans/0074-lean-reuse-contract.md +++ b/docs/plans/0074-lean-reuse-contract.md @@ -66,3 +66,21 @@ inventory. The actual workflow-scoped GitHub endpoint returns current f5e9, previous ee797 and original977 CI runs, unlike the repository-wide first ten. No early f5e9 failed check was observed before this correction. Real bootstrap and warm-hit results remain pending; no hosted proof success is inferred. + +The requested audit against actual retained GitHub metadata found that a run's +associated PR object updates its head SHA when the PR advances. Successfulce9 +run40899439849 and original977 now show the current20b PR snapshot. Historical +identity instead matches across the immutable run, successful exact-attempt +job123552204257, artifact12910849462 and its single lean.json member. Its verified +ZIP SHA-256 is94562f1057bddcaae2aae0be22adc645c39830f498a72cf9a62c1057fb629cd1. +The PR association still validates the number and both repository identities; +only its mutable snapshot is excluded from historical source comparison. Tests +accept this observed shape while refusing any mismatched immutable source field. +The oldce9 record still lacks complete attestation and cannot qualify reuse. + +The complete metadata correction passed all11 provenance tests and the metadata +constructor with no generated changes. Running the corrected transport against +the retained actualce9 run accepts its same-PR association, then explicitly rejects +its old phase for missing complete-input attestation. No native validator or +qualified result was invoked or synthesized for that legacy artifact. No early20b +failed check was observed before this correction. From 91b397e7e2a2ba6e8dbd0d7b1ee9ec78ebfbbf4f Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 08:02:04 +0900 Subject: [PATCH 133/136] docs(ap074): reconcile executed acceptance and final verification gates --- docs/plans/0074-final-acceptance-audit.md | 43 +++++++++++-- docs/plans/0074-final-coding-checklist.md | 9 +++ docs/plans/0074-implementation-status.md | 73 +++++++++++++++++++---- 3 files changed, 109 insertions(+), 16 deletions(-) diff --git a/docs/plans/0074-final-acceptance-audit.md b/docs/plans/0074-final-acceptance-audit.md index 869dd4134..7ce87a192 100644 --- a/docs/plans/0074-final-acceptance-audit.md +++ b/docs/plans/0074-final-acceptance-audit.md @@ -3,9 +3,12 @@ This is the current requirement-to-producer map, superseding stale outstanding work descriptions in historical checkpoints. It does not supersede the spec, remove a test or establish that authored checks passed. The final coding batch -is implemented and its artifacts are constructed; exact-head hosted verification -is pending. Every row -below therefore remains **unverified on the completed revision**. +is implemented and its artifacts are constructed. Hosted source +`eb44d8f7082db6ed9ab46c1bf5319e8e736d7b28` has actual native adapter, +installed, containment, differential and cost evidence. Its broad implementation +gate exposed two obsolete committed fuzz seeds; the native-generator repair is +constructed and awaits hosted confirmation. Formal qualification and the final +repaired revision's applicable gates remain open. **This is not completion.** Native test files below are in `product/runtime/auths-gateway/src/`. The PostgreSQL lifecycle workflow explicitly runs both durable adapters, including @@ -13,6 +16,32 @@ ignored PostgreSQL selectors, and retains real execution logs. A selector must execute once with one pass and zero ignored; a skipped or zero-match invocation is not evidence. Application-owned AP070 remains independent. AP073 is untouched. +## Current executed evidence and remaining gates + +The [hosted evidence report](0074-hosted-evidence-eb44d8f7.md) preserves exact +source, merge producer, tree, closures, authenticated artifact hashes and limits. +Source `eb44d8f7` and tested merge producer `8335af6a` share tree +`195e1ae19c0491af1c7e8fdd6d0c63b87655fe89`. Neither may be relabeled as the +subsequent repaired head. + +| Requirements | Actual evidence on source eb44d8f7 | Remaining acceptance gate | +| --- | --- | --- | +| P0/P1, E01–E05 | Native owner/consumer and canonical binding/review implementation; installed exact review, consent, request and disclosure controls; signed binding/review corpora execute in the required cohort | Final source/architecture/compliance and repaired-head confirmation | +| P2/P3, R01–R10, A01–A17/A21 | All 63 required native selectors execute exactly once with one pass and zero failures/ignored tests on file and TLS PostgreSQL; process, capacity, crash, partial-upload, ambiguous-commit, epoch/floor, recovery, ACK and 64-event cases | Final broad repaired-head gate and conditional formal/runtime audit | +| A18 | Native journal/frame/binding limits and shared 209-vector binding corpus execute; broad gateway library passes 302 tests, zero failures and 63 ignored tests separately covered by the required adapter cohort | Two stale positive fuzz seeds require native-constructor repair, obsolete refusal controls and repaired hosted corpus confirmation | +| A19 | Two mutation recipes: 28 request and 26 response comparisons; acquisition/disclosure: 22 pairs after eight named native histories; all 12 reference source hashes match | Repaired-head confirmation with references still independent | +| A20 | Four-seed concurrent histories per adapter: 32 positive and four negative rounds, 72 workers, independent HTTP/transport-count and historical-byte oracles | Clean source-linked Lean/329-claim audit, translation, Kani49 and applicable formal/release adequacy gates; final consumer qualification | +| A22 | Installed Airtable: 36 cases/13 verified private audits; Stripe: 23/6, zero inconsistent/unverified. Linux distinct-UID: 33 application cases, 12 admin commands, 53 CLI routes, five private CLI refusals and actual credential/provider/file/privacy controls | Final repaired-head installed/platform confirmation | +| P4 cost and bounded work | Eight samples per path/backend with actual verification, compilation, approval, callback, adapter, inventory, snapshot-size and Linux RSS distributions | Preserve actual producer and limits; these fixtures establish no production latency or heap SLO | +| Lean reuse | Complete-input/provenance refusal controls; fresh fast Lean bootstrap passed | Clean authoritative producer, then observed reuse by both Lean jobs while current Rust/source checks still run | + +All twelve applicable workflows outside main CI passed on this source. The +conditional live-custody workflow was skipped and provides no live qualification. +The failed implementation job and derivative rollup remain failures until the +complete corpus repair passes; narrow local repair results do not replace the +hosted gate. Completion still requires every row below and every applicable +final-head gate. + ## Architecture and phase deliverables | Requirement | Authoritative implementation/deliverable | Required closure evidence | @@ -109,8 +138,12 @@ requires the maintained TLS/transaction configuration and participating writers. SIGKILL and modeled syscall faults do not prove power-loss behavior. The partial upload test observes application-level prefix delivery, not kernel backpressure or provider atomicity. Generation rollback detection requires independently -retained floors; restoring the whole store and every anchor together remains -unsupported. Browser automation proves the authenticated owner protocol and UI +retained floors and protects only the state those floors bind. An unchanged +connection floor does not anchor rolled-back attempt/accounting rows. Physical +WAL restore establishes before-target retention and after-target exclusion and +explicitly reports `replay_continuity=false`. Whole-journal rollback and safe +automatic managed resumption after arbitrary point-in-time restore are outside +the guarantee. Browser automation proves the authenticated owner protocol and UI controls, not human attention. Local recipe/custody fixtures do not qualify a live provider. These are explicit premises, not excuses to omit acceptance tests. diff --git a/docs/plans/0074-final-coding-checklist.md b/docs/plans/0074-final-coding-checklist.md index a062137af..6550b475e 100644 --- a/docs/plans/0074-final-coding-checklist.md +++ b/docs/plans/0074-final-coding-checklist.md @@ -5,6 +5,15 @@ owner's instruction and AGENTS.md. Do not run individual new tests, artifact constructors, fixture generators or replacement CI cohorts while authoring it. The existing CI agent may finish observing the already-running 5acd62b0 cohort. +Current checkpoint: the planned coding and constructor batches below are done. +Source `eb44d8f7` passed all 63 required adapter selectors, installed journeys, +distinct-UID containment and differential/cost/history workflows. Its broad +implementation gate found two stale committed fuzz positives. Native constructors +now generate the complete repair with explicit obsolete refusal controls; hosted +confirmation remains required. Preserve the live clean Lean producer, then combine +this repair and evidence reconciliation in one follow-up publication to establish +actual Lean reuse. Both unchecked final items remain open until its gates pass. + ## Checks to finish writing - [x] **Guarded Stripe and prerequisite crashes (A05/A06/A10/A13).** Extend the diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 0abd7dd9a..6ca0b0c5b 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -3468,19 +3468,24 @@ stale outstanding-work descriptions in earlier checkpoint tables, without removing any spec requirement or test. The historical checkpoints above and below remain provenance, not instructions to reimplement later completed behavior. -| Phase | Current implementation | Unclosed gate | +| Phase | Current implementation and executed evidence | Unclosed gate | | --- | --- | --- | | P0 | Native owner/consumer map, ownership ADR, abstraction and independent reference contracts documented | Final source inventory and architecture/compliance audit | -| P1 | Immutable binding, exact approval, complete literal review and installed native request path; independent binding/review substitutions authored | Construct final corpus and verify exact-head native/SDK/UI evidence | -| P2 | Sole typed journal/transition and admission/entry fence; all-protocol adapter races, crashes, faults and recovery; final guarded/partial-upload/journal batch authored | Final artifact construction and exact-head adverse adapter evidence | -| P3 | Native acquisition, separate recipient disclosure/ACK, retained history and thin installed wrappers | Final exact-head installed journey plus adverse read/release evidence | -| P4 | Two-recipe/information differential, installed owner journey, complete restricted interface inventory, public/private audit, translated/formal links, cost and generated histories implemented | Complete final hosted cohort, formal/release/platform gates and requirement audit | - -All A01–A22 remain **unverified on the final revision** until the new batch and -all required exact-head gates execute. The final audit names a concrete producer -and expected boundary observation for every row. Earlier passing source revisions -are useful regression evidence and cannot qualify later changes. External live -provider qualification is a separate, unclaimed deployment property. +| P1 | Immutable binding, exact approval, complete literal review and installed native request path; signed binding/review corpus and installed consent/substitution controls execute on eb44d8f7 | Final repaired-head native/SDK/UI gates | +| P2 | Sole journal/transition and admission/entry fence; all-protocol races, crashes, faults, guarded prerequisites, partial upload, strict journal/revision and recovery cases execute in the 63-selector file/TLS PostgreSQL cohort | Final broad repaired-head gate and conditional proof/runtime audit | +| P3 | Native acquisition, separate recipient disclosure/ACK, retained history and thin wrappers; adverse read/release and complete installed owner journey execute on eb44d8f7 | Final repaired-head installed/platform confirmation | +| P4 | Two-recipe/information comparisons, distinct-UID inventory, public/private audit, native cost and generated histories pass on eb44d8f7; formal links implemented | Two obsolete fuzz positives repaired through native generators; clean formal qualification, actual Lean reuse and final-head gates/requirement audit remain pending | + +The [eb44d8f7 hosted report](0074-hosted-evidence-eb44d8f7.md) records actual +source-specific execution, including all 63 required selectors exactly once with +one pass and zero ignored tests, 302 passing broad gateway tests, installed +journeys and authenticated artifacts. Those are executed evidence, not merely +authored producers. They cannot qualify the subsequent corpus-repair revision +without its applicable gates. A18's stale committed corpus is an actual failure; +A20's full formal qualification and final P4 acceptance remain open. The final +audit names a producer and expected observation for every row. Live-provider +qualification remains a separate, unclaimed deployment property. AP070 stays an +independent reference; AP073 remains untouched. ## Deployment assumptions retained @@ -4103,3 +4108,49 @@ identity changes. Final correction closure is `71ff1dcdd7464474a0d1b12f661f7277d665775a6a192128bbbc5870ff9231eb`. The correction is committed for integration with the CI agent's combined actual 977 repair roots; final hosted acceptance remains unverified until that cohort. + +## Current hosted checkpoint and bounded final repair + +The complete combined implementation and CI repair source is +`eb44d8f7082db6ed9ab46c1bf5319e8e736d7b28`. Its merge producer +`8335af6a6f9170a12f4b63feae0f755e87290308` has the same tree, +`195e1ae19c0491af1c7e8fdd6d0c63b87655fe89`. The +[source-specific hosted report](0074-hosted-evidence-eb44d8f7.md) retains actual +artifact provenance and replaces earlier merely authored status with executed +evidence. All twelve applicable non-main workflows passed, including the complete +63-selector durable adapter cohort, installed owner journey, differential, +generated history, native cost and Linux distinct-UID containment producers. +The broad gateway library passed 302 tests with no failures and 63 ignored tests; +required adapter selectors execute separately rather than treating ignored tests +as passing. Conditional live custody supplies no qualification. + +The remaining actual implementation failure is two stale committed fuzz positives: +an old public outcome and observe/3 frame. The dynamic campaign generators already +use current schemas. The complete repair uses the existing native canonical +signer/frame constructors, current positives/refusals and preserved obsolete +rejection controls. All six corpus tests and both native generators/unchanged +checks pass in the bounded repair verification. No runtime decoder, signature, +assertion or security invariant is relaxed. Hosted repaired-head confirmation is +still required; the failed implementation/derivative rollup remains recorded. + +Repeated Lean work on each push came from the PR-wide formal planner and fresh +jobs. Both Lean phases now support a successful, same-PR, clean authoritative +producer with authenticated immutable provenance and the native complete-input +digest; current Rust/source checks still run, and any missing or mismatched +evidence falls back to fresh verification. Fast bootstrap Lean has passed; clean +authoritative Lean/compiled audit and the remaining formal gates are pending. +No warm hit is claimed before actual execution. The seed repair changes no proof +inputs: the native digest is unchanged at +`c523f465540e306ac9eaaf49ef460365b467be4bccaafd2160552ce23dc83432`. +Preserve that live producer and combine seed repair, evidence report and this +acceptance reconciliation into one follow-up publication for warm verification. + +The physical-WAL restore test explicitly reports `replay_continuity=false`. +Connection-generation/exact-record floors protect their stated state, not an +arbitrary rollback of attempt/counter history. It establishes before-target +retention and after-target exclusion, not safe automatic managed resume after +whole-journal rollback. File sync/rename, PostgreSQL participating-writer/TLS, +clock, OS isolation and external-provider assumptions remain explicit. AP070 +stays an independent, narrower application-owned reference; AP073 is untouched. +The goal remains incomplete until final applicable gates and the P/E/R/A audit +close. No merge, deployment or live-provider qualification is claimed. From 8ddba7eaae3028c36b3423b5d45d393289bc3b85 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 08:04:28 +0900 Subject: [PATCH 134/136] fix(gateway): generate fuzz seeds through current native schemas --- docs/plans/0074-final-acceptance-audit.md | 2 +- .../target_gateway_app_frame/observe-outcome | 1 + .../observe-pre-entry | 2 +- .../obsolete-observe-v3 | 1 + .../accepted-not-entered-after-claim | Bin 0 -> 802 bytes .../accepted-not-entered-exhausted | Bin 0 -> 796 bytes ...pted-not-entered-pre-entry-condition-false | Bin 0 -> 813 bytes ...ccepted-not-entered-relative-ceiling-above | Bin 0 -> 808 bytes ...cepted-observed-by-provider-after-response | Bin 0 -> 792 bytes ...ccepted-observed-by-provider-after-unknown | Bin 0 -> 773 bytes ...cepted-observed-by-provider-with-pre-entry | Bin 0 -> 791 bytes .../accepted-observed-echo-mismatch | Bin 0 -> 766 bytes .../accepted-observed-match | Bin 0 -> 758 bytes .../accepted-observed-mismatch | Bin 0 -> 761 bytes .../accepted-response-recorded | Bin 0 -> 771 bytes ...cepted-response-recorded-provider-rejected | Bin 0 -> 790 bytes .../target_gateway_outcome/accepted-unknown | Bin 0 -> 734 bytes .../accepted-unknown-without-counters | Bin 0 -> 750 bytes ...e-v1-schema => obsolete-outcome-v1-schema} | Bin ...me-v2-observed-by-provider-after-response} | Bin .../refused-missing-record-commitment | Bin 0 -> 665 bytes .../refused-other-signer | Bin 0 -> 739 bytes .../refused-outcome-v1-schema | Bin 0 -> 744 bytes .../refused-outcome-v2-schema | Bin 0 -> 744 bytes .../refused-private-evidence-digest | Bin 0 -> 803 bytes .../refused-private-outcome-schema | Bin 0 -> 758 bytes .../refused-private-relative-basis | Bin 0 -> 770 bytes .../refused-raw-action-commitment | Bin 0 -> 828 bytes .../auths-gateway/fuzz/tests/corpus.rs | 48 +++++++++++++++++- .../auths-gateway/semantic-closure.json | 2 +- product/runtime/auths-gateway/src/app.rs | 10 ++++ .../src/pending_vectors/outcomes.rs | 27 ++++++++++ .../auths-gateway/src/semantic_closure.rs | 2 +- 33 files changed, 90 insertions(+), 5 deletions(-) create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-outcome create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-observe-v3 create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-after-claim create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-exhausted create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-pre-entry-condition-false create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-relative-ceiling-above create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-response create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-unknown create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-with-pre-entry create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-echo-mismatch create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-match create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-mismatch create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded-provider-rejected create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown-without-counters rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/{outcome-v1-schema => obsolete-outcome-v1-schema} (100%) rename product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/{observed-by-provider-after-response => obsolete-outcome-v2-observed-by-provider-after-response} (100%) create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-missing-record-commitment create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-other-signer create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-outcome-v1-schema create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-outcome-v2-schema create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-evidence-digest create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-outcome-schema create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-relative-basis create mode 100644 product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-raw-action-commitment diff --git a/docs/plans/0074-final-acceptance-audit.md b/docs/plans/0074-final-acceptance-audit.md index 7ce87a192..50bae9a80 100644 --- a/docs/plans/0074-final-acceptance-audit.md +++ b/docs/plans/0074-final-acceptance-audit.md @@ -28,7 +28,7 @@ subsequent repaired head. | --- | --- | --- | | P0/P1, E01–E05 | Native owner/consumer and canonical binding/review implementation; installed exact review, consent, request and disclosure controls; signed binding/review corpora execute in the required cohort | Final source/architecture/compliance and repaired-head confirmation | | P2/P3, R01–R10, A01–A17/A21 | All 63 required native selectors execute exactly once with one pass and zero failures/ignored tests on file and TLS PostgreSQL; process, capacity, crash, partial-upload, ambiguous-commit, epoch/floor, recovery, ACK and 64-event cases | Final broad repaired-head gate and conditional formal/runtime audit | -| A18 | Native journal/frame/binding limits and shared 209-vector binding corpus execute; broad gateway library passes 302 tests, zero failures and 63 ignored tests separately covered by the required adapter cohort | Two stale positive fuzz seeds require native-constructor repair, obsolete refusal controls and repaired hosted corpus confirmation | +| A18 | Native journal/frame/binding limits and shared 209-vector binding corpus execute; broad gateway library passes 302 tests, zero failures and 63 ignored; separately, all 63 required native selectors and 30 additional PostgreSQL conformance/hostile tests pass | Two stale positive fuzz seeds require native-constructor repair, obsolete refusal controls and repaired hosted corpus confirmation | | A19 | Two mutation recipes: 28 request and 26 response comparisons; acquisition/disclosure: 22 pairs after eight named native histories; all 12 reference source hashes match | Repaired-head confirmation with references still independent | | A20 | Four-seed concurrent histories per adapter: 32 positive and four negative rounds, 72 workers, independent HTTP/transport-count and historical-byte oracles | Clean source-linked Lean/329-claim audit, translation, Kani49 and applicable formal/release adequacy gates; final consumer qualification | | A22 | Installed Airtable: 36 cases/13 verified private audits; Stripe: 23/6, zero inconsistent/unverified. Linux distinct-UID: 33 application cases, 12 admin commands, 53 CLI routes, five private CLI refusals and actual credential/provider/file/privacy controls | Final repaired-head installed/platform confirmation | diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-outcome b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-outcome new file mode 100644 index 000000000..051425019 --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-outcome @@ -0,0 +1 @@ +{"schema":"auths.gateway-observe/4","request":{"kind":"outcome","operation_id":"refund-1"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry index 440d2527a..7a7a6ff47 100644 --- a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/observe-pre-entry @@ -1 +1 @@ -{"schema": "auths.gateway-observe/3", "request": {"kind": "pre-entry", "operation_id": "refund-1"}} \ No newline at end of file +{"schema":"auths.gateway-observe/4","request":{"kind":"pre-entry","operation_id":"refund-1"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-observe-v3 b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-observe-v3 new file mode 100644 index 000000000..440d2527a --- /dev/null +++ b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_app_frame/obsolete-observe-v3 @@ -0,0 +1 @@ +{"schema": "auths.gateway-observe/3", "request": {"kind": "pre-entry", "operation_id": "refund-1"}} \ No newline at end of file diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-after-claim b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-after-claim new file mode 100644 index 0000000000000000000000000000000000000000..c5137204db082dffc3766c9363cbe4324d323b04 GIT binary patch literal 802 zcmbVKO-NKh9Dh#}N)jUqK@fzf+uMC_=FOWo3gQ;_VOEw(WR{BYE#bM-9Deivees*uZfd$7I-_E& zEl5y+oVKImJDo#@QIavz)6+|K520KxX7<7EM0z|N1HC8xJ$}f#nILXWi56rchzwIH zN_5P~6eP>|A_{B6*eYUFk+x_wkoja*75Mc)T8g~j2KCfy zuoO-D>zYUIw@=nhm9?z!Ji%n;R((n{p@*FWLz~8-2~C$UN4UuJxD)p{fF2}*0OF!J z=fq=x5n`H**)Fgspd#)7i!fN$Qldyx1?60+O1&a>R!QXrtJ?f01ucOARbqhHju-bV z!X4mQ*fKfv5Jt#zg^gVYdY)r5VR7u($b|~#M3{t^wVYzjPDKnrcJ=|99Il@$l ziatqG5z1Jmkd}s@416kCqO6HP(qW;Gt|?qEYxCMjo|X)?0HbLA{}e_92MAfDLNeHS zmz)-_CiZ%=L@r)vp@P5-hNwI{JQc+ zU*o(cY^B+3D#=z?6)mQDZw4wPR@O)P+m+56)kno_T-o4|Lxd)Bpeg literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-exhausted b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-exhausted new file mode 100644 index 0000000000000000000000000000000000000000..c2e215013b5ed4837354e6db475d922abc02e857 GIT binary patch literal 796 zcmbVKOH30%7~U3wjjm8Uj)oi;vvpc(k2B}6dh}r;#$3>ZKSm zNNeBtDRN0sN`9PnbtUN8L1SzzuJ+*0lrtWbQQ}IrBOCBe4%CX2Siw(u(P8F8iIo+% z;Bz+%Fnq^+kO!eakYWYT2eIq$ z$o%n%`pJrv1KS4fSAT|291e2OPED+{Bv!F%QBJ@zR9ldwEfBUb1&XL;B!!?hN1Res z}H<``IvRm;fnPn|pw5Zkfqxj|Cb3ICTyiYlQW+2?W)UvmbC|ukvJ$q+<{c&^1D2`6I4IY@h P_h`?nyN~Zot-kyXTOb(u literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-pre-entry-condition-false b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-pre-entry-condition-false new file mode 100644 index 0000000000000000000000000000000000000000..938d83a362712daae4af2d1bafa7d53c07b50eb8 GIT binary patch literal 813 zcmbW0%WD%s9LIP2zy}l+e4rvkkK!h~GdsIG6-ra^L0fCEmDZ}%*_q$AX_IWa*(94H zR11w&yxF3q^k7;=y=WEm53pA~cMvl)uXq8@BDt>`F#1#oOD}~<-iz% zQe$p_A!0OkkF*%a6{YCMX?uHu9_}T>!*R6}w+>`Rf)YyfrH`Zo-pYYmHAR;92XfJV z=0lN{6gTg4Hw`gd8+5EF%Bs>Bi?O8VGdl%}fV3NPv*0m5>1J}VjO#0q@xcS3WId>! zy^_M+j7U~5C=N^Ipl;XT!ol(Saz)C5;{f*+51eo$!$A(3sfl%FV->3w=2U>#{%874D2|D&OsBVp%V*-vY?<+QIUqjt*$3R!gM<6 zr$gM305N1?Y#X*}8YVR;0ZI%NOdU+20y9m*Fj55<;l_}NVGKYy(sj#JRbsM=)E@?t z&#{yo>|G5#`X|lkKWSDZ$oZ@v+9x@1Cy0MGIPO4~n1cI@+n6h<7V(hfal`K#DZv6Zwwy(ybTf byRT#CNMUHEsdroX%H+m}m!~dGym{~o-C`WW literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-relative-ceiling-above b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-not-entered-relative-ceiling-above new file mode 100644 index 0000000000000000000000000000000000000000..6150f66c144706dc439149a5cf6c50f1d480442e GIT binary patch literal 808 zcmbV~-%Aux9K~leA%sXG349QJC@PxWnR{pM%ry`phoqzURYPkRD00?2{2F zwdIBxGDzFt=n2xRC`B(qySw}7$%{rN6H)td*RVV4mr&o;XE$>iKf$;L5GW!;gDr;~SS&?$tLRd!cT=|9s=^tEQROwdvK> z>u-9ltRGpct-1L?8ftm6f9l;#o!{_sDb)UJ@7IX~uNUV#=D!ate*Ctzw6V1&@3_3i zZ(-?lBF4A36)w0U^k<^ga-o7&JA@+V2Tu1Z=OTm3na&Hr{-u^Z`M&(w-O|HlbA5CC Yno$_J-+r-i^3H7i^Xa+UQ=gvx1|}LE=l}o! literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-response b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-response new file mode 100644 index 0000000000000000000000000000000000000000..59adada015fa8e138c8a823df57bd65d290f5295 GIT binary patch literal 792 zcmbV~J7^R^9L9I^03V175yk2XA%*PS?#%AY&I#czKFLFaNyr1Dncews?vi_DclI6u zK?8ZHjrgb}%|$JO5EZntQBtHag_YPSSZN_5K0pGxi9sx^Y=(hv_`d(|Ki{HqPf^t> znSfd{$Z%wlg_K6qh41c_n^d@i%aLUeTk@XH`Hr>2$s zVmT|o*SII6(}$oGJ%Of!;}4I_G|$$R5_lfCa>ECFD7c_jQ;cGhJ6OlM&0GSurF()n zoadz%xYyd?(N=M8jp5qxz5ab!u&;|A^YFVBQCbbFnJYu?F2ue)L#*r)- z=uFg=$;h?n3oY7QJ}dK3kP#B%$i~gjv8Wq60O73LQA57RN{zu815XM2;~4 zbCGGk34JkAW)xwOzHYEGpwZuV~S~Yh~mA3os4>S(d>zOa@cW&)rY4@WQL7 z{^(Nc)lhksc)m7Y>t4O~zAM%~`0YjV!}b0{+Yh%qZl5OB-cH)O(D7q#Wam+-)Q=5~ znoqv->830-cXJ4QYn{p zH@lQ57exGbCAZ+>WutKrrThC%^=fC+16t?tp{ValY**M5p5CV1eMvulogTHy6Sv!j S_sw3px#Q90TXXa89{d6X=@VK2 literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-unknown b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-after-unknown new file mode 100644 index 0000000000000000000000000000000000000000..300d8f92ffc7f9b2cd9c8a2997c4bc871c646843 GIT binary patch literal 773 zcmbVK%}W$v9G=mn2&4{{5J8^0&CbmG&O0-&fw+Q|AJmeDCPcpTzQ1u-cW2hw+1*)B zR%jMo!la_StmUDL)gk-?q==xXQ$%4O7rR7Q;YF~~JQQ^5^1D3nJiq5-PMViwIWk9} z(p*S0M9k*Cu{QIhqLjlV?e0#|qXT4gG^zFA&a^icRZ!|&?pQA3ogAoLQ)b05T}TYE z5X!8g_{EU>IZ$zJ)U|~u+eovjvP=*%Cku*zoUi(M2w0f$y@KjH1qezY6sMx(1HY6J z5Gc$I<6HDbJiqMiI57P1$VA;lRmy|w0uPk{TnND9AV;m#!Ul7&hBcdV6KtZn!gO4L zu!|{BL~Y^-L0yhGrJBaMVI!R(29Akz%5hc7LWyOIu?L~BP~H?9kEH_OnLPX@g>|qH zi^UK%OxJOBDoo_+maYlx5{nSm2E(#V?7F7GK^K;35F5v^prBDvl}2M$KM+bBQ!W$c zzzbssh#?ze$8YX zW`v12*3<43N(@m28*2RX7=j7~@hVh(wP`^2LwfbtgYh~rr z%=^O|tYdoTU}f@7^z6{fTi@Fo*FNswXnVI>|MX&aF?}ty_~pj@8@cBEU8%q6e#6w; z>AGm|}@tc-&G`eKA!$u}ix5+WPwQ!XPP)+-@1zH+kjy?njqrE=_%Y F@C)rE5{du- literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-with-pre-entry b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-by-provider-with-pre-entry new file mode 100644 index 0000000000000000000000000000000000000000..4a4f02b7e2a832beefe4433d294cd57ba6a9883d GIT binary patch literal 791 zcmbV~OGs5w6o${y1d*Z#Ng))5P4~U$?0sI_NbVJSU{aEXCPePD_d4F|eI3u;_vOe0 z%_Kx9M4!W={!*oa}3kn() zRb@DI%>@F5hsz{oCgcr~FvAWZuH|aBWmAiqKut>n+W=c=z--%O1Z#qe&@n`0gaA;E z4a2cD&9qrnfpGCbQ02d_t5%f-Whh`J6uuo5_5c6>5D09VI^8zui~ZCL^Ra!YVfBe7hO1WHLSbRysywzxLB{;U$Z}b9UCxtCm literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-echo-mismatch b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-observed-echo-mismatch new file mode 100644 index 0000000000000000000000000000000000000000..4112571904669053ee84034730b9eb0f9d1278e3 GIT binary patch literal 766 zcmbVKO-K|`9G_VeBFZ`xg%Wz{*6hx_H($@f+#m}R6F<2S&Oi8l&q{NWEQe+mMq7(1iVU-L zaO|{sK~X9qNxHgvNXI2(WF)Ef;m%ZkEF48Wm%X!I$T}GiJ6543kt)WAselR{Rs51* zz6S|h7oOTilpUlsk)Y{7P$vfp2hUIV1qi4}`}tzRcZv{{fh)jLzT%~e9u+LLt1*Z z5z$T8aW%qCp8_%b*ykobiY;ibydAAPnicZKnB#0k7nLAX4f{F zA1pLY(y7nyo990roA=u6o1$T=uj;K1zr1>U;YV!m+{*H1M|VT)`a@}`fQSA z!1JYe+t2-9#}B_*oN1rg=wJNseRJvC=9>JM^H|tI3x!;oZC@r)&hz;1C@BPPJb#~X;+1Xt$ zmEcERI+Q0dVy%ceXhG36D6mUJm!L~QVG$7#MGAtAW>DA8KlpvmD7O?yTv{H~@9UV#5+G`CBCG;-bmd*~BD=2x!JM5K3n*e6llz1^n7h-)pfD*50 zxndx49>j5NnXVz)I?@=A^Nb&GXAm?AUM`-?gU^FZE?bD_oC5eENX_GcNZ0M{zjt7? zeypnG!F53dnh!4ckQJbon;FF>cd(9in+XE8rMr?iu0+_y3>adz=s)fe?&)W|YS(d?8Nm9)#Px-65RQ2+UJ?)>jFHUajySvZZ|Gp(W_~6v( z#~-g(+}rJQiwoBlrp7DF&z3sFbEzab`e~`P7yBO`jm&STxo|^CHQd=T@%l=AdF#U` zv8I(RUq^R6pPg=={@FeI_WSaaZ_97gzns^U8+blHm=SANiHBJk`+d0eaIw&+O`*hz z?jv2=@kEc--f}W}v(m7+m@FRKsN8%>zx)_EYlQ<-O}#tEE?wPp|KjBM#Jjm)X(`=Jn2 z;73sqWE6=V*2?H&btv%E!9$1aP^W?@hzLR=qKH7K(G2R^`3Jx6Y2~(}s%2{ch7w_l zAz~$t5AU^(Xj(}oX?uGIZS5h0gGs#;x23Yf;OFAGJOoUpbJ;MSb3+JsWUvx4yEn zn+`G54Ltk}|J_lF34-Zg~=E2f)*L_(vNXU?Uc( zBWhZn>lsv7$TMt17uX{C%n^ENBk24D&NX_D!tF0FoZp@Co-xDq# zsz-COrMP{^ol6(y3NI%&J)+m^8r2sQ`(BG(#;M*PJI$xtG_~r?O{Kfx?#A&~mut%# z9?r*_ey;yKviaHURP)sLuGzO=m*&4Ly;1*iUR7>j`FtkLSKbmYW<~7x=T^hTibi!e zN*?Pv(5W3w9@h@GoQMvsG}IM33WwJ!x1QUdzMbtQ#evDDp8C=A6YCzFyD~QZ?%prk C8VM-? literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded new file mode 100644 index 0000000000000000000000000000000000000000..611f1dd55c5baca4c17701d7252bd6c616c077c1 GIT binary patch literal 771 zcmbVK%S#ne7@zS05k)PGLJa%^ntNx?nRCt@1<{}fDk*AcZtUE1zVY7ceK|Atp|r3- zvs_lIaC1$AHflr<0yjwyhzKc&5DMBxNEAUyHCH8~Wvg%TDC{Xu4jaBQVzF z#|0v^sek+^?J|sF(8fDEyZP}!GCJC3_Tu(K-JVI zmzyVRr^;FmTo+_e*#ZwT67*6lXV?}oY+}>ll7d4_SJ9ZO5Oy&Kj<`c&N^w^r$+>At zX*2A9t1hV4@8jn^+QiX?a4~BdzSt;O|NrYGC`5?GD%^6=-KzQdXO_ntMN zm)?4Gc%~z@uwGZQ_M@Ta`S<5TOZ9J(Ht0 literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded-provider-rejected b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-response-recorded-provider-rejected new file mode 100644 index 0000000000000000000000000000000000000000..be6f2d69804cbdd3121908f7104564a1d214df58 GIT binary patch literal 790 zcmbVKPe>F|9G=mH5~83Y>Lf&Tn%$ZAX5P%(NL(oswX(D{A?nS0zj1eUcgLC8KMH{b zn$@K!i3%@kb?9Pxi0G4XTQ7Vk} zvj|FTSj!h8p3g!Y*Om{hAle#|h{wYyNc*4#;1zNrjOTp_Sd`A^!gv6oFJ~3w`9Ofs z{2*UU3kc*U13Ut;Zf9n8?^xYeju%0McLd@YPvR0!1_ z>J=$2FI+S6M;seqBPQh$HHqhX1{DN(hHdBqdzNiko&%=s5bSxx5*X!Ksho^ z$JTYrW)%hG<^7;a_J7{1R+MQa6R?sdQ`d^d|Hq#Jfh^0QRg&JO{g2haOH z-kcb9w>6(txj8$3YeRjdWzIYy!ow{IDF|DyZoo~N&0?cViy^5?0mH){7iYK0GV zHRtXqy$$!bPQ1BRSKj<^A=db7)6&@XXERexQ$My^7N?JwWYpRtMqw;TJm QjbFN6KX-BR!o=c(-$_^%(EtDd literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown new file mode 100644 index 0000000000000000000000000000000000000000..e65b5592427c339e343acd5644f9972f40bd59d2 GIT binary patch literal 734 zcmbVKO-K|`9G~$6Du_B5L5JEymkzT#^WMDo<|)W-&<7?asc2s6&3pfGSKZllcXoI5 zl#!)D5M)Gz9o7sn(CQFGbm@bjgF%meP2 z(dJ@WAVQma#}3lthEWMpyuH1XAMPh3BPp{Bx265Da1?c(${xvvvP}Ya>MEiXq>J$Z z5kN(Z8o5#+b6H5>`q0`$j2hCMNECxYCJ#mdyppeqiCi8EBFNHW9$XJ6Of>Hj#d3u7XmAI`|lMI_3;ivJl_EnK{8)%T%PPxsL-<3y_0ICkh{v|25; lz0_Ii*rLt7W}m*FJx$6(H(L95oxeD}?f%r&3zHx2{svU71z-RG literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown-without-counters b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/accepted-unknown-without-counters new file mode 100644 index 0000000000000000000000000000000000000000..53daad577a9332ed6db16b2bcaf11fc997c25bf7 GIT binary patch literal 750 zcmbV~Pe>F|9LHzY3<)w1Mc^epc9`8a@6DT;XCS*le=w;f4b7x_^WJaV)!mtOcJ_}# z^am^pqC<8HgI4R%#SH2ig3uwT2tv@LAc9VjX><{4G!J#{{Dtr5`~CgCQ_4d{RjcL@ zjIePDDmnx(J67SPFjI^V z@DM6|MDt6b@bi!$b=B0SqHQT{i3HCEA$M}1Nyz&NzW@Obv%XhMl)NF&uXtJ|8)hN{ zP531*grK;sd2sf?Sp8T{DS+#O2(n<7`5jw>;72?K_i zO&uwjE3jY;At4MK>l|}%Osq3OYDx~uJXea6OO1!>2JBLV3P5BF@DGaUU|}A?Ff&Zo zadjq5?CO?|Byp)lscVB_*(Pya(-5Fb%QUD>B3Uv(OxBd)$kh*IR4t#+hI#P9r~&5K zCd4rvWSJH-83jg71eO7oM8GYJa)OZ*GIER>aY6u?z=mO42vLjI6exy#0Mvo43#v6` zN*N4zMT@?vmG%FB>mW!>sm?Y`dXw;?X{~>*A@zEBWhs4T0g(%f&C8#)?JHm2OuTAb zn45lXH1E5()Ov3@1~A#~YLfZ>_ICuAHakp}XyUd#>J?*zx50oonNt9{&a#b_u=! literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/outcome-v1-schema b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/obsolete-outcome-v1-schema similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/outcome-v1-schema rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/obsolete-outcome-v1-schema diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/observed-by-provider-after-response b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/obsolete-outcome-v2-observed-by-provider-after-response similarity index 100% rename from product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/observed-by-provider-after-response rename to product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/obsolete-outcome-v2-observed-by-provider-after-response diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-missing-record-commitment b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-missing-record-commitment new file mode 100644 index 0000000000000000000000000000000000000000..71194835fefcb0014ef40b19d99aedaf2c163a27 GIT binary patch literal 665 zcmbV~OK1~O6ozL~TU3xLD1vkm(S@Ls%-oxK+!RVuZIu{ou$9&#*qi&vdy-~ml1b5` zVr|u>x+-0m8Yx1ky09C;O;;`y1zm`speq-m;sd0hlN!Xe>z{MJ|D69{6mAQm=xRAu z3tMRnR4qI@)vpanQq_*4cszjy$JNQns5}f~X>-c0fyC*;;etzIgdxLM#g3h}0x4{> zDy~UI$0o%B3&IZf;JPBUm2fa<+2u@$NoB?zlUl)IiIuUPDVkQWkg=?cnerr3EK|wb zP{`N?X4)HeW$*RQbY83rCB``;c59lInMs)FMvx9eI0Fp)`dkO zTgFw%d%RRp{y%{%qd-*^)LJqY3GCZ69a(xGeO;R#a(AcWv%bCk`%g9JyBd#QEH$pi z4m~=sr|aRF4?k~i8~EOHwr8RtJS)BIg)7bGXM6Bzx9|KdVa$JL``oK*o$l5LtAV~> z-JfQ5K3QIfEc_T*e*1N8^~>5D@gL_t*N;o3e1@!t8LXHz@TU{);{p|>V+=%3j2s!3 wjz>qOqXQ?s!U_H@PQp31QD{8ZKYqI~p;mJ9ed9YWUAeyb{^c99bMNl{275N_82|tP literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-other-signer b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-other-signer new file mode 100644 index 0000000000000000000000000000000000000000..6867b389baa96638e453bff93d042ebfe3c0771c GIT binary patch literal 739 zcmbVKJxmlq6y7_8m`iNzBoq`PCc1aKGrO}pCow?y6A~3U1PqCpn|XV;_p^KM?%gdA zgPPEgU}a-ra~SC`fRRpOW3Lt#8XHuMiDF@*9WF?WwcSg;yzl3|Z&`XI#bO~T!c5xF zGo+LBXo!agN8F2j_E@HVZG3Q$U(WkunJHB0pUr563w@?DTDm?lOEP}E&Z5e;$Wjee5!liV zUAIio43l8XA{qx(7(~-e9KnKuLPbNm5wW_SkfV!~?Vt=!5G6ninHXnDRxyY{3Dtq> zL;*tsLny!uLuVK%f{TbTO2jY*pd4wMX()a)}2^GT9yhPtIN>~ z<(m5czbt@2x~|fFlF9D1u2-jz-|=>TO)Vv!olxF}%|B{4w?2Goc|D)$e0p?oeLZ=8 zey4NsXGh1Gm9uVB+xF&e*tS}KH?aBm>w~>S{Psg>vVBvm%#~kOd%sBb#&qiow%xUQ zU%f}-PnzExJ2kSEi2dU{9=5YerDXGiTBK@@Nd9TpVYp;XZJIBrtG9-Mc zh^mn*`7)PzqW6E!Ult_#v%-+}^o67(R>8MZ|Vo7i-?q~H+KRW#))gk8*mBkqutQrwkDa&DSZ z+77Y=5|E9!# z-|02Qr)Gnt@qLNe>d)mb@0$;_zG^nkHEzGvP

hmTY;_IQijvL$LS7LZt2Yp05*4 zZ|A1t)2sb+pH|iuzO8-K|8ZUyw1|9uG$S{<5iNTvvRSdMaFMcApG1ih{YUzY-o${> sdFW)=U#(?Vsi$;ohxYItTmEtJEGduNZX4Wx>FSN0&#v6OJo$P453nZ%^8f$< literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-outcome-v2-schema b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-outcome-v2-schema new file mode 100644 index 0000000000000000000000000000000000000000..da2afd4719cb9204f9848f43b6cbf196e695cb3b GIT binary patch literal 744 zcmbVKJ7^R^7~V?^h!3RJe)E*aa-COsZ>!%f9_bWBH9Enr>@M4VY(0> z;31TGRriab@NB>X%CJk0oBG_G&yC8QTb8ghKo zp6sKRv4*jlmItLkgsWQ+fF~eUNirK-+{Feq9406@#88sDN+PT<1BRGGTq&6nNHAs? zLRbzmIpW|_WHNzk+7OiZP%-i>bsol6#V$rt0f-HQf2FVqHsX;OVir}dGMS`EnYL+2 ztcXpBa=@}3ij|_408`r3A`XsV$-rQ;rVU4|ejxSeEV)dW122pcAdVc2UFsS(wHaju z7@-E(7TD4NZrg-oWJn<+#wZcT7=Q_6S&nTO#O5^(3LzhW*g(-6^!&0Ht7+3(HsEDF z`lDVl|No&`kcbeIt&;R4KfIX#t#iA)h`s@j9+-QckATTjro~xXJ5WM z_q=+rH(CDbPBOpo&~>tZ-+}i_qstE#Lw8%{N1UxodXu*UH?_m5;H1oYz&Fcs@Ur5o_H@lsp+Soc*(5qL8&uc$2;}Ysc!wm rk>04kTGRGoNAculZRV~0eQESODGlCf?Q0yrc5BPytGBOAe17-`uNMX# literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-evidence-digest b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-evidence-digest new file mode 100644 index 0000000000000000000000000000000000000000..f73880a54fa81b525ad3c7fd204395f39f1248dc GIT binary patch literal 803 zcmbV~Pe>F|9LHz;10qO4Nl+aYJaln(X5O1OGj9WNg)~fS{S&TU>g{`P)?MA%-PxJl z)k`L*nx=%P>%7)Adq2*GAeB06^dzW4oozF)qJ!m=QW zMSX;ig>u6LAU!lN-lm_Cq=Fm9U0o5}K7_K_u+j%Rhwbs=7>Jxpb)<^4lX7fU6^Q2! z=YnzK@&Xx?(w|K?N!%raCu~Vlh2tF#s)y zIR@B7F~+b(0mWERDAi1$5~L}`mSk*Nq(cLgqz~F>&FHJm=MPFm}2M# z)-mE3=?XVAZZL%t!$1TAg;C}^`ZW*;ImZ-enrSEsGDunQnX+?x@h|eKVt`~aqY1h@D>-ko;O}+rg$w4@>L>`G?LXNk^@aze rQzr)f=?j4dFXEl96Yjh;K5k8(NBNPPEkljdvsddMUb;3@dUO952dx}h literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-outcome-schema b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-outcome-schema new file mode 100644 index 0000000000000000000000000000000000000000..a0ef2aaa5d562dc0089cb3b36df2494f77098303 GIT binary patch literal 758 zcmbVKO=uHA6yBtksvrt#6;UkWN!Vm}W@l%oLP>;HtwoEiv=%`pGjE$T%_iC1B%6w& zrO{Sz{#=w^QuW}aTF_$;rH3A*2XA^%!E;5#`U4f+)*|B3+k^Ms_w(L2r94t1k-*GC zwbe^=M9kK{kt60QRjv3**45R`ItECwnACc3XWAJFs;K*X?r1I$odTE@4fgYrpY~#d z+=mLUss%Sw4ofv(@KRvPyO(q;f&5tNcTSb)blcWQZB2ow9W% zO=Rm-*Ce(HCB(MCpq7bk+cX5|l9~pwaM+d%G$!jxF+|O~QVnmD%lJ8P{Llg7$ig^f zrZj3&W-N(6sMLT{N;pQE6f#5%9dV2Sm_UYMQB5P1*A?)5J_wP)l9P4v6(>?x zrj#L`gUWm?fHDH z?dR5ywOxzTlZnZ%z0>bLugrg1c^mmlc{FI@g~D(~tOX=qc4X{#-qy{<%6daTN}lOG y)}x+I_Ngb@&xUDMTDFwBOD8uf4`0#`%cB=aIeWitVCS_PcQ(&V+`T^j{>d-c4+=p5 literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-relative-basis b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-private-relative-basis new file mode 100644 index 0000000000000000000000000000000000000000..938391133902c4743028601ed0668b287692c4fd GIT binary patch literal 770 zcmbV~Pe>F|9LHxgK_sbzAxQ@h9fF+QnfGSin`a=q(Lc;g)X==toA-XRuDd(C&dmN3 zA`LX_5JY+kFRMv(u?#$Qv|Chk2`VV))FmPc4+=J#L|wbSFYo*LeSg32qOz>0YK3H= z+8K;;WRcFHiIe1_rj^4a>*?uZXGW~?@uWV0yGOl=N)`28$(_wrM7IED*OhrO91UVA z9zvN{wR|xY`5eS?eI>E0XnRU$JRXF8x&WFFZqbuLJYN8xhv~c*#0!496d6QPHhL+6 z=I|gL>}wl)a$>q+rlu6YbwPwXU%>}YfLci~icRid9qTp|1Z+!pC2?Gdu!|Wm#B9rv zlDPs2#&lf>(?$kI92|lSCU8y3LWyUK5m#zFRCi#L5y}U#H{~A`Hh>}?!4NZv>$nD! z1i1z^bctPyT9#{rNo|5%mzV+!Nr`FMIFcm;oynRq9=YaysYScVrNbO}VUz%IWMk|Q zN2i1`!Yp7G(Se#kr4F1@i({lqAtT2q5yu#S31pf!)pd*Vn&SPtF!gZ#mzn}W$Wx%E zieARcmp!$nEGlC@FKf|-wUY7wryc`|EX!a!Cc}vf$q)VM*KPf)>SXJSYfH*}Qwz^7 zZ@zs>9wv@7+jH-GJ6>&Ul4IAmYtQc7O~F*h^UT`O+12W)w&Meh>-+1bmXzW4M=i7O z?ln{nuC2$qwhw%pZhg73kXYClT>124YyJDyNA<7C>niQMP{^jmZfoKtPsV}^yYyrExz-neR&GWWYi4$a)2Yg)ZEe{=Tp F<6oA~3^xD( literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-raw-action-commitment b/product/runtime/auths-gateway/fuzz/corpus/target_gateway_outcome/refused-raw-action-commitment new file mode 100644 index 0000000000000000000000000000000000000000..9135f0004ec7366228a58fac42b96ee997d05f29 GIT binary patch literal 828 zcmbVLOGs5g7(Q1MDo|VWfZDi^-}lWov(}syixt=qjMioP zC8n&dd+Y!^YTNm+Nwl`Mi$lG1WTXjokmmkitT2k(PbUs13aVLw@XGQs8}?^v`(y}t zIcg`fp-LtoPRa`nYlyv$)WzeOFg=h0I}Iiq=uAABg0u_=l0hb(mU&yM(%O!0CkDa< z1mULLgOB%3R7@7F!GD{vLL+uuL|s?;K6MdtIM>P{mO+owKUt0-(+Sgfu8RsCgR*X#M2#+jAQ z`Q>k`i(gki#x^J~E7ZtTYIs1c^(~$YbnTzouA8gPIpsaLsjKryhkd-M+ip2{BKi|n mO=Y${+qT)dzr;U(A3sBLL$~XDcT8TozV*rUjf+#C9{mQLjvS!? literal 0 HcmV?d00001 diff --git a/product/runtime/auths-gateway/fuzz/tests/corpus.rs b/product/runtime/auths-gateway/fuzz/tests/corpus.rs index 95f1fca4e..8e28cd5e6 100644 --- a/product/runtime/auths-gateway/fuzz/tests/corpus.rs +++ b/product/runtime/auths-gateway/fuzz/tests/corpus.rs @@ -129,10 +129,56 @@ fn attempt_seeds_are_records_and_valid_transitions() { #[test] fn outcome_seeds_verify_or_are_refused_as_named() { let observer = fuzzing::test_observer(0x5a); + let vectors: Value = serde_json::from_slice( + &fs::read( + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../../../bindings/fixtures/gateway/outcome-v3.json"), + ) + .expect("canonical public outcome vectors"), + ) + .expect("vector JSON"); + let mut accepted = 0; + let mut refused = 0; for (name, data) in seeds("target_gateway_outcome") { let verified = fuzzing::verify_outcome(&data, &observer); - assert_eq!(verified.is_some(), name != "outcome-v1-schema", "{name}"); + if name.starts_with("obsolete-") { + assert!(verified.is_none(), "obsolete {name}"); + continue; + } + let (prefix, id) = name.split_once('-').expect("closed seed name"); + let expected = match prefix { + "accepted" => { + accepted += 1; + true + } + "refused" => { + refused += 1; + false + } + _ => panic!("unknown outcome seed class: {name}"), + }; + assert!( + vectors[prefix] + .as_array() + .expect("cases") + .iter() + .any(|v| v["id"] == id), + "unknown canonical case: {name}" + ); + assert_eq!(verified.is_some(), expected, "{name}"); } + assert!( + accepted > 0 && refused > 0, + "both decoder paths require seeds" + ); + assert_eq!( + accepted, + vectors["accepted"].as_array().expect("accepted").len() + ); + assert_eq!( + refused, + vectors["refused"].as_array().expect("refused").len() + ); } #[cfg(unix)] diff --git a/product/runtime/auths-gateway/semantic-closure.json b/product/runtime/auths-gateway/semantic-closure.json index 8386d6aec..b880a158f 100644 --- a/product/runtime/auths-gateway/semantic-closure.json +++ b/product/runtime/auths-gateway/semantic-closure.json @@ -1 +1 @@ -{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"3fe20efcd1bcdce96861b15ffa846c845f6e8e35115a62e8ec05fc930a78fb64"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"cf7263f6b3d5f5749a76d970f0c73d3a0410832ac8f47d8770b4a4754928f21a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"dd0821e8337e56189708496ca85cc2f2da2d6a4ea8b53db5aa0412beead69864"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"d803ff53f90ce2a8c29808b4f874cd81954a3a5c52e19b519ab22f0543808fe1"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"181bf0a196805e50944cff4fe2315459eba877e7d7b5b90bf3c99e3353a8cad7"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"f7abd9464e75cca4b140272a866a548b92b469d4d080ec17559e65c6c74b7a25"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"fdf746572649f554f24089d0dd6322d964be1c12d1695dd5d9f8d86079b23a82"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"87363b666c16cef5f4566db25b3cbec93f3083b2bf8508a5c55ce78667bc4a6c"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file +{"files":[{"path":"Cargo.lock","sha256":"1b9e6f8e02fd41f6becc2158fca15854138b3bc162ad203854bc2251391da8fc"},{"path":"Cargo.toml","sha256":"ccc17deac72da945940a9ab4be2ce27628c056b977d19429bc1679b19fae30f3"},{"path":"core/adapters/auths-did-keri/Cargo.toml","sha256":"86ba3e3f9a0a70d970568bfb3113b7ba7bbdd81c3eebbb52743dd574a0c0ecaa"},{"path":"core/adapters/auths-did-keri/src/lib.rs","sha256":"a75674842f8a7142004369ccd206ab43e476459293f0ff4bed4d4e659031b3e3"},{"path":"core/adapters/auths-did-key/Cargo.toml","sha256":"d5a3ae07ecde83f91eed4c3785051dd0f44eab6c891754f3309b6b40596707d7"},{"path":"core/adapters/auths-did-key/src/lib.rs","sha256":"b76a3f4528a725df53cfa9242e6e414e1d26caa48468aaed497e28b121f4497c"},{"path":"core/adapters/auths-raw-key/Cargo.toml","sha256":"f49616bc18c19e6aaa7e6a02ccebcdb9f5c1422c1278ef9869e0dbf22ceda7be"},{"path":"core/adapters/auths-raw-key/src/lib.rs","sha256":"45eec1b295dac3bed65cd79c942870b926b06b3f5d38eaebaeb6140ac69315fa"},{"path":"core/crates/auths-algebra-kernel/Cargo.toml","sha256":"0cb078915287b8c47d20fb97b6fa14135ed1c61c4985c4de2753855563c27bba"},{"path":"core/crates/auths-algebra-kernel/src/generated.rs","sha256":"ae4bcbef42a408c7ffa0c6a74a42f7de177a6f14479e51d205acf830bda05960"},{"path":"core/crates/auths-algebra-kernel/src/lib.rs","sha256":"6654667eeb9b353d6648954c9fd2e8838462a82ce6b2803eb49e1366892c68c6"},{"path":"core/crates/auths-assurance/Cargo.toml","sha256":"afcb12a97ddd09d7a264b9ecd3fcaefc865ff2c9b4539ee85b00883420ba333a"},{"path":"core/crates/auths-assurance/src/lib.rs","sha256":"0fb2ec844d674b25a9e20b1601452c89c2454901fa506adfa9bb38ef9a7fa213"},{"path":"core/crates/auths-author/Cargo.toml","sha256":"1e6f0e3bc079ddb558decf0db26b291c6e72fc47327b6df1b7650d41689b215f"},{"path":"core/crates/auths-author/src/lib.rs","sha256":"e14475f2f49715a1869d5fa6b11ff1fbb72497e39097e09f833b0bae7e5b3f2b"},{"path":"core/crates/auths-author/src/observations.rs","sha256":"dda7d6bfa6f4bd7e95a480ca283c2c0e996f69c5c15cb0c7197af328131a7066"},{"path":"core/crates/auths-authority/Cargo.toml","sha256":"4f68212938029f79ebd857b4f3038494eb85d0163d49f07e51376715cf959815"},{"path":"core/crates/auths-authority/src/lib.rs","sha256":"da88d5194de4e17449e69972c0fb042afa3c39798a8f570f30771e77c384f1eb"},{"path":"core/crates/auths-codec/Cargo.toml","sha256":"e20e51826e17814effd9d8925d18d5fbdd6c0d37bf50231e743ec2611314722c"},{"path":"core/crates/auths-codec/src/approval.rs","sha256":"fbff43bf4d57f69f8b7738a8647751cde75c5a932dee65d924a1fe9c7202f91f"},{"path":"core/crates/auths-codec/src/bounded_policy.rs","sha256":"d21f6728be2d8a04b6d94921f2b683f7e61cbb42e0ac6866f1c88a49caa534c3"},{"path":"core/crates/auths-codec/src/decode.rs","sha256":"ba2999584cdf53b1b517ecb9c7ea50d39efee17c666a9a38e2ad1ac94379f778"},{"path":"core/crates/auths-codec/src/encode.rs","sha256":"8491192053e2e15d62b4d2a491de22405b7487ead69ab6f6bca40669ce7ca5f7"},{"path":"core/crates/auths-codec/src/error.rs","sha256":"fecb0737c16deb42d859f1dc7727c698438d9ac12064fd99e0024629642c390c"},{"path":"core/crates/auths-codec/src/hash.rs","sha256":"f88e111f1dbb2cef6b7b5e9c948cb45ff92e366710c8a5f5c636138aa748479e"},{"path":"core/crates/auths-codec/src/lib.rs","sha256":"3b0e5c94c6f34f750b88a9333e1d5c8145746d845d3a23e0d2f61807cf592ea7"},{"path":"core/crates/auths-codec/src/observation.rs","sha256":"38328b0c71ff97a4196eeade8b4faa889527ff1f80bb168468bcd49082a3987e"},{"path":"core/crates/auths-composition/Cargo.toml","sha256":"331e13025eb82588b5269ed3975929eb41c823d588c49e4c296273d85c6fe80e"},{"path":"core/crates/auths-composition/src/lib.rs","sha256":"e42e3b0b6a9985b73c533aeb23799c638979aa27a9ce7d0f10a8d60340570fb1"},{"path":"core/crates/auths-model/Cargo.toml","sha256":"565c15302b0cc9270db1e28efa3862804846850ba933cc17aea8abcec4a65987"},{"path":"core/crates/auths-model/src/approval.rs","sha256":"54cf44a9ef747ec21546a4086aecfb130bc7803b0d646430e6082df51e6e305f"},{"path":"core/crates/auths-model/src/bounded.rs","sha256":"f90496abc0a06c028b4d850af6ddab7d850bfafeaa3d042f1b1246a41d8bbbc9"},{"path":"core/crates/auths-model/src/bounded_policy.rs","sha256":"306a8f049cc7cfc7635fe0e4de47eb7813eed63d3c14c3be2b51586aa4eea450"},{"path":"core/crates/auths-model/src/lib.rs","sha256":"e7cfe6bb9574c6b016aa63e70658c31e0b90903ec6479a49f4a2ceb64f5bad97"},{"path":"core/crates/auths-model/src/observation.rs","sha256":"b3ed3e3cc090afca2896a7d3de7988afccc1ee1ea0ebd91b51a8bc0f20ad8dbb"},{"path":"core/crates/auths-multikey/Cargo.toml","sha256":"858756c1197befcada06134742bffe8d58cf674cadd6c046bf710570e96efaf2"},{"path":"core/crates/auths-multikey/src/lib.rs","sha256":"f5177fffb11e40eeaaa665ba886c541fc1f24d5eacdd6983fb03dc20148733f0"},{"path":"core/crates/auths-ports/Cargo.toml","sha256":"596a9b0f5af3717c16a6d13f7054d8a106bcd9f01f5f72c2235dd2afcf0ab16c"},{"path":"core/crates/auths-ports/src/binding.rs","sha256":"a16c012d40aa4249e3ec54372b9611006d0bfe8c7dc3c741911c2194ad17736d"},{"path":"core/crates/auths-ports/src/diagnostics.rs","sha256":"aa596572503b5a65a918bb2ff38281c144ff53821ee914e9325c852828d852df"},{"path":"core/crates/auths-ports/src/lib.rs","sha256":"8da1debf86f9532df0660155d04298beb1ba3a1204508f8586e2e67cd2fb3449"},{"path":"core/crates/auths-ports/src/path.rs","sha256":"b68fc547b4e4d97a60cbbc1cc1939fc6b34a8233b81f840bd396914a707e3ea1"},{"path":"core/crates/auths-raw-key-core/Cargo.toml","sha256":"98c0bc8527a537512e43a74dd6ba9658c6f0cdc16610cf938e3f9b43785d836d"},{"path":"core/crates/auths-raw-key-core/src/lib.rs","sha256":"98c0500c41697aae28708ad0bf970b9a97583d96a3d2c18d23e7fa351e0f7d12"},{"path":"core/crates/auths-registries/Cargo.toml","sha256":"590e49e58b0622d9d6274fea46796dcdb07dec9550eff295cce6a6427ffa51e2"},{"path":"core/crates/auths-registries/src/lib.rs","sha256":"450d3886d85ee333b7e046317fb5b47cde62483d5f3e41d46265e2caf4c373ec"},{"path":"core/crates/auths-registries/src/template.rs","sha256":"1224039dd2b3ce6fa8357613d8cafbae40400493da7176da202b9ade62fa05e4"},{"path":"core/crates/auths-signature-core/Cargo.toml","sha256":"6bee2230eb30af1be0bd5c2d57bd3e1903497a70028d47290d4ac6e9e0e8bca0"},{"path":"core/crates/auths-signature-core/src/lib.rs","sha256":"db97ecb45a82faa6f96a92738d3af1da92d1ba2f241f2c29114f4b8107dc4ab0"},{"path":"core/crates/auths-signature/Cargo.toml","sha256":"7f7b5682466ba439d8c59579022cb61068cad9fb4bd2d73e1cc21327c902b450"},{"path":"core/crates/auths-signature/src/lib.rs","sha256":"b3d9ac4cc3ba0797b9e1c09f2d6ac05089b25dac4e285a5af28c0165b33d925b"},{"path":"core/crates/auths-verifier/Cargo.toml","sha256":"c43358e06a33324b41a8b93e5cc7279c55f7d21f1f6cfaa539a3fc7b4c27a38f"},{"path":"core/crates/auths-verifier/src/approval.rs","sha256":"c3cae6a49e169051eb555bb092b1069a4d422516d6a2114623a89e5f31ff923f"},{"path":"core/crates/auths-verifier/src/causal.rs","sha256":"9635230f33b13a263573d319ac8a1976addbcc07677514a43e3c7bf28dc04587"},{"path":"core/crates/auths-verifier/src/lib.rs","sha256":"f22dec38dfa47ced8da4f605390da8453273bee1da010f57fd1fdfcb10e0b389"},{"path":"core/crates/auths-verifier/src/observation.rs","sha256":"0bb07f06a0f9524c88427df1c972b1de8ba038a9eeeb15d3134c25125ae84b1e"},{"path":"core/crates/auths-verifier/src/trace.rs","sha256":"2213d72023a1d9e0413a2cf2c51c3dad9e04775d86033a0caaa9d29a8f0036f8"},{"path":"exchange/crates/auths-proof-exchange-model/Cargo.toml","sha256":"34b2db64f93a288e942b5a3918d28cdcbef906e0dc9074ce848018d3d5f7a1fa"},{"path":"exchange/crates/auths-proof-exchange-model/src/lib.rs","sha256":"49fac5aff2339d3a57c41cb8bb2a82852538e8f77ecc4b157c88e264ff31fb55"},{"path":"exchange/crates/auths-proof-exchange-port/Cargo.toml","sha256":"7ff660f1b7579dc570c791090aeb450404fbbf44c92781e289f5ccdde746d739"},{"path":"exchange/crates/auths-proof-exchange-port/src/lib.rs","sha256":"b408fb40c6432edc1facb3d8b3e9433a033f8dc73fe2e0ba5a88c972ca675021"},{"path":"product/config/auths-config/Cargo.toml","sha256":"e4b568ab9f6d84f7d7e6d66443fe825f360db9c27bc7c31d6ddc0647ba3ab304"},{"path":"product/config/auths-config/src/lib.rs","sha256":"fecf00ea65cef9018fda9af2063326d7065b869266d0d9e73a4f06816f1102cc"},{"path":"product/errors/auths-errors/Cargo.toml","sha256":"3b3a199b6460ba75bda84475bb5accd35e1485448a3981038db85bf4772dd350"},{"path":"product/errors/auths-errors/src/lib.rs","sha256":"7feeb9069fa4003f94f1f07c1c94619cf1c883e0dbaaf2187f04d0f742264bdd"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/Cargo.toml","sha256":"716f1f2a117d6d69d8effe9ee9057e24ba3502f20af6a602b06facb638cdabed"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/api.rs","sha256":"9ea61dd7ddd93282b073b98e453e6b75b26dc49689c04e9782435d06a3a09e48"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/clock.rs","sha256":"73f0a6e0f5903883329fa6683f5888288f759512ac69e5c87efd2b6b87f7d79f"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/http.rs","sha256":"14c1fce14e24c984b2a275563a29b6326fb08367922b6e8d37ba38b9cb81aa2b"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/identity.rs","sha256":"186de11230c8b33375951c4368609f8976bf9795f171af3fd7fac26207a94361"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/lib.rs","sha256":"0b4617d044f5254a5ab22f5a2578f91cc025206a8c1845be39c1c56dcdf7a5df"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/names.rs","sha256":"41bb23572d6002e23ee103d6fe70ecd68764861c6f2e48a1c53af998270a4afa"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/sigv4.rs","sha256":"39fed883f4802e68d3b41a68fea0aba0737810996b33d13577de70faba004c29"},{"path":"product/integrations/auths-credentials-aws-secrets-manager/src/store.rs","sha256":"fc60ee9c49b2f4f063c449b4c78100c5c4872779e94ca168f796603b380ef6e4"},{"path":"product/integrations/auths-custody/Cargo.toml","sha256":"1e14034185ad1ec24a977fd5f41d0abee219606245c046ce2a82287fadef448b"},{"path":"product/integrations/auths-custody/src/conformance.rs","sha256":"13a2b28bba4a7af5b00bb96d16ecf027d35d5487b314e48a666fb8ed09c2f2e9"},{"path":"product/integrations/auths-custody/src/key.rs","sha256":"c3b1468b8538421a796aeb65a0cd94b942e3788e78741f20dde07b4838e0c3da"},{"path":"product/integrations/auths-custody/src/lib.rs","sha256":"836ad8044440fd250457a46f5c4a980339534a8af6a4daac2643560050b62d39"},{"path":"product/operations/auths-operations/Cargo.toml","sha256":"73dde1e914ba5e1386f8d49c0d730423cc72ae77ec44c6554a6a75cc8e8922b1"},{"path":"product/operations/auths-operations/src/explanation.rs","sha256":"b4a39bcbd5712cb9e735ee7deeb281f3fa6af5ddca973735bf3d87dce427ef11"},{"path":"product/operations/auths-operations/src/lib.rs","sha256":"3f401a56555113b98f57bca172a2660eaecedf76247b83a3fdbb089c133a29cd"},{"path":"product/operations/auths-operations/src/render/json.rs","sha256":"2ae042639960afee123730e945d373bc5dda1d2b3af20ae16c939a7e99b9e418"},{"path":"product/operations/auths-operations/src/render/mod.rs","sha256":"b3b7f6fe473f49227ace5a68bfc3d8dc14b5db8dd9888fd9e207070337b1b8bf"},{"path":"product/operations/auths-operations/src/render/text.rs","sha256":"f216cf3bdb00e264523271b16e7059535ac6b1aabf271cebd7935af155e4bfec"},{"path":"product/policy/auths-bounded-policy/Cargo.toml","sha256":"babd5d200923137ead71d8c2528f847cea323ce98da942a1320b054436612c47"},{"path":"product/policy/auths-bounded-policy/src/arithmetic.rs","sha256":"75e43c5d4eab8d1f71c1daf53839f5f9fe45a400afc1f63a30c6f55ce3632627"},{"path":"product/policy/auths-bounded-policy/src/commitment.rs","sha256":"c5706f2d583454e1a7f570f7ada138d4d864bef0205dfae7c1296774f396bb3f"},{"path":"product/policy/auths-bounded-policy/src/eligibility.rs","sha256":"c9acdfb793074e687fc36efad506be27dbd99ffbf40387bc66c8de39ef238432"},{"path":"product/policy/auths-bounded-policy/src/identifier.rs","sha256":"0006a32bae9eb16c4178cf797df418d2b0a781f2bc6474b741dc1a908141831c"},{"path":"product/policy/auths-bounded-policy/src/kernel.rs","sha256":"99187c28b161ac70bee1afed60711f7f645adb4d1671a01863f9849b369811d5"},{"path":"product/policy/auths-bounded-policy/src/lib.rs","sha256":"76a18638b810e62e594d6e951504679305ce21841388e0c282ad51cd7841b91c"},{"path":"product/policy/auths-bounded-policy/src/receipt.rs","sha256":"3b9eae82f349956d3e7f29b57b254bff5ce67cc703e6cf43445ce2827676d1ad"},{"path":"product/policy/auths-bounded-policy/src/registry.rs","sha256":"4e251ea5833559841f8ee0bd9b66c0c01c39fa5e3a21720a19c4e8adbfcb99d0"},{"path":"product/profiles/auths-profile-api/Cargo.toml","sha256":"7ae85761f58625b5d678f961fd052eebf3e000ef565c7312e3ac857763c0017f"},{"path":"product/profiles/auths-profile-api/src/lib.rs","sha256":"a194b82b20bf8aa864c2334ef6c6aec30b2154ded972862252d5dcefa488ab95"},{"path":"product/profiles/auths-profile-mcp/Cargo.toml","sha256":"db264fc25242f7b7e4133cbe5782545b3107b406c87168ae072683cfb59eac66"},{"path":"product/profiles/auths-profile-mcp/src/arguments.rs","sha256":"a5de696586d507e2aee4a49fee99ef1ef4c51a2e46603f8838f1af6d9009833f"},{"path":"product/profiles/auths-profile-mcp/src/lib.rs","sha256":"d0f8b733a09ef8408336cdebc8948d6a5861012ce6878598b11be7084dfd4280"},{"path":"product/profiles/auths-profile-mcp/src/session.rs","sha256":"166c281fa66333388e4760d6098dad02d3359e1d5de4b8f93312c014f97abb03"},{"path":"product/qualification/auths-recipe-qualification/Cargo.toml","sha256":"b7b15b30b9a3d96d4f089d514266d3a892de6608d30707aa44be31cca89ca9fe"},{"path":"product/qualification/auths-recipe-qualification/src/canonical.rs","sha256":"30a9b50777f0dcb4b606abfee2467d5a975d9f6ad941ab6c13ca3df5b359f667"},{"path":"product/qualification/auths-recipe-qualification/src/closure.rs","sha256":"0ad6aee9bd981e2863fa725f209ec84031db2ff12f4c7ac3aaf5120f0bb86039"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning.rs","sha256":"db135c55e4e3079a73253ebae275536523eb36b545d1c152b4d7dce3c6b76828"},{"path":"product/qualification/auths-recipe-qualification/src/commissioning/tests.rs","sha256":"4dde3736d206099b1bea4c14e0092c6c1287d1af9065958777d7c54331dd8686"},{"path":"product/qualification/auths-recipe-qualification/src/error.rs","sha256":"52d5cf720a1e4579008fdda90a3ac2c31f0b8db57985f121f65e54b4da2b7dd1"},{"path":"product/qualification/auths-recipe-qualification/src/evidence.rs","sha256":"ba45a7409d67a8af26ab811af306412014557477a101ab2a8eb0faf8f2bd4b91"},{"path":"product/qualification/auths-recipe-qualification/src/ids.rs","sha256":"e81a906d571497ab2da753e1532d4443706410e0b75fdd59a7d2d788c7aec403"},{"path":"product/qualification/auths-recipe-qualification/src/launch.rs","sha256":"805154ce931e3977f2a2a2c62909d90f7c0a22dc167bf4f1554dcf19316ffef8"},{"path":"product/qualification/auths-recipe-qualification/src/lib.rs","sha256":"0e24b0f81191df0d078c7f4d73ced784ba9472372bfcdff3c7d0e2fb1687b323"},{"path":"product/qualification/auths-recipe-qualification/src/model.rs","sha256":"3484eb0ec287b23d4682ade7b1b0f8d1335985b3fb180f06fc28716076957d5f"},{"path":"product/qualification/auths-recipe-qualification/src/release.rs","sha256":"ec478e53f70052e566aac7e15be2f9e1b1cd46837ac6990ae955fa864d311586"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/mod.rs","sha256":"1e4e5edc12d921e6b95475b3c1850f58f622c088d24a1fc9398d34019fb2f288"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/schemas.rs","sha256":"c59feec2805621f341a90f81fc005e2c12f7a70f9d264fdeacccb2be4fe1c046"},{"path":"product/qualification/auths-recipe-qualification/src/vectors/verification.rs","sha256":"bdf5746fed4d10a7f577f7878619a917d29aa8b7d522f00d9f774e53eff4c8c1"},{"path":"product/qualification/auths-recipe-qualification/src/verify.rs","sha256":"646ff0e52e915174ad183768706e35e5ce2118b83475455310b930a77a7877f6"},{"path":"product/receipts/auths-receipts/Cargo.toml","sha256":"6001fa1375899953aafcb07c23a6da0c8f57ea7ec08bb9c950b12a60a8cc6f0f"},{"path":"product/receipts/auths-receipts/src/disclosure.rs","sha256":"ba9ed439be0a320c8a01f5b6e9b51361c1a37e076947490d8e4a484ba6bb119c"},{"path":"product/receipts/auths-receipts/src/lib.rs","sha256":"547a57c4160256719cafb7d0ab972d9fc80b0da14fbbce4148c70c414070ff36"},{"path":"product/runtime/auths-connections/Cargo.toml","sha256":"babeb6e1dda3dfb66291713ce1e43dce5c349833d0b50ea4dccbf986030026b2"},{"path":"product/runtime/auths-connections/src/credential.rs","sha256":"7e6fbca8911d5c0c1baddf35572236d419566dd6e3fcbbdfda77c8dd114dbcad"},{"path":"product/runtime/auths-connections/src/kernel.rs","sha256":"a456af19526ef7b19278551fd8d97606b6e7aa5a195e70bdd85d1e0786090ce8"},{"path":"product/runtime/auths-connections/src/lib.rs","sha256":"79209249a0acba0e854d9937255ea0e30a9a6f8e1c2baad77ab83646d392de22"},{"path":"product/runtime/auths-connections/src/model.rs","sha256":"de34a089cac9702acb889b7602b3e4732306c9e61029ec892582b7e02b73fc77"},{"path":"product/runtime/auths-connections/src/registry.rs","sha256":"e57640e003e72ad3235c567c2bb944a262bd64e673f023b62ea091094cc7e946"},{"path":"product/runtime/auths-gateway-kernel/Cargo.toml","sha256":"34f864e67656af4ac7e5c7a347a23f01fc8ab31365b8e23c0ef474483b14a183"},{"path":"product/runtime/auths-gateway-kernel/src/construct.rs","sha256":"e9d65744bae273d65face4285e5d2da75c06a92ab48f7b8333d496604e31c63c"},{"path":"product/runtime/auths-gateway-kernel/src/lib.rs","sha256":"cfda6f8453426564c085475f183b6f790b438768a19668f1b65d33ba59dc8632"},{"path":"product/runtime/auths-gateway-kernel/src/order.rs","sha256":"efc2f2eef68232fe3082e1607e6f1e87d4a19cbb2f492bdc6e71916a2461b6a8"},{"path":"product/runtime/auths-gateway-kernel/src/outcome.rs","sha256":"ac0245699457c802a70cdd6f52a01dcb4777c487b58ed7dc9cfc99345465ccaa"},{"path":"product/runtime/auths-gateway-kernel/src/ratio.rs","sha256":"7ace22264812e6fc1ef3a62afee402cf43494bb71ae0d3de219ad1b39d690bcb"},{"path":"product/runtime/auths-gateway-kernel/src/recovery.rs","sha256":"9f46dcd1685ab6e4d1ba04a3fc286a9f3afee8fb47829be1fbc670a7926a2dc6"},{"path":"product/runtime/auths-gateway-kernel/src/transition.rs","sha256":"9c9c292397aa640c2f002ffb5befe110f86d0aa246f3ffe99440718e5174af3c"},{"path":"product/runtime/auths-gateway/Cargo.toml","sha256":"713a55ac7dfbc9c0d89b2d9d370278ed5f7a7a2d76460d69248db0da5c11ebdf"},{"path":"product/runtime/auths-gateway/src/admin.rs","sha256":"5d0f1b583a4cacdcbc62521ed1a5730ed6b57d42bf826708a0c5e591272c4a12"},{"path":"product/runtime/auths-gateway/src/admin_boundary_tests.rs","sha256":"7ef23fdaf512cfa6315aed72577ccf0c4d04725f5b4fa4b5f0482e27e5e7ba1c"},{"path":"product/runtime/auths-gateway/src/app.rs","sha256":"04c7f98ea3a9506fa4a2da8039455dccc4eebfb2452e7fb3c612aa2aa9bc405f"},{"path":"product/runtime/auths-gateway/src/app/content.rs","sha256":"5de081c7f31f0b1af466d500372e123f2927918d63ed2da0adc48d5c4178e8f8"},{"path":"product/runtime/auths-gateway/src/app/content_tests.rs","sha256":"6a239a15732dd279abb35a72721eb2034bf5aac79439edc7c34aa8d4fdfd5212"},{"path":"product/runtime/auths-gateway/src/audit.rs","sha256":"aebb55cfe1305c6de26fda03989e138a6731ec57d1cfebf4114886bfb6b93d26"},{"path":"product/runtime/auths-gateway/src/audit_export.rs","sha256":"6cc3d70ef4cc64026de4ec4e094979a95fee6fadb86707b0e09515ad754632be"},{"path":"product/runtime/auths-gateway/src/audit_tests.rs","sha256":"8cf1ab4cd2789973791805b07216d423690645aa4f28307f87dbcb803bd2ad22"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway-harness.rs","sha256":"12b0c24d36b2e6a3be392d3c081a783b355fdd67dc5b54bacc0410e803116b8c"},{"path":"product/runtime/auths-gateway/src/bin/auths-gateway.rs","sha256":"97c4388a3d95307e083c55152b02aaf288b3cb7b7c11ac863cd1932f274fc029"},{"path":"product/runtime/auths-gateway/src/binding.rs","sha256":"663b0ce878319511aa7d05722ab4ab2fa9be18817884ffb2ee9f131ff1e382d1"},{"path":"product/runtime/auths-gateway/src/bounds.rs","sha256":"d0658585765d4d8f9865f65d23d850ec196eeca23fe65a66a55f1f1bc9b2c9b9"},{"path":"product/runtime/auths-gateway/src/bounds_aggregate_tests.rs","sha256":"ab34f227b7c8692ba1da88ccb32bb3687a66adf8353d8282fae905d4a88eb612"},{"path":"product/runtime/auths-gateway/src/bounds_tests.rs","sha256":"80b116ccf65bda2d7f2fbcd3b26fcf82b0a4bd3dce3a5df7842828cb271d7741"},{"path":"product/runtime/auths-gateway/src/candidate_runtime.rs","sha256":"5160b5a26668d2a177cadb472f95b10a2c97d2307ac444e9be8046f01b41909d"},{"path":"product/runtime/auths-gateway/src/commissioning_budget.rs","sha256":"f5c38e9e07df3cb99b6bd664f33eae414b9f3dfef4932d69c19a9b174906dc1b"},{"path":"product/runtime/auths-gateway/src/commissioning_budget/tests.rs","sha256":"da104a1643c37515deec6397bca6db2054f2c9158ec3d230a1b1ec9c7d0f659f"},{"path":"product/runtime/auths-gateway/src/commissioning_floor.rs","sha256":"7fa6991c5ccd5ae1403be84b3da390323fab09f36e15ac01fd7a38ea350c6fdb"},{"path":"product/runtime/auths-gateway/src/commissioning_floor/tests.rs","sha256":"6b663d6e556adc0b455b81845bc4394d82c6c4de0c5f43e1310f3ddc6e4e40f7"},{"path":"product/runtime/auths-gateway/src/commissioning_session.rs","sha256":"919fe57fafa563f770402be66b4e32f1f0d652f09fe1276a62e41b50d66f8696"},{"path":"product/runtime/auths-gateway/src/commissioning_session/tests.rs","sha256":"48d44a5fccea737930f24c49a397428edc439525330c83a868b5113a48f122ab"},{"path":"product/runtime/auths-gateway/src/configuration.rs","sha256":"f6b35e3f1257d25628244d0908b9c29afea7875c4bc9ddca832a2e8cd1418f9e"},{"path":"product/runtime/auths-gateway/src/connection.rs","sha256":"5d5cc58bec7665e44c625b7a6195a35e513593681ada669294cd6bf47921143f"},{"path":"product/runtime/auths-gateway/src/credential_journal.rs","sha256":"7297fccaee5cd8622928e8e0a42bba50da7941970a6f682ecd300c41ee6509da"},{"path":"product/runtime/auths-gateway/src/disclosure_transport.rs","sha256":"614c975a4b9810f40092a2f9cdd022308b75e649167dbc486c9907f7570d8d45"},{"path":"product/runtime/auths-gateway/src/echo_verify.rs","sha256":"6d453051665f823abd7354d5c50031d9524cf47d6092d2f09080ae814e3b9575"},{"path":"product/runtime/auths-gateway/src/effect.rs","sha256":"4c67f575f7597652dbe1e27ccfedd6f9c3d09e4d146756be9b8df098b4fd3f2f"},{"path":"product/runtime/auths-gateway/src/effect/acquisition.rs","sha256":"24d73218c07db78b79fe6ad96da6acacee7aea3df68a453f39a06c5cf8298e7f"},{"path":"product/runtime/auths-gateway/src/effect/authority.rs","sha256":"2490494c3a1636decbfd04b2dbac71c47e49be26b61cc6cf41319a13450bb4a0"},{"path":"product/runtime/auths-gateway/src/effect/candidate.rs","sha256":"d1efc3ec7e1fa642af26f4e4c6a25924c60821dc2e96bd0b458d9292d3866678"},{"path":"product/runtime/auths-gateway/src/effect/candidate/proposal.rs","sha256":"d78574109f41300edfcd7ad38155439ffc3adb9a799554d75d5484738ef174f1"},{"path":"product/runtime/auths-gateway/src/effect/capacity.rs","sha256":"300fa32e09dab7c679b8c0a69bb4e3c1e924ed2ce1416090a2aa477a7eec9f0f"},{"path":"product/runtime/auths-gateway/src/effect/content.rs","sha256":"27b83afdc6b5612299f527348a50dd16ea6dce98c3f2523b596a56004850c994"},{"path":"product/runtime/auths-gateway/src/effect/disclosure.rs","sha256":"0acb5ac805e91c952c8f0028db03ae607c3753cbd08a76035f2d1b4fa6fe6244"},{"path":"product/runtime/auths-gateway/src/effect/disclosure_auth.rs","sha256":"32fa6f040ae46f3323df6e153c6ae810eccf32d22b9945e5565e7189dc877eac"},{"path":"product/runtime/auths-gateway/src/effect/prerequisite.rs","sha256":"fbeaab5f5422becbfeeff5c94d41a3bb99a2dd9c571c23895a594c2a3b4cd1fa"},{"path":"product/runtime/auths-gateway/src/effect/release.rs","sha256":"fd841cbce131136acd888bf35f08d0dc6ba524f98a24bdeb9ee5c20bcb81fe4d"},{"path":"product/runtime/auths-gateway/src/effect_binding_boundary_tests.rs","sha256":"83d8e0edf524a2be0d2c494e4b9897cab0ddcf61184828d716bae10cbaf904b4"},{"path":"product/runtime/auths-gateway/src/effect_candidate_staging_tests.rs","sha256":"12d16a9d2752a1791c8814be1857db9f6703d8e368da3bad1d6fd128be01cb28"},{"path":"product/runtime/auths-gateway/src/effect_candidate_tests.rs","sha256":"55f85891a8559fe3dea618b09f6e790749b406c8fee501306a57837af6319ab6"},{"path":"product/runtime/auths-gateway/src/effect_content_tests.rs","sha256":"59d10b48daa531bb7f46b0d30e077476c83ecdf4bddfdf3c3bda0621ca176f6f"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_delivery_tests.rs","sha256":"9586b84b045561edbcf8276cd9769b412240f04248e240cd29a5068d4cd03a00"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_journal_tests.rs","sha256":"a044537d6ee65bf3a3c3e650199d1c9ac18955ef6b6e6ef0d5793f4a5c3a253a"},{"path":"product/runtime/auths-gateway/src/effect_disclosure_tests.rs","sha256":"5389b03d7d0cd5b23abaa3c396450fa4018102c942b27af35aef81e65b9bb841"},{"path":"product/runtime/auths-gateway/src/effect_native_tests.rs","sha256":"cf7263f6b3d5f5749a76d970f0c73d3a0410832ac8f47d8770b4a4754928f21a"},{"path":"product/runtime/auths-gateway/src/effect_prerequisite_tests.rs","sha256":"0e76695c5d00c6806de7f1edc9d873d036d837c1fd0989530b820a41b1beb472"},{"path":"product/runtime/auths-gateway/src/effect_read_budget_tests.rs","sha256":"9bf8491f0da471e07b5d96dbfdbdf5fbe5a47fec11700dca55a6ac05a1ebb68b"},{"path":"product/runtime/auths-gateway/src/effect_recovery_prerequisite_tests.rs","sha256":"e6235b83ac159d9446d79e6e072dd4aa9d0447a68055be3b32de6450a2300699"},{"path":"product/runtime/auths-gateway/src/effect_review_approval_tests.rs","sha256":"6e5c5a72ec93255d7d8f219ae8cf4401431644ff03d624164645a1e9d2b2e87e"},{"path":"product/runtime/auths-gateway/src/engine.rs","sha256":"58525d87087da11ac8c86d4765e2af51f5176898f244e189a48188c61c578851"},{"path":"product/runtime/auths-gateway/src/entry.rs","sha256":"053e4cce4f63d4406eea47b536af4d344bcee073844827390aa6b4eb43c69638"},{"path":"product/runtime/auths-gateway/src/entry_tests.rs","sha256":"6fdd7a0373b3eca51d3062682f1187ee1318add7d2a1eb0e6b0a05ea36dadaae"},{"path":"product/runtime/auths-gateway/src/execution_witness.rs","sha256":"e8b1a8e41d5e3fa309760067849d390ef065feeb46701a83391832645a2f000c"},{"path":"product/runtime/auths-gateway/src/fuzzing.rs","sha256":"2dcf0a15e407a9180c7fecb7eecfaf4674698aa997b1f5de9a3649a49baebd1b"},{"path":"product/runtime/auths-gateway/src/generation_floor.rs","sha256":"3e82c3832685c43b546ebd12857ebecbfa6be29d8749654ab65e3e520ad552fb"},{"path":"product/runtime/auths-gateway/src/harness.rs","sha256":"94469e437df7b296bb12a4f311cf4bbfdbaaed31bf72983e83136f4b3707b34d"},{"path":"product/runtime/auths-gateway/src/harness/authoring.rs","sha256":"de511d89bf6bb72e443558caf0c4835dad2908b5fe5c13a3a02483e85dd7d354"},{"path":"product/runtime/auths-gateway/src/lib.rs","sha256":"c03c3a73276ace55b9b8aa1dd3dc6ae56b3f01850ff2a4526d70ab38797b40ee"},{"path":"product/runtime/auths-gateway/src/listener.rs","sha256":"aa08239bcbc1fcb55e8a212fbdf6a84f12985b0d436dcb51dc58b06e59e435f2"},{"path":"product/runtime/auths-gateway/src/native_budget_tests.rs","sha256":"d6de965afc7f794e611545744fa515f833abf315157519ed8390c195a7dac8c0"},{"path":"product/runtime/auths-gateway/src/native_cost_store.rs","sha256":"d1acdd7e4076e3a32f312dce74a01e5dcbccdb1f8912758524b7841d61377eed"},{"path":"product/runtime/auths-gateway/src/native_cost_tests.rs","sha256":"45bcb4e9174d4c23495ac734a42b5f8b7735c14d4599cd191d50f6547aaf374c"},{"path":"product/runtime/auths-gateway/src/native_crash_tests.rs","sha256":"46998a973388884d902a6b07e12fa342fb08ea77363a43a41b0b0a7a5ccbcde9"},{"path":"product/runtime/auths-gateway/src/native_dependency_tests.rs","sha256":"a8aafce830175c7aa26b3831076703265af8dcbec9ad7b7f34a851c9bc4ebc96"},{"path":"product/runtime/auths-gateway/src/native_differential_tests.rs","sha256":"4c9ef638d4eb38c564ed94d0c6cdc7cf0ede0bff669face453fa58809c1174f1"},{"path":"product/runtime/auths-gateway/src/native_disclosure_budget_tests.rs","sha256":"bb2a6f76f06a6d42d69698f7d22d0b4aeb4dc857e442042d65582097567009fb"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_testkit.rs","sha256":"4beb946a288e4fe082cc0917f4200b18b8154eff98eca1ea3d0c830ffdc3625d"},{"path":"product/runtime/auths-gateway/src/native_disclosure_crash_tests.rs","sha256":"425e423f04d92794656d4da915125e4d0a8be25ec85fb88244ee0c27ece8ec44"},{"path":"product/runtime/auths-gateway/src/native_disclosure_entry_tests.rs","sha256":"50f5dc35a9a8ef462b8833296cb313b2acec81d544b7e317c7f188741d0786db"},{"path":"product/runtime/auths-gateway/src/native_disclosure_file_fault_tests.rs","sha256":"72d67bb0d3fd77fb93c4f5d3ab0afa5a939742b5a47acf006a511d99d72cee9f"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_batch_tests.rs","sha256":"a8b8a90210d9f7f0012e40701c09c524527f93f9e56933d89b58a38464cba702"},{"path":"product/runtime/auths-gateway/src/native_disclosure_pg_commit_tests.rs","sha256":"1e14503140805c12883e1c288b75029aa7fd9ebe8c5d490a4c503161c4a27a4b"},{"path":"product/runtime/auths-gateway/src/native_epoch_tests.rs","sha256":"e37d34e699baa2b84578bd4c378975dbdceb407de51861c2217afdcf7b48e3b9"},{"path":"product/runtime/auths-gateway/src/native_file_fault_tests.rs","sha256":"e1077a0059aa69918fb7e0a3481edd19af45a7343ce876583fbdbc96c4291b21"},{"path":"product/runtime/auths-gateway/src/native_generated_history_tests.rs","sha256":"5a5e308c1e4bc32cac31badf91e9453bed62e3e90f1b6585fc522bb4038990f9"},{"path":"product/runtime/auths-gateway/src/native_guarded_mutation_crash_tests.rs","sha256":"5329f72e7f22399a17627b058c2035c243e1b6ba60c9dfcd1c834258244cc440"},{"path":"product/runtime/auths-gateway/src/native_information_journal_tests.rs","sha256":"dd0821e8337e56189708496ca85cc2f2da2d6a4ea8b53db5aa0412beead69864"},{"path":"product/runtime/auths-gateway/src/native_information_replay_tests.rs","sha256":"71edb47c63d194950d9898107487bd36b3f3eeba8405ff81d85cec2af2d2ecf5"},{"path":"product/runtime/auths-gateway/src/native_journal_tests.rs","sha256":"d803ff53f90ce2a8c29808b4f874cd81954a3a5c52e19b519ab22f0543808fe1"},{"path":"product/runtime/auths-gateway/src/native_mutation_budget_tests.rs","sha256":"41d7f560d6b04e750acb2f8add2544745743ea9fea760a8ffd5ec5aab307e94c"},{"path":"product/runtime/auths-gateway/src/native_mutation_crash_tests.rs","sha256":"3e1befd35e7264024666331b52ca2245540ffa8f9927ed62e3aa45c7c8cc8950"},{"path":"product/runtime/auths-gateway/src/native_mutation_entry_tests.rs","sha256":"219a1986cf7440d31734db9db3c25f7997486a2fc29fee0a1ac8c7f0ee9ce803"},{"path":"product/runtime/auths-gateway/src/native_mutation_file_fault_tests.rs","sha256":"252f6ca9455b291b0873d983c8fccc75254d947b89a3fe9a1de0155c8ee53930"},{"path":"product/runtime/auths-gateway/src/native_mutation_journal_tests.rs","sha256":"181bf0a196805e50944cff4fe2315459eba877e7d7b5b90bf3c99e3353a8cad7"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_batch_tests.rs","sha256":"137f0e2f0e8d950cea3b38a7a03113c61177e54083f11eecc34b994ce41728f1"},{"path":"product/runtime/auths-gateway/src/native_mutation_pg_commit_tests.rs","sha256":"5d9a3b8a1601c83c66db3aefd904c16233ce2700d070ba5c9c4f81f4051c5fad"},{"path":"product/runtime/auths-gateway/src/native_mutation_replay_tests.rs","sha256":"3a874e1416cbb29cce70930f9955a70b4a5ad46e2cbca8d55f1acf070215cfbd"},{"path":"product/runtime/auths-gateway/src/native_partial_upload_tests.rs","sha256":"5fa867219d61b7c8a563e7cf5111291f15b8a11464623859be8aa9ea858170ea"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_proxy.rs","sha256":"1c95b3f8af48b78dc4f1c1baa3b26c1aa7bbe868c23aefbb32f1f0ae592f0045"},{"path":"product/runtime/auths-gateway/src/native_postgres_commit_tests.rs","sha256":"f021b110991ba3ae497705d0aaa0350a210f09b6f102fd71ac2f8eb4ff8f30c0"},{"path":"product/runtime/auths-gateway/src/native_postgres_fault_tests.rs","sha256":"0c6edea869a20765b322fa69c48e580aa0664e726b6cef483d4eba49803135ba"},{"path":"product/runtime/auths-gateway/src/native_process_tests.rs","sha256":"44c41da202499180fb9ab8d8f10bf5efc5c12f7a2c1fb9397f31e7eaf08c3425"},{"path":"product/runtime/auths-gateway/src/native_public_evidence_tests.rs","sha256":"dac3a70f4535a14aab49ceed5a6b5fd7002e199270bb5a120f5bc8edfa5398bf"},{"path":"product/runtime/auths-gateway/src/native_recovery_actor_tests.rs","sha256":"bfdcdbaa0ee1d6822c57e5ab9ca524e731c393f9289c5508b61a0fc1d0b065e5"},{"path":"product/runtime/auths-gateway/src/native_recovery_authoring.rs","sha256":"9f4e8008160b349a52267eacd6a1c1e5c31c3c1cdfd71b574162ccaa9f7430b6"},{"path":"product/runtime/auths-gateway/src/native_recovery_history_tests.rs","sha256":"0c6ec8fe18fd4cc8496f04c3bc38552c3602d7254cae979fac76aeb7c7e4f41b"},{"path":"product/runtime/auths-gateway/src/native_recovery_limits_tests.rs","sha256":"f147c2e78cbe364fb3fd0c97bbbacdad86d77ca8c0b8575d9fa108968f82379a"},{"path":"product/runtime/auths-gateway/src/native_result_wire_cases.rs","sha256":"2b93c8ed96d7092216410bb99435411fd57497284639f56e0120b16639a98eb2"},{"path":"product/runtime/auths-gateway/src/native_retention_tests.rs","sha256":"93844bfe86b2983f9b26134154d9148c641ad9120bd294ebdaf648ead5ba2666"},{"path":"product/runtime/auths-gateway/src/native_scope_tests.rs","sha256":"8d3f362df9fadc10c22f0483f3a16d238d0f82f393a628727adf0b728707673e"},{"path":"product/runtime/auths-gateway/src/native_threshold_testkit.rs","sha256":"74e6b6ed1b77b463effff132fd8af9b3b59aeee64704a8fe8a19ed3ca9d79bf7"},{"path":"product/runtime/auths-gateway/src/observed_tests.rs","sha256":"91223493fefd3efc3fec58db225f00786b539e3b24027419e919d8bd7310059c"},{"path":"product/runtime/auths-gateway/src/observer.rs","sha256":"1c8988dd8807566d5a152e1894aa0f4c80c3ba7302ac910a4a6978d4f31b323d"},{"path":"product/runtime/auths-gateway/src/onboarding.rs","sha256":"6180e79d7698bcd4dd6ffdf32dcfbe14427f96de92f4ae4ceac4dda651f3671b"},{"path":"product/runtime/auths-gateway/src/operator.rs","sha256":"fe3b11fcf8e2394ab955b09a5b9b1f979c46f9e07a4f16e1a3ca160d675f1ace"},{"path":"product/runtime/auths-gateway/src/pending_vectors/attempts.rs","sha256":"e4c08fda8ea764701ab7b07285260c770da5f585c1e2adc406216eca79095120"},{"path":"product/runtime/auths-gateway/src/pending_vectors/bounds.rs","sha256":"e612217307e1da5b0eb5ee6582a7458bb064b8aa8a529fc6555b1b334127ab68"},{"path":"product/runtime/auths-gateway/src/pending_vectors/codes.rs","sha256":"6fb3f1679b0fd2ca7a8ac6aaee65f586b9eb809d9d7c9e26d3dd8ae2bfd10307"},{"path":"product/runtime/auths-gateway/src/pending_vectors/keys.rs","sha256":"b0b1f79d2fadc06e91378a8250223a429163138e4b86e90e09bc207d80fabf86"},{"path":"product/runtime/auths-gateway/src/pending_vectors/mod.rs","sha256":"5de8340f0ef71a0b57a09e323fefe473d3160c6ae952b9ba46f714825fbacafc"},{"path":"product/runtime/auths-gateway/src/pending_vectors/outcomes.rs","sha256":"a8960d8e055ac31827e379513f57f00ed868b559079fa2a4687e1b055d48e3ca"},{"path":"product/runtime/auths-gateway/src/pending_vectors/production.rs","sha256":"95d8e5f51383fcc6e9a1209b89fe1d9c5bd1dc2b9c8424d1f151ab94976db381"},{"path":"product/runtime/auths-gateway/src/pending_vectors/recipes.rs","sha256":"5d550e3708ea41a9547ae2207699bde5ff4435f5a1ed7afa4378fb8defb51bb4"},{"path":"product/runtime/auths-gateway/src/pre_entry.rs","sha256":"3f2554feda72fa047229d427504676a1fb14894bdd377055a3108d7b3e3587cd"},{"path":"product/runtime/auths-gateway/src/prerequisite_race_tests.rs","sha256":"683cc46b3718d12dbb42668dae4bc6ec7e7508dcbb6b6232fead2e3e4f510d0d"},{"path":"product/runtime/auths-gateway/src/property_tests.rs","sha256":"85a77aaf01d9be51e1dd7c72461653a099c51b0ca9c818800d991abe262b198a"},{"path":"product/runtime/auths-gateway/src/qualification.rs","sha256":"30686268fee3d3ddc49301e58b779368f6cb6d3b38e6277d86728f8b7102af3e"},{"path":"product/runtime/auths-gateway/src/qualification_simulation.rs","sha256":"4b6961472fb825e535a64f0b6eb92278cb50036755dfa03e8a63ce8dd00827ae"},{"path":"product/runtime/auths-gateway/src/qualification_tests.rs","sha256":"2712cac071c15dd20ed28159a63f8c6488f9d8221d8c34c3f54577f1a6831913"},{"path":"product/runtime/auths-gateway/src/quorum_tests.rs","sha256":"a6533de9bc2689ec632f009404daf363494e224e7b89b1c65bb2e2cd4fc6421d"},{"path":"product/runtime/auths-gateway/src/readiness.rs","sha256":"911c3f11892f94641574375e2da4c671c802738f71082f12c39832331052d43d"},{"path":"product/runtime/auths-gateway/src/recipe.rs","sha256":"fdfc6a1eda078f3c1bbc35bf019a34c78395611d8e3c4ece5f382aa795024a35"},{"path":"product/runtime/auths-gateway/src/recipe/content.rs","sha256":"e3f8aa8cf2dd9ef5777d9d1e76331052c67be87873db0c2cd6a8f48ff940d9d6"},{"path":"product/runtime/auths-gateway/src/recipe/effect_review.rs","sha256":"8f94896f0d124162d3dbd080c44582bb23ad181bb582ff5cd3d049d75fcb6d77"},{"path":"product/runtime/auths-gateway/src/recipe/lower.rs","sha256":"81118ea7ae6c2d9984b88fe9991f91283070859d56923ee4fdfe9a50eee9ccb1"},{"path":"product/runtime/auths-gateway/src/recipe/response.rs","sha256":"0b4a074eb05b98685697094ed4775c5fe588b3e34f954aa1844135fe14c94487"},{"path":"product/runtime/auths-gateway/src/recipe/review.rs","sha256":"efb557741edc08d7c53770299afdb9c13a07de28426290030210c3da26826c0b"},{"path":"product/runtime/auths-gateway/src/recipe/runtime.rs","sha256":"0853711dc8549b2ed6949e09faca15163f9ed708e3129d1ca55e0c450cab76cd"},{"path":"product/runtime/auths-gateway/src/recipe/source.rs","sha256":"2fa3605998a959ccb61e1042dda81e5bc0d2e553af38e15101cff109621b0f4e"},{"path":"product/runtime/auths-gateway/src/recipe/tests.rs","sha256":"c4cf62a9f882071f9cec205d074953f758c6492121911a62e0dad19f4aed5348"},{"path":"product/runtime/auths-gateway/src/recipe/validate.rs","sha256":"c1a0393c0afbadbad01f119fb9257020abea686916c992c7e8a18dc92627f4f4"},{"path":"product/runtime/auths-gateway/src/scenario_tests.rs","sha256":"cefbaefaffb3147ac43acae67c2b2c9f30ed2bb1c014af29083d02e43e482312"},{"path":"product/runtime/auths-gateway/src/separation.rs","sha256":"be9306848ca5d801767cf6aa14247c8618312ef0e202f00ce0c24c4844491061"},{"path":"product/runtime/auths-gateway/src/simulation_attestation.rs","sha256":"88705e5d45415f760f1e3c3a065c35c48f4f4065bf7b3feb7882246983814d6f"},{"path":"product/runtime/auths-gateway/src/store.rs","sha256":"fdf746572649f554f24089d0dd6322d964be1c12d1695dd5d9f8d86079b23a82"},{"path":"product/runtime/auths-gateway/src/store/acquisition.rs","sha256":"56ee776420bbd00312f732a97a4f342c1b953605290c7c5a1a10497669786e05"},{"path":"product/runtime/auths-gateway/src/store/acquisition/candidate.rs","sha256":"4300b9ab31986d1150ef93050cf5b827e84d9a34c60fd19ea474d7d5a01fc984"},{"path":"product/runtime/auths-gateway/src/store/acquisition/content.rs","sha256":"92f87e4556335af8e1c4157e60e6936ca02b271381569e14510bc2c35e697ece"},{"path":"product/runtime/auths-gateway/src/store/acquisition/recovery.rs","sha256":"87363b666c16cef5f4566db25b3cbec93f3083b2bf8508a5c55ce78667bc4a6c"},{"path":"product/runtime/auths-gateway/src/store/capacity.rs","sha256":"d25c4a0d753317270cb352246c70642bf0659e6448d14061356e4e9ea7ed3811"},{"path":"product/runtime/auths-gateway/src/store/disclosure.rs","sha256":"6c8f0b788501dbacf1d51ac5adc78e35c40e0bd51b7fe84c97f1609f1008744a"},{"path":"product/runtime/auths-gateway/src/store_retention_tests.rs","sha256":"a9e300fde3c45999764ee05c4c6ea46cfb9ffcaa51b82337a322925ad50f4f50"},{"path":"product/runtime/auths-gateway/src/store_testkit.rs","sha256":"5bcdabc1c67c4d44f124786edab0d0a97c6dbd22a25df0ba576cdc30e88f5b50"},{"path":"product/runtime/auths-gateway/src/submit.rs","sha256":"06d554107f389a1e445ef0505d12ee75d557132a25be17bdda0da0071fe73bfd"},{"path":"product/runtime/auths-gateway/src/support.rs","sha256":"d4865f95a7a2fdfe297f3f73687c05ab64a6b911814daf5f2b6c703ce58262ce"},{"path":"product/runtime/auths-gateway/src/transport.rs","sha256":"0ad16c63c19cc41d11c485625c8fc0617aede21401d16ec814401f963538bb46"},{"path":"product/runtime/auths-kernel-runtime/Cargo.toml","sha256":"926bcd0053e5edd703be8f0027ad009e2982db013c8174c1366edbf38b48087d"},{"path":"product/runtime/auths-kernel-runtime/src/lib.rs","sha256":"7108faae9ca4bc32dc093ddaf885ac8f74f3c9b8d317b7c7d0ed00d1d0ab5972"},{"path":"product/runtime/auths-lifecycle/Cargo.toml","sha256":"c5053c705f8d5554b44e432fe75287a2faf11d644e5a2552e45ad6cd94176af5"},{"path":"product/runtime/auths-lifecycle/src/codec.rs","sha256":"51c4b746749150e8bfcd8ff972b3f6c1ef40bec15583448ec1b471d9ad737dc0"},{"path":"product/runtime/auths-lifecycle/src/digest.rs","sha256":"55282cd7d8aba37713c2dcb5357c9877819edb72a30eadefb860d28d7d3a3eb7"},{"path":"product/runtime/auths-lifecycle/src/identifier.rs","sha256":"31620e8c16de68d3d2d3b84d6353c1a5b9d4151d8247f91fa389b906a8e660f1"},{"path":"product/runtime/auths-lifecycle/src/kernel.rs","sha256":"2abb8c094b36d35b364e74d78091d14c5d6f3d1eb6552cca3b5538dbd017ce23"},{"path":"product/runtime/auths-lifecycle/src/lib.rs","sha256":"afe5a345cd309b5a4f08ffba3170a6d7f16ff914892b3f2006d5208ed24ec736"},{"path":"product/runtime/auths-lifecycle/src/model.rs","sha256":"1af12bbeeeaa65ec02ddcebd7d2c8c92ec1e339fa40ae85b45ab9b01a722a4fa"},{"path":"product/runtime/auths-lifecycle/src/operation.rs","sha256":"78e6d05fcf5d7ea4f148032a3fa26fdfcab77eb346019effe927b08e0d64d732"},{"path":"product/runtime/auths-lifecycle/src/registry.rs","sha256":"53495fe6f7a77422593a41623e28716f1c140dcc1e00f87f6b0ffbfb93a5ef90"},{"path":"product/runtime/auths-lifecycle/src/sealed.rs","sha256":"2e0c03b5813c926c159598bb7890d1523825edbe57cd687d42a5dfb3374a0c19"},{"path":"product/runtime/auths-lifecycle/src/test_support.rs","sha256":"221d9a5c5ef8e1f9f8fd66927484eaf813571d0568470278ecd8fa08a5eec8cd"},{"path":"product/runtime/auths-lifecycle/src/transition.rs","sha256":"011805a28efdd541f44ccea54dd0e34a1e58f4004447ee58013703b4fb6b2822"},{"path":"product/runtime/auths-runtime/Cargo.toml","sha256":"dd29d80a8b4bb56c869f036a6c9998f6e6d1c0383ac5dc03fa42b24abe2a7ff7"},{"path":"product/runtime/auths-runtime/src/lib.rs","sha256":"132ca03d58c14905d3a822a4972f42a22a5ad33a45f2ba9ca44f3a57d810b4b0"},{"path":"product/runtime/auths-runtime/src/production.rs","sha256":"fd4eff4270c571c10fcff6cf27df28961ebf074de8a1a028f500fda1ca376820"},{"path":"product/sdk/auths-approval-quorum/Cargo.toml","sha256":"df904971fca87a24194c5816738a331588fe8f164acb5d70839a35dca5f57114"},{"path":"product/sdk/auths-approval-quorum/src/lib.rs","sha256":"72e4086088a1c0912e4e1a9e980f26a5c280bf5ab16ea39c9f0f58d5096ac2ce"},{"path":"product/sdk/auths-approval-quorum/src/remote.rs","sha256":"9fa029c7c63003adf260f8aec55160c545681c60c1bace0d934e7525862aac7b"},{"path":"product/sdk/auths-approval-quorum/src/remote_tests.rs","sha256":"8a09ce17cfee82a035a74edd535f3ebeb3db0e078784740d3997b17dbdb10197"},{"path":"product/sdk/auths-approval-quorum/src/tests.rs","sha256":"0acbf12be3e497dcc6c2d8f29c9af3b1a7ed8e11b75f6399570d4f217a785060"},{"path":"product/stores/auths-stores/Cargo.toml","sha256":"a32c4b76d17b264be5d40d24497ff237e1ed87822e8bab86229b3db93106dbe3"},{"path":"product/stores/auths-stores/src/gateway_attempt.rs","sha256":"f39dc84a238db0ebc70ad1ac495da194d2c24b5e1f9905552a9b1143278725a9"},{"path":"product/stores/auths-stores/src/lib.rs","sha256":"40c280a5ff79bfc1cafcf0bb415e775e205637c526973eb94b43a30f86d4e6fe"},{"path":"product/stores/auths-stores/src/lifecycle.rs","sha256":"4033f69a8d36de9285b87ab86af363fc85f785918ec2042d0ef1bdcb64d6f73a"}],"schema":"auths.gateway-semantic-closure/1"} \ No newline at end of file diff --git a/product/runtime/auths-gateway/src/app.rs b/product/runtime/auths-gateway/src/app.rs index 7e9961a3e..a05f5a9f2 100644 --- a/product/runtime/auths-gateway/src/app.rs +++ b/product/runtime/auths-gateway/src/app.rs @@ -879,6 +879,16 @@ mod tests { for (name, frame) in [ ("recover", valid.clone()), ("submit", valid["submission"].clone()), + ( + "observe-pre-entry", + serde_json::json!({"schema": APP_OBSERVE_SCHEMA, + "request": {"kind": "pre-entry", "operation_id": "refund-1"}}), + ), + ( + "observe-outcome", + serde_json::json!({"schema": APP_OBSERVE_SCHEMA, + "request": {"kind": "outcome", "operation_id": "refund-1"}}), + ), ( "obsolete-read-back", serde_json::json!({"schema": APP_OBSERVE_SCHEMA, diff --git a/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs b/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs index ce258ab6b..62618230a 100644 --- a/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs +++ b/product/runtime/auths-gateway/src/pending_vectors/outcomes.rs @@ -753,6 +753,32 @@ fn public_document() -> Value { "verdict_trusted_context_b64":Base64UrlUnpadded::encode_string(&context),"verdicts":verdicts}) } +/// Keep every positive and refusal seed bound to the canonical native signer. +/// Obsolete committed seeds remain separate decoder-refusal controls. +fn require_public_fuzz_corpus(document: &Value) { + let directory = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/target_gateway_outcome"); + for prefix in ["accepted", "refused"] { + for entry in document[prefix].as_array().expect("outcome cases") { + let name = format!("{prefix}-{}", entry["id"].as_str().expect("case name")); + let bytes = Base64::decode_vec( + entry["observation_b64"] + .as_str() + .expect("canonical observation"), + ) + .expect("base64"); + let path = directory.join(&name); + if std::env::var_os("AUTHS_UPDATE_FIXTURES").is_some() { + std::fs::write(&path, &bytes).expect("write outcome seed"); + } + assert!( + std::fs::read(path).expect("committed outcome seed") == bytes, + "{name} must be the exact canonical signed vector" + ); + } + } +} + #[test] fn public_outcome_v3_vectors_are_current() { let document = public_document(); @@ -775,4 +801,5 @@ fn public_outcome_v3_vectors_are_current() { ); } require_current("outcome-v3.json", &document); + require_public_fuzz_corpus(&document); } diff --git a/product/runtime/auths-gateway/src/semantic_closure.rs b/product/runtime/auths-gateway/src/semantic_closure.rs index 316070f31..865bf5733 100644 --- a/product/runtime/auths-gateway/src/semantic_closure.rs +++ b/product/runtime/auths-gateway/src/semantic_closure.rs @@ -10,7 +10,7 @@ /// SHA-256 of the schema, a NUL byte, and `semantic-closure.json`. /// Regenerate through `semantic_closure_is_current` with `AUTHS_UPDATE_FIXTURES=1`. pub const GATEWAY_SEMANTIC_CLOSURE_SHA256: &str = - "61173a0020911d7fb40fe9870a81b9b19a3641b1f5c406c0eeb9b9db3a3b88aa"; + "4c368d74e5a748ac79752bf9f2da2cbb3447c9ec67755147c80c03a0856a3d81"; #[cfg(test)] mod tests { From b54ed0902cfc3d82bc19e49542e826389583f182 Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 08:47:19 +0900 Subject: [PATCH 135/136] docs(ap074): record verified cold Lean producer and final gate boundary --- docs/plans/0074-final-acceptance-audit.md | 4 +- docs/plans/0074-final-coding-checklist.md | 4 +- docs/plans/0074-hosted-evidence-eb44d8f7.md | 128 ++++++++++++++++++++ docs/plans/0074-implementation-status.md | 15 ++- docs/plans/0074-lean-reuse-contract.md | 31 +++++ 5 files changed, 174 insertions(+), 8 deletions(-) create mode 100644 docs/plans/0074-hosted-evidence-eb44d8f7.md diff --git a/docs/plans/0074-final-acceptance-audit.md b/docs/plans/0074-final-acceptance-audit.md index 50bae9a80..9a2f24a80 100644 --- a/docs/plans/0074-final-acceptance-audit.md +++ b/docs/plans/0074-final-acceptance-audit.md @@ -30,10 +30,10 @@ subsequent repaired head. | P2/P3, R01–R10, A01–A17/A21 | All 63 required native selectors execute exactly once with one pass and zero failures/ignored tests on file and TLS PostgreSQL; process, capacity, crash, partial-upload, ambiguous-commit, epoch/floor, recovery, ACK and 64-event cases | Final broad repaired-head gate and conditional formal/runtime audit | | A18 | Native journal/frame/binding limits and shared 209-vector binding corpus execute; broad gateway library passes 302 tests, zero failures and 63 ignored; separately, all 63 required native selectors and 30 additional PostgreSQL conformance/hostile tests pass | Two stale positive fuzz seeds require native-constructor repair, obsolete refusal controls and repaired hosted corpus confirmation | | A19 | Two mutation recipes: 28 request and 26 response comparisons; acquisition/disclosure: 22 pairs after eight named native histories; all 12 reference source hashes match | Repaired-head confirmation with references still independent | -| A20 | Four-seed concurrent histories per adapter: 32 positive and four negative rounds, 72 workers, independent HTTP/transport-count and historical-byte oracles | Clean source-linked Lean/329-claim audit, translation, Kani49 and applicable formal/release adequacy gates; final consumer qualification | +| A20 | Four-seed concurrent histories per adapter: 32 positive and four negative rounds, 72 workers, independent HTTP/transport-count and historical-byte oracles | Clean source-linked Lean/329-claim audit, two translation reproductions and Kani49 passed; final formal aggregation passed; consumer qualification remains pending at publication | | A22 | Installed Airtable: 36 cases/13 verified private audits; Stripe: 23/6, zero inconsistent/unverified. Linux distinct-UID: 33 application cases, 12 admin commands, 53 CLI routes, five private CLI refusals and actual credential/provider/file/privacy controls | Final repaired-head installed/platform confirmation | | P4 cost and bounded work | Eight samples per path/backend with actual verification, compilation, approval, callback, adapter, inventory, snapshot-size and Linux RSS distributions | Preserve actual producer and limits; these fixtures establish no production latency or heap SLO | -| Lean reuse | Complete-input/provenance refusal controls; fresh fast Lean bootstrap passed | Clean authoritative producer, then observed reuse by both Lean jobs while current Rust/source checks still run | +| Lean reuse | Complete-input/provenance refusal controls; fast and clean authoritative Lean bootstrap passed with authenticated complete-input artifact | Observed reuse by both consumer Lean jobs while current Rust/source checks still run, pending at publication | All twelve applicable workflows outside main CI passed on this source. The conditional live-custody workflow was skipped and provides no live qualification. diff --git a/docs/plans/0074-final-coding-checklist.md b/docs/plans/0074-final-coding-checklist.md index 6550b475e..61259f925 100644 --- a/docs/plans/0074-final-coding-checklist.md +++ b/docs/plans/0074-final-coding-checklist.md @@ -10,9 +10,9 @@ Source `eb44d8f7` passed all 63 required adapter selectors, installed journeys, distinct-UID containment and differential/cost/history workflows. Its broad implementation gate found two stale committed fuzz positives. Native constructors now generate the complete repair with explicit obsolete refusal controls; hosted -confirmation remains required. Preserve the live clean Lean producer, then combine +confirmation remains required. The clean Lean producer now passed with its complete-input attestation. Combine this repair and evidence reconciliation in one follow-up publication to establish -actual Lean reuse. Both unchecked final items remain open until its gates pass. +actual Lean reuse; consumer results remain pending at publication. Both unchecked final items remain open until its gates pass. ## Checks to finish writing diff --git a/docs/plans/0074-hosted-evidence-eb44d8f7.md b/docs/plans/0074-hosted-evidence-eb44d8f7.md new file mode 100644 index 000000000..462a7293e --- /dev/null +++ b/docs/plans/0074-hosted-evidence-eb44d8f7.md @@ -0,0 +1,128 @@ +# AP074 hosted evidence: eb44d8f7 + +Status at publication: the eb44 native, installed and clean formal producers below are verified. Its implementation gate retains the obsolete-corpus failure; the repaired consumer head must pass its own complete gates and both real Lean reuse checks. This is producer evidence, not final acceptance. + +Source `eb44d8f7082db6ed9ab46c1bf5319e8e736d7b28`; GitHub PR merge producer `8335af6a6f9170a12f4b63feae0f755e87290308`; both tree `195e1ae19c0491af1c7e8fdd6d0c63b87655fe89`. Merge parents are protected base `e2d10a74fa0be5e6bfe2b9f698632c835cd7b11b` and source eb44. Native closure `61173a0020911d7fb40fe9870a81b9b19a3641b1f5c406c0eeb9b9db3a3b88aa`; formal source closure `fe66a1c24450b555e7e28d775c5796b68bc0d896445181343c6f8178d3f43751`; freeze 432. + +All twelve applicable workflows outside CI passed. Conditional custody-live41924978034 is skipped and provides no live-provider evidence. Main CI41924977969 is terminal with its known corpus failure. The complete cohort has 96 checks: 85 success, 3 failure and 8 conditional skips. Fast Lean126908887765 passed at22:49:58UTC after the fresh build beginning22:34:06UTC. Kani126913912984 passed at 23:01:31UTC with all49harnesses; translation126913912807 passed at 23:10:35UTC after two byte-identical reproductions. Authoritative clean Lean126929527493 ran23:10:39–23:38:21UTC and passed; its clean rebuild step started23:14:08UTC. No manual reruns/cancellations or new publication occurred after eb44. + +## Workflow inventory + +| Workflow | Run | Current result | +| --- | --- | --- | +| Airtable gateway demo | [41924977955](https://github.com/auths-dev/auths-proof/actions/runs/41924977955) | success | +| CI | [41924977969](https://github.com/auths-dev/auths-proof/actions/runs/41924977969) | failure: corpus root and dependent rollups | +| Gateway custody live | [41924978034](https://github.com/auths-dev/auths-proof/actions/runs/41924978034) | skipped | +| Gateway isolation | [41924977909](https://github.com/auths-dev/auths-proof/actions/runs/41924977909) | success | +| Gateway operator package | [41924977942](https://github.com/auths-dev/auths-proof/actions/runs/41924977942) | success | +| Git signing branch-protection action | [41924978062](https://github.com/auths-dev/auths-proof/actions/runs/41924978062) | success | +| Git signing protocol | [41924978149](https://github.com/auths-dev/auths-proof/actions/runs/41924978149) | success | +| Google read demo installed images | [41924978033](https://github.com/auths-dev/auths-proof/actions/runs/41924978033) | success | +| PostgreSQL lifecycle qualification | [41924978051](https://github.com/auths-dev/auths-proof/actions/runs/41924978051) | success | +| Python SDK package | [41924977978](https://github.com/auths-dev/auths-proof/actions/runs/41924977978) | success | +| Recipe qualification | [41924978037](https://github.com/auths-dev/auths-proof/actions/runs/41924978037) | success | +| SDK outcome recipes | [41924978031](https://github.com/auths-dev/auths-proof/actions/runs/41924978031) | success | +| Stripe gateway demo | [41924978136](https://github.com/auths-dev/auths-proof/actions/runs/41924978136) | success | +| TypeScript SDK package | [41924978104](https://github.com/auths-dev/auths-proof/actions/runs/41924978104) | success | + +## Conditional skips and scope + +All eight skipped jobs require `github.event_name == workflow_dispatch` and `github.ref == refs/heads/main` in their checked-in workflows. This cohort is a PR event on `codex/effect-recovery-foundation`, so neither condition is met. These are explicit inapplicable live/operator release paths for this PR event; their skipped status supplies no passing, provider, retained-operator or signed-release evidence. The installed simulations and required native/platform gates are separately executed above. + +| Skipped job | Workflow and excluded operation | +| --- | --- | +| [verify as a gateway would (126912127149)](https://github.com/auths-dev/auths-proof/actions/runs/41924978037/job/126912127149) | recipe-qualification: verify a manually signed live qualification release | +| [sign the complete cleaned qualification release (126912126680)](https://github.com/auths-dev/auths-proof/actions/runs/41924978037/job/126912126680) | recipe-qualification: sign the cleaned live release | +| [independently review finite commissioning (${{ matrix.family }}) (126912125017)](https://github.com/auths-dev/auths-proof/actions/runs/41924978037/job/126912125017) | recipe-qualification: independent finite commissioning review | +| [independently sign first qualification (${{ matrix.family }}) (126912124758)](https://github.com/auths-dev/auths-proof/actions/runs/41924978037/job/126912124758) | recipe-qualification: independent first-qualification signing | +| [retained production operator (${{ matrix.family }}) (126912124717)](https://github.com/auths-dev/auths-proof/actions/runs/41924978037/job/126912124717) | recipe-qualification: retained production operator | +| [gateway journey against Stripe test mode (126906932637)](https://github.com/auths-dev/auths-proof/actions/runs/41924978034/job/126906932637) | gateway-custody-live: actual Stripe test-mode provider journey | +| [store-contract (126906880394)](https://github.com/auths-dev/auths-proof/actions/runs/41924978034/job/126906880394) | gateway-custody-live: manually dispatched production credential-store contract | +| [gateway journey on the production credential store (126906879308)](https://github.com/auths-dev/auths-proof/actions/runs/41924978034/job/126906879308) | gateway-custody-live: production credential-store journey | + +## Actual native and installed evidence + +[PostgreSQL lifecycle job126906875975](https://github.com/auths-dev/auths-proof/actions/runs/41924978051/job/126906875975) passed. Its actual complete retained log matches all 63 required selectors exactly once with one passed/zero failed/zero ignored:48 ordinary,11 final-hardening,2 cost and2 generated-history. Both newly required native review and64-event boundary selectors executed. The additional production connection-process test and 30-store hostile/conformance suite passed separately. Physical-with-WAL restore to a named restore point reports before-target retained and after-target excluded; replay-continuity claim is explicitly false. Connection-generation and exact-record floors protect only their stated state: an unchanged connection floor does not establish safe automatic managed resume after point-in-time rollback of attempt/counter rows. The physical-WAL rehearsal proves before/after storage behavior, not whole-journal replay/accounting continuity. + +The independent mutation report compares28 requests and26 responses across maintained Airtable/Stripe recipes. All seven source hashes match this checkout. The information report compares22 pairs after actual execution of the eight named file/PostgreSQL histories; its five source hashes and native-log hash match. Its source_commit is the verified merge producer, whereas installed/cost/history reports explicitly retain source and/or checkout separately. None is relabeled as a different producer revision. + +Generated histories retain four seeds and eight concurrent rounds per seed per adapter (32 positive rounds and four negative pairs). Independent expected effect entries agree with actual HTTP and write-transport counts. Distinct OS workers and retained historical-byte preservation hold in every round; each seed has four distinct effects plus the baseline HTTP entry, with fresh-operation/old-approval refusal leaving the source unchanged. These are deterministic generated fixtures, not exhaustive concurrency exploration. + +The actual Linux distinct-UID report covers33 application cases,12 admin commands,53 CLI routes and5 private CLI refusals. Initial 45/replay 49 private files remain inaccessible. It reports no new custody/provider entries, direct provider refusals, recipient identity/key checks before content, trusted recipient positive control, no plaintext/encoding/raw-digest sentinel leakage,0600 private export, one verified audit entry and overwrite refusal. + +Airtable source-free installed simulation passes 36 cases with 13 verified private audit entries, zero inconsistent/unverified. All owner-browser positive assertions hold: consent withholding/decline/substitution, exact native renderer, private owner credentials, one write and separate read, Python+TypeScript acquisition, separate disclosure consent/native recipient ACK, private content, no replay delivery, same actor across operations and unknown-response/fresh-process controls. Stripe passes 23 cases with 6 verified audit entries, zero inconsistent/unverified. Both explicitly decline production/live-provider/human-attention qualification. + +## Verified artifact archives + +All ZIP SHA-256 values below match GitHub's authenticated artifact metadata; run metadata binds the exact source head. Only bounded named reports/logs were read. Private nested audit packets were not copied into this report. + +| Artifact | GitHub ID | ZIP SHA-256 | +| --- | --- | --- | +| Linux distinct-UID | 13369196614 | `b58fb2bf2087540b0cded52e54ac07a3ea1c6d658a0a66bb26e6643ab6426f67` | +| Mutation differential | 13368214676 | `2f12aad26dcbebd9dd3122159aea9f67869dd536dbd5fd4e53d65f0df81a93cd` | +| Final hardening | 13370235387 | `1901e57fe4081450b9398a28622fdc5634784d00d5fa4948e8c7607e1b8e520f` | +| Generated histories | 13369825985 | `4c44f92f269c0988d8cb9e7afe9f32da23d0130ae7be2ea20ccacbbef7061963` | +| Native cost | 13369072499 | `668af902c3b2ebeecff308eb2933d60f1c679af2bfb2b49e658958c6065affcd` | +| Information differential | 13368772949 | `18e9449e053625c7c019d1c5b08379774e3435297e98986e7fe87cbe05211e8b` | +| Airtable installed | 13368319829 | `b8d0d631a952d3647b8ee338db6b5df0e603941b182e925604f9d09ad310acbd` | +| Stripe installed | 13369173481 | `60aeed41d3b8054e83d2f69111fdfce3beee70f26d55db570258ddc64ab77bfa` | +| Fast Lean log | 13370357973 | `d20e5620c8de7d5d36513e8869b27e029330749ff670a79942f2771e3dbe2b0f` | +| Kani phase | 13370384762 | `5f9b7dea6ddf6313592d36da7dff15700fb6ca792f4d3408130ae77c197bb963` | +| Translation phase | 13371652840 | `68184973fcad190b9fc0c289a8960665f38b7bda87b7ae6ef0317a0f5488b5fa` | +| Translation qualification | 13370803802 | `bcb31f244dbfa513eedd33ea06dd0be1c10176c4ce64214a2aadb4b54760e537` | +| Clean authoritative Lean phase | 13373617020 | `f2a256d1be842c86af7cf057b0e46e989e2029f5a4504ca18b2ecf093fd6818c` | +| Final formal evidence | 13373479017 | `7ac7d07e3b21228650318811c6d54bf09dbc6febbd4e4e793f806b567f52fb8a` | + +## Native cost measurements + +Eight test-profile samples per path/backend; timings are min/median/max milliseconds, not production SLOs. Adapter and fenced callback totals sum compilation plus execution calls per sample. Snapshot and RSS columns are maxima. + +| Backend/path | Verify ms | Compile incl verify ms | Approval ms | Fenced callback ms | Adapter ms | Max snapshot bytes | Max RSS KiB | +| --- | --- | --- | --- | --- | --- | --- | --- | +| file/mutation | 0.888/0.946/0.979 | 3.040/3.116/3.142 | 0.238/0.239/0.325 | 11.359/11.660/16.188 | 14.362/14.800/20.507 | 4538 | 34092 | +| file/recovery | 0.870/0.884/0.912 | 8.627/8.885/8.975 | 0.222/0.224/0.251 | 37.588/38.156/40.827 | 42.149/42.811/54.645 | 12032 | 34136 | +| file/acquisition | 0.937/0.958/1.518 | 4.627/4.699/7.423 | 0.232/0.245/0.260 | 18.533/18.745/18.960 | 22.289/22.587/22.934 | 7330 | 35516 | +| file/disclosure | 0.889/0.920/0.945 | 4.114/4.189/4.255 | 0.239/0.242/0.263 | 37.878/38.435/38.691 | 41.773/42.379/52.188 | 16717 | 35580 | +| postgres/mutation | 0.916/0.955/1.179 | 4.250/4.337/5.506 | 0.237/0.241/0.270 | 11.451/11.750/13.926 | 24.247/25.036/34.465 | 4538 | 38940 | +| postgres/recovery | 0.874/0.922/0.960 | 10.415/10.585/11.005 | 0.223/0.227/0.239 | 38.249/38.478/40.621 | 63.532/64.258/66.230 | 12032 | 39000 | +| postgres/acquisition | 0.902/0.940/1.665 | 5.699/5.804/6.515 | 0.231/0.233/0.261 | 18.692/18.941/19.462 | 34.708/40.561/50.609 | 7330 | 41756 | +| postgres/disclosure | 0.903/0.928/0.959 | 5.222/5.313/5.754 | 0.238/0.240/0.253 | 38.566/39.142/45.296 | 54.699/55.373/64.891 | 16692 | 41816 | + +file mutation_recovery: 8 measured inventories; native decode+inventory ms 16.346/51.331/88.234; max attempts 17, limit 4096; max RSS 34136 KiB. + +file acquisition_disclosure: 8 measured inventories; native decode+inventory ms 17.950/79.608/142.396; max attempts 16, limit 4096; max RSS 35580 KiB. + +postgres mutation_recovery: 8 measured inventories; native decode+inventory ms 17.703/63.310/99.874; max attempts 17, limit 4096; max RSS 39000 KiB. + +postgres acquisition_disclosure: 8 measured inventories; native decode+inventory ms 20.013/86.463/155.022; max attempts 16, limit 4096; max RSS 41816 KiB. + + +Raw artifacts bind source eb44, merge8335, native closure61173 and the current test profile. They report actual native verification, compile, approval, adapter/callback timings, buffer lengths and Linux RSS; these eight-sample fixtures are not production SLOs or adversarial throughput guarantees. + +## Assurance citation audit + +The parent independently compared977→eb44 assurance manifest text. Masking only the 59 existing `kind=source-closure` citations to `formal/qualification/aeneas/source-closure.json` makes the remaining text byte-identical. All 59 current hashes equal raw source-closure file SHA-256 `685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601`. No theorem, axiom, claim, review or semantic binding changed. This agrees with the local complete typed-manifest negative controls; metadata refresh does not constitute proof qualification. + +## Verified clean Lean producer + +[Authoritative Lean job 126929527493](https://github.com/auths-dev/auths-proof/actions/runs/41924977969/job/126929527493) completed successfully at 23:38:21UTC. Its actual log records the compiled audit of329 statements with transitive axioms reviewed, Aeneas qualification with four reviewed external links and zero compiled external axioms, and four passing Rust refinement tests. The clean rebuild executed; no cached phase was accepted. + +Artifact 13373617020 has exactly one member, `lean.json`. Authenticated archive SHA-256 is `f2a256d1be842c86af7cf057b0e46e989e2029f5a4504ca18b2ecf093fd6818c`. Its immutable source is eb44, run 41924977969, attempt 1; `execution=executed-clean`, `reproduction_count=0`, and no `reused_from`. Complete proof inputs are `c523f465540e306ac9eaaf49ef460365b467be4bccaafd2160552ce23dc83432`, exactly matching the repaired native computation. Planned Lean closure is `9a9be86efddb2a9db4ee16ed2c25233dce5d56437c7e4395c93f347908472ddc`; toolchain closure is `baff1cabbf9c83ffca0f4bdb1b8dda685a5ac59638e95d6d12e57f5d5bda9633`; evidence closure is `1c446639f484deacf0dc54fbd94da4ec6aceaa69e8e50432ae05696f123c0dbd`. The native reuse validator must independently validate these fields and current source/refinement checks at the consumer; this successful producer is not itself a warm hit. + +## Remaining qualification + +Main CI authoritative workspace has the corpus failure documented below. Final formal evidence 126942117729 passed at 23:46:11UTC; artifact 13373479017 attests execution=aggregated for the exact source/run/attempt and matching closures. Clean authoritative Lean and its compiled 329-claim audit passed. Qualified rollup126945531900 failed because AUTHORITATIVE=failure from the corpus root; its other listed formal, compliance, dependency, secrets and live-adapter dependencies are success. The three failures are implementation126913912856 and its derivative authoritative126917977445/qualified126945531900 rollups, not three independent roots. Fast Lean, both translation reproductions and all 49 Kani harnesses have passed. The authenticated translation phase reports execution=executed/reproduction_count=2; its qualification record retains zero compiled external axioms and four reviewed external models with all seven case modules. With the successful cold producer preserved, the required corpus repair/final evidence update must demonstrate both Lean phases reuse matching verified evidence while current-head Rust/source checks still execute. No warm hit is claimed yet. AP074 is incomplete pending final acceptance; AP070 stays independent and AP073 untouched. + +## Actual authoritative corpus root and repair + +Authoritative implementation126913912856/rollup126917977445 failed after the gateway library passed 302 tests, zero failed and 63 ignored in 38.35s. Both failures are in `auths-gateway-fuzz --test corpus`: the committed `observed-by-provider-after-response` seed predates public outcome/3, and `observe-pre-entry` still uses observe/3 instead of/4. Dynamic xtask campaign seeds already use current native fixtures/schemas. The repair binds committed positive/refused outcomes to the existing native canonical signer, keeps old bytes as explicit obsolete refusal controls, and binds current observation frames to the existing native frame constructor. No decoder or assertion is relaxed. No xtask/formal/controller/Cargo input changes are needed; the healthy eb44 proof producer is preserved. Focused complete repair verification passed: both authoritative native seed constructors and unchanged checks, all six fuzz corpus tests, native source-closure update/rebuilt check, formatting and semantic metadata construction. The canonical signed outcome corpus now has 14 current positives,8 current refusals and2 preserved obsolete seeds; current observation frames coexist with the preserved obsolete/3 refusal. No release identity or formal source/assurance file changed. Corrected-head hosted qualification remains pending. + +Repair results: `/tmp/ap074-ci-eb44-repair/results.json`. No broad workspace, Lean or Kani suite was rerun locally. The successful hosted clean proof record is eligible for independently validated reuse because the repair changes only native gateway test/corpus/source-inventory files. + +The repaired native gateway closure is `4c368d74e5a748ac79752bf9f2da2cbb3447c9ec67755147c80c03a0856a3d81`. The actual native `auths_ci_plan::formal_proof_inputs_digest` function was evaluated read-only against published main eb44 and the repaired isolated tree: both return `c523f465540e306ac9eaaf49ef460365b467be4bccaafd2160552ce23dc83432`. This establishes unchanged complete proof inputs for the seed repair; it is not a synthesized or qualified phase result. The future hosted warm path must independently repeat that validation and all current-head checks. + +The two 63 counts name different inventories: 32 library-ignored cases are in the 63 explicit native selectors; another 30 ignored cases passed in the PostgreSQL conformance/hostile suite. The remaining ignored `scenario_tests::conformance_child_process` is deliberately spawned by both file/PostgreSQL conformance parents, twice for submit and twice for batch. Those parents require successful child exits and exact `RACE` witnesses. Their passing hosted results establish the child executions through this harness; there is no separately invented standalone helper run. + +## Consumer verification boundary + +The corrected consumer head must pass its own required implementation, installed SDK/demo, native adapter, formal aggregation and two validated Lean reuse gates. Those consumer results are pending at publication of this report. The final live verification record is the exact published head shown in [PR213 checks](https://github.com/auths-dev/auths-proof/pull/213/checks), with its immutable run/job/artifact identities recorded in the PR validation notes and retained authenticated final-head report. Passing producer evidence above is not relabeled as consumer execution. Recording that consumer outcome does not require a recursive documentation-only push. diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 6ca0b0c5b..84d915edb 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -4137,13 +4137,20 @@ Repeated Lean work on each push came from the PR-wide formal planner and fresh jobs. Both Lean phases now support a successful, same-PR, clean authoritative producer with authenticated immutable provenance and the native complete-input digest; current Rust/source checks still run, and any missing or mismatched -evidence falls back to fresh verification. Fast bootstrap Lean has passed; clean -authoritative Lean/compiled audit and the remaining formal gates are pending. +evidence falls back to fresh verification. Fast bootstrap Lean, two translation reproductions and all49Kani harnesses +have passed. Clean authoritative Lean126929527493 also passed with329compiled +statements/transitive-axiom audit and four Rust refinement tests. Its authenticated +artifact13373617020 attests the complete proof key below. Final formal aggregation also passed. The overall old CI remains failed solely +for the known corpus root and its dependent rollups (85success/3failure/8skips). +Consumer-head qualification remains pending at publication. No warm hit is claimed before actual execution. The seed repair changes no proof inputs: the native digest is unchanged at `c523f465540e306ac9eaaf49ef460365b467be4bccaafd2160552ce23dc83432`. -Preserve that live producer and combine seed repair, evidence report and this -acceptance reconciliation into one follow-up publication for warm verification. +Preserve that successful producer and combine seed repair, evidence report and +this acceptance reconciliation into one follow-up publication for warm verification. +The exact-head [PR213 checks](https://github.com/auths-dev/auths-proof/pull/213/checks) +and immutable final validation records will record consumer results without a +recursive documentation-only push; no pending gate is represented as passing. The physical-WAL restore test explicitly reports `replay_continuity=false`. Connection-generation/exact-record floors protect their stated state, not an diff --git a/docs/plans/0074-lean-reuse-contract.md b/docs/plans/0074-lean-reuse-contract.md index c8d7a4301..aef6b9920 100644 --- a/docs/plans/0074-lean-reuse-contract.md +++ b/docs/plans/0074-lean-reuse-contract.md @@ -84,3 +84,34 @@ the retained actualce9 run accepts its same-PR association, then explicitly reje its old phase for missing complete-input attestation. No native validator or qualified result was invoked or synthesized for that legacy artifact. No early20b failed check was observed before this correction. + +## Verified cold producer and pending consumer + +The corrected controller's real bootstrap is source `eb44d8f7`, CI run41924977969, +attempt1. Fast Lean126908887765 passed; translation126913912807 reproduced twice; +Kani126913912984 verified49harnesses. Authoritative Lean126929527493 completed its +clean build and329-statement compiled audit successfully at23:38:21UTC. Final +formal evidence126942117729 also passed; the three old CI failures all derive +from the known corpus root (85success/3failure/8conditional skips). The +[producer evidence report](0074-hosted-evidence-eb44d8f7.md) records immutable +source/merge identities and authenticated artifact hashes. The old overall CI +retains its separate, repaired corpus failure; a successful clean producer job +is the reuse predicate, not a false claim that the entire old CI passed. + +Clean Lean artifact13373617020 contains only `lean.json`, with ZIP SHA-256 +`f2a256d1be842c86af7cf057b0e46e989e2029f5a4504ca18b2ecf093fd6818c`. +It attests `executed-clean`, no reuse chain, source eb44/run41924977969/attempt1, +and complete inputs +`c523f465540e306ac9eaaf49ef460365b467be4bccaafd2160552ce23dc83432`. +The actual native digest function returns this same key for the held corpus +repair and final documentation. No producer result was synthesized locally. + +At publication of this report, real warm hits in both consumer Lean jobs and +complete final-head qualification are still pending. The legitimate follow-up +combines the required corpus repair with final evidence documentation. Both jobs +must independently validate the retained producer, rerun current Rust/source +checks and retain current-head provenance before skipping only the expensive +Lean rebuild. Missing/mismatched evidence must still fall back to fresh work. +Final results belong to the exact head in [PR213 checks](https://github.com/auths-dev/auths-proof/pull/213/checks) +and its immutable validation records; no recursive docs-only publication is +needed merely to record the outcome of the commit containing this report. From 28ecb46d0ec81a2a2e402d582aea4e757d7b77ce Mon Sep 17 00:00:00 2001 From: bordumb Date: Thu, 5 Nov 2026 09:13:27 +0900 Subject: [PATCH 136/136] fix(ci): initialize pinned Lean dependencies before reuse --- .github/ci/README.md | 9 ++ .github/workflows/ci.yml | 11 +- docs/plans/0074-implementation-status.md | 19 +++ docs/plans/0074-lean-reuse-contract.md | 33 +++++ formal/assurance-manifest-v1.toml | 118 +++++++++--------- .../qualification/aeneas/source-closure.json | 4 +- release/semantic-freeze-versions.toml | 10 +- release/semantic-freeze.json | 18 +-- xtask/src/formal_qualification.rs | 69 ++++++++++ 9 files changed, 211 insertions(+), 80 deletions(-) diff --git a/.github/ci/README.md b/.github/ci/README.md index d2fd5579a..dc1b2db2c 100644 --- a/.github/ci/README.md +++ b/.github/ci/README.md @@ -122,3 +122,12 @@ GitHub's run-associated PR object contains a mutable current head snapshot. It establishes PR/repository membership, not the historical source SHA. The immutable run, exact-attempt successful job, artifact metadata and phase record must all agree on the producer source; changing any one remains a cold miss. + +Both Lean jobs prepare the pinned toolchain and Lake dependency checkout before +attempting reuse. The current-head validator audits the actual Aeneas package +commit, clean worktree and reviewed warning inventory; a fresh checkout cannot +perform those checks before dependency setup. Setup/cache restoration is not +proof qualification. Only the expensive repository proof compilation remains +conditional on a successful independently validated reuse result. Missing or +invalid packages still fail closed, and the native workflow guard requires this +unconditional order in both jobs. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8500cf963..eac1efdab 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -281,6 +281,9 @@ jobs: with: toolchain: 1.97.1 compiler-cache: "false" + - id: lean-setup + name: Prepare pinned Lean dependency audit + uses: ./.github/actions/setup-lean - id: lean-reuse name: Validate successful same-PR clean Lean evidence if: github.event_name == 'pull_request' @@ -291,9 +294,6 @@ jobs: AUTHS_FORMAL_TOOLCHAIN_CLOSURE_SHA256: ${{ needs.ci-plan.outputs.formal_toolchain_digest }} AUTHS_FORMAL_EVIDENCE_CLOSURE_SHA256: ${{ needs.ci-plan.outputs.formal_evidence_digest }} run: python3 .github/scripts/reuse-formal-lean.py - - id: lean-setup - if: steps.lean-reuse.outputs.reused != 'true' - uses: ./.github/actions/setup-lean - name: Compile the highest-value proofs, then the complete Lean libraries if: steps.lean-reuse.outputs.reused != 'true' shell: bash @@ -627,6 +627,9 @@ jobs: with: toolchain: 1.97.1 compiler-cache: "false" + - id: lean-setup + name: Prepare pinned Lean dependency audit + uses: ./.github/actions/setup-lean - id: lean-reuse name: Validate successful same-PR clean Lean evidence if: github.event_name == 'pull_request' @@ -637,8 +640,6 @@ jobs: AUTHS_FORMAL_TOOLCHAIN_CLOSURE_SHA256: ${{ needs.ci-plan.outputs.formal_toolchain_digest }} AUTHS_FORMAL_EVIDENCE_CLOSURE_SHA256: ${{ needs.ci-plan.outputs.formal_evidence_digest }} run: python3 .github/scripts/reuse-formal-lean.py - - uses: ./.github/actions/setup-lean - if: steps.lean-reuse.outputs.reused != 'true' - name: Clean and rebuild authoritative Lean evidence if: steps.lean-reuse.outputs.reused != 'true' shell: bash diff --git a/docs/plans/0074-implementation-status.md b/docs/plans/0074-implementation-status.md index 84d915edb..068b4a9ba 100644 --- a/docs/plans/0074-implementation-status.md +++ b/docs/plans/0074-implementation-status.md @@ -4161,3 +4161,22 @@ clock, OS isolation and external-provider assumptions remain explicit. AP070 stays an independent, narrower application-owned reference; AP073 is untouched. The goal remains incomplete until final applicable gates and the P/E/R/A audit close. No merge, deployment or live-provider qualification is claimed. + + +## Final reuse dependency-order correction + +The b54 consumer passed all twelve applicable non-main workflows and retained +all63 required native selector passes, differential/installed/containment/cost +artifacts. Its first real Lean reuse attempt safely refused because the native +warning audit required the pinned Aeneas checkout before workflow setup created +it. This was an optimization defect; no proof or runtime security check was +bypassed. The [reuse contract](0074-lean-reuse-contract.md) records the exact +retained refusal and complete correction: unconditional pinned setup before both +validators, expensive proof compilation still conditional, fresh-checkout/order +regressions and unchanged package/provenance/fingerprint requirements. + +The corrected executor has a new complete proof key and needs fresh hosted +qualification followed by real reuse in both jobs. Local affected checks pass; +no warm result is inferred. Final acceptance remains open until those actual +corrected-head gates and implementation results pass. Publication of this source +repair is necessary; it is not a documentation-only retry of an unchanged build. diff --git a/docs/plans/0074-lean-reuse-contract.md b/docs/plans/0074-lean-reuse-contract.md index aef6b9920..60fdf3daf 100644 --- a/docs/plans/0074-lean-reuse-contract.md +++ b/docs/plans/0074-lean-reuse-contract.md @@ -115,3 +115,36 @@ Lean rebuild. Missing/mismatched evidence must still fall back to fresh work. Final results belong to the exact head in [PR213 checks](https://github.com/auths-dev/auths-proof/pull/213/checks) and its immutable validation records; no recursive docs-only publication is needed merely to record the outcome of the commit containing this report. + +## Actual first-consumer dependency-order correction + +The b54 consumer exposed a real warm-path miss: fast Lean completed reuse +validation and then entered fresh setup. The native current-head validator audits +`formal/.lake/packages/aeneas` for the exact pinned commit, clean status and +reviewed warning inventory, but the workflow previously created that dependency +checkout only after a reuse miss. A fresh hosted checkout therefore could not +satisfy the intended audit. Both jobs now prepare pinned dependencies before +validation; the expensive repository proof build remains conditional. No warning, +commit, signature, provenance, current-source or refinement check is removed. +Fresh-checkout and both-job order regressions reject omitted, late, conditional +or ignored setup. The complete executor fingerprint is retained: this correction +changes proof inputs and requires a new successful clean producer before another +real warm verification. The eb44 successful proof remains valid for its exact +inputs; it is not silently reinterpreted under this corrected executor. + +The retained b54 fast-job log confirms the refusal at00:03:19UTC: `git rev-parse +HEAD` could not run in the absent Aeneas package directory. The affected batch +passes27 native qualification tests, workflow ownership and strict xtask Clippy; +metadata construction/non-update verification and formal source-closure check +pass after advancing only the generator-reported counters. Freeze433 advances +assurance bytes63, source-closure bytes108, evolution86 and public surface433; +runtime protocol/SDK identities are unchanged. Exactly59 existing source-citation +hashes changed, with all remaining manifest bytes identical. + +Corrected formal source closure is +`09fb135d91c47ff1b2a873b583564db3467e76973c9763090bac2affd73b6837`; +the actual complete native proof-input key is +`9b5a7049779384207399e43d927cef5ccd856dce925ba80242c1bc0a25f929aa`. +No local Lean/Kani run or corrected hosted warm success is claimed. The healthy +old fallback may be superseded after remaining current implementation results +are collected: its old executor key cannot qualify this correction. diff --git a/formal/assurance-manifest-v1.toml b/formal/assurance-manifest-v1.toml index 8fa264c52..37d89c524 100644 --- a/formal/assurance-manifest-v1.toml +++ b/formal/assurance-manifest-v1.toml @@ -8733,7 +8733,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-055" @@ -8854,7 +8854,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-056" @@ -8989,7 +8989,7 @@ sha256 = "2bb401ffca0136622cd79bb14a5a38852061649a06cc46100503870c22d300c7" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-104" @@ -10463,7 +10463,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-263" @@ -10559,7 +10559,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-264" @@ -10658,7 +10658,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-186" @@ -10918,7 +10918,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-237" @@ -11014,7 +11014,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-238" @@ -11113,7 +11113,7 @@ sha256 = "ba7aea214063b8a698fbd2c9c8cd95a717bf0ec0eaef70a92844444bf7e9f22e" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-175" @@ -15601,7 +15601,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-211" @@ -15696,7 +15696,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-212" @@ -15792,7 +15792,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-213" @@ -15888,7 +15888,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-214" @@ -15984,7 +15984,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-232" @@ -16083,7 +16083,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-233" @@ -16179,7 +16179,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-234" @@ -16275,7 +16275,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-235" @@ -16371,7 +16371,7 @@ sha256 = "8c6c2ab1a63280e94f4084566888d727b13a5890b9de4c75aa90322406c5c601" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-249" @@ -17038,7 +17038,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-257" @@ -17137,7 +17137,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-258" @@ -17236,7 +17236,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-259" @@ -17332,7 +17332,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-260" @@ -17431,7 +17431,7 @@ sha256 = "dfa1998e3506f06dce142222dc383116d0952155517edc399f5d94e688e22912" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-070" @@ -24429,7 +24429,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-189" @@ -24525,7 +24525,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-190" @@ -24621,7 +24621,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-191" @@ -24717,7 +24717,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-192" @@ -24812,7 +24812,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-193" @@ -24911,7 +24911,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-194" @@ -25010,7 +25010,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-195" @@ -25111,7 +25111,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-196" @@ -25215,7 +25215,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-197" @@ -25320,7 +25320,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-198" @@ -25416,7 +25416,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-199" @@ -25521,7 +25521,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-200" @@ -25616,7 +25616,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-201" @@ -25711,7 +25711,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-271" @@ -25807,7 +25807,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-272" @@ -25903,7 +25903,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-273" @@ -26002,7 +26002,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-274" @@ -26101,7 +26101,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-275" @@ -26202,7 +26202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-276" @@ -26302,7 +26302,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-277" @@ -26401,7 +26401,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-278" @@ -26501,7 +26501,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-279" @@ -26600,7 +26600,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-280" @@ -26701,7 +26701,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-281" @@ -26801,7 +26801,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-282" @@ -26901,7 +26901,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-283" @@ -27001,7 +27001,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-284" @@ -27100,7 +27100,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-285" @@ -27202,7 +27202,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-306" @@ -27298,7 +27298,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-307" @@ -27397,7 +27397,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-308" @@ -27493,7 +27493,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-309" @@ -27592,7 +27592,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-310" @@ -27692,7 +27692,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-311" @@ -27791,7 +27791,7 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" [[claims]] claim_id = "AP-FORMAL-RICH-312" @@ -27892,4 +27892,4 @@ sha256 = "d4d36b72718a4076b7c0561abfa2edc006a1f9a4491762979f86c3dd99a71fdc" [[claims.evidence]] kind = "source-closure" artifact = "formal/qualification/aeneas/source-closure.json" -sha256 = "685fdbfd0d91ae329300d15dbd2d3469b101a358137c8e37dbed35e3559d4601" +sha256 = "229b327c87cecc1405b12dcf0d2b36e733629c8bb5f96b1762fa1fe6d075b769" diff --git a/formal/qualification/aeneas/source-closure.json b/formal/qualification/aeneas/source-closure.json index cbff7ac63..dcd2dd29a 100644 --- a/formal/qualification/aeneas/source-closure.json +++ b/formal/qualification/aeneas/source-closure.json @@ -1,6 +1,6 @@ { "schema": "auths-proof-translation-source-closure/v2", - "digest": "fe66a1c24450b555e7e28d775c5796b68bc0d896445181343c6f8178d3f43751", + "digest": "09fb135d91c47ff1b2a873b583564db3467e76973c9763090bac2affd73b6837", "files": [ { "path": ".cargo/config.toml", @@ -337,7 +337,7 @@ }, { "path": "xtask/src/formal_qualification.rs", - "sha256": "82bb07a8a20fdb2bc9c54d1c26837e8968cf5dd02b5aec1483634071742a1c21" + "sha256": "5565f25fb5e321d32baf8bd9ac028348aa47fe16864824973fceca7c69ed45cd" }, { "path": "xtask/src/fuzz.rs", diff --git a/release/semantic-freeze-versions.toml b/release/semantic-freeze-versions.toml index 919170c14..87969022f 100644 --- a/release/semantic-freeze-versions.toml +++ b/release/semantic-freeze-versions.toml @@ -1,4 +1,4 @@ -freeze_version = 432 +freeze_version = 433 # Semantic identity counters live outside the xtask source tree deliberately. # The formal source closure binds xtask's executable code, while the semantic @@ -16,10 +16,10 @@ freeze_version = 432 "auths.frozen-bytes/core/fixtures/v1/manifest.json" = 15 "auths.frozen-bytes/core/formal-vectors/v1/manifest.json" = 1 "auths.frozen-bytes/demos/benchmarks/profiles/release.toml" = 1 -"auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 62 +"auths.frozen-bytes/formal/assurance-manifest-v1.toml" = 63 "auths.frozen-bytes/formal/qualification/aeneas/generated" = 20 "auths.frozen-bytes/formal/qualification/aeneas/qualification.toml" = 17 -"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 107 +"auths.frozen-bytes/formal/qualification/aeneas/source-closure.json" = 108 "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json" = 1 "auths.frozen-bytes/product/conformance/v1/simplified-product-waist.json" = 4 "auths.frozen-bytes/product/fixtures/v1/bounded-policy/manifest.json" = 3 @@ -66,5 +66,5 @@ freeze_version = 432 "auths.product.simplified-waist" = 20 "auths.product.vocabulary" = 30 "auths.release.benchmark-contract" = 1 -"auths.release.evolution-contract" = 85 -"auths.release.public-surface" = 432 +"auths.release.evolution-contract" = 86 +"auths.release.public-surface" = 433 diff --git a/release/semantic-freeze.json b/release/semantic-freeze.json index d1b86227a..5d00d8e23 100644 --- a/release/semantic-freeze.json +++ b/release/semantic-freeze.json @@ -1,6 +1,6 @@ { "schema": "auths.semantic-freeze/1", - "freezeVersion": 432, + "freezeVersion": 433, "publicSurface": { "rustRoots": [ "auths", @@ -202,7 +202,7 @@ }, { "id": "auths.frozen-bytes/formal/assurance-manifest-v1.toml", - "version": 62, + "version": 63, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -210,7 +210,7 @@ "owners": [ "formal/assurance-manifest-v1.toml" ], - "sha256": "b540346bb0da7fd92e0917a329eb4a2cd42ea30eaaf69e4959d3d15692437e13" + "sha256": "a4fe8de0be22c88bd56ffd32d7eae2f333f2c3b31f84c8b363c8c42ef9ae8126" }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/generated", @@ -238,7 +238,7 @@ }, { "id": "auths.frozen-bytes/formal/qualification/aeneas/source-closure.json", - "version": 107, + "version": 108, "classification": "frozen-bytes", "categories": [ "canonical-generated-evidence" @@ -246,7 +246,7 @@ "owners": [ "formal/qualification/aeneas/source-closure.json" ], - "sha256": "0681a320b4bf3527739fef5157da2817da6aa61e1b95630ae5229c5c5921c736" + "sha256": "4f9725bdf2da92e96a1751d495cf8353e9db12b7f1799313822b9be92a9985c3" }, { "id": "auths.frozen-bytes/product/conformance/v1/mechanism-profile-conformance.json", @@ -986,7 +986,7 @@ }, { "id": "auths.release.evolution-contract", - "version": 85, + "version": 86, "classification": "frozen-meaning", "categories": [ "version-axes", @@ -1007,11 +1007,11 @@ "release/fixtures/evolution", "xtask/src/evolution_policy.rs" ], - "sha256": "ceeb00844716adb15cbf57d48af84f16741c425f415cc684a80fc7472c3b00f4" + "sha256": "72b4cb9949a0a4248a82fa9709d629051f4df12b498b4b347fb92c821670960d" }, { "id": "auths.release.public-surface", - "version": 432, + "version": 433, "classification": "release-metadata", "categories": [ "package-names", @@ -1104,7 +1104,7 @@ "xtask/src/release_launch.rs", "xtask/src/semantic_freeze.rs" ], - "sha256": "2f369b5917b67332d8b5e98f23704abb75ab82794a6fa35793c59b38bb13c28b" + "sha256": "41eff875c18f9c656c309f9af7c59d36a06d6f21ef7e0e942783bfd4eb66182e" } ] } diff --git a/xtask/src/formal_qualification.rs b/xtask/src/formal_qualification.rs index f9fc8c61a..c4c8cbf29 100644 --- a/xtask/src/formal_qualification.rs +++ b/xtask/src/formal_qualification.rs @@ -1682,6 +1682,22 @@ fn validate_release_workflow_gates(orchestration: &str, builder: &str) -> Result } fn validate_lean_reuse_fallback(job: &str, fresh_step: &str) -> Result<(), String> { + // A fresh checkout has no Lake packages. The current-head warning audit + // checks the actual pinned dependency, so setup must precede reuse even + // when the expensive repository proof build can be omitted. + let setup = workflow_step_source(job, "Prepare pinned Lean dependency audit")?; + if !setup.contains("uses: ./.github/actions/setup-lean") + || setup.lines().any(|line| { + let line = line.trim_start(); + line.starts_with("if:") || line.starts_with("continue-on-error:") + }) + || job.find("name: Prepare pinned Lean dependency audit") >= job.find("- id: lean-reuse") + { + return Err( + "Lean reuse requires an unconditional pinned dependency audit setup before validation" + .to_owned(), + ); + } for required in [ "- id: lean-reuse", "if: github.event_name == 'pull_request'", @@ -2483,6 +2499,53 @@ mod tests { } } + #[test] + fn fresh_checkout_lean_reuse_requires_dependency_setup_before_both_validators() { + let hosted = include_str!("../../.github/workflows/ci.yml"); + assert!(validate_ci_workflow_gates(hosted).is_ok()); + for (name, fresh) in [ + ( + "formal-proof-fast", + "Compile the highest-value proofs, then the complete Lean libraries", + ), + ( + "formal-lean-authoritative-run", + "Clean and rebuild authoritative Lean evidence", + ), + ] { + let job = workflow_job_source(hosted, name).expect("maintained Lean job"); + let setup = workflow_step_source(job, "Prepare pinned Lean dependency audit") + .expect("pinned setup"); + let missing = job.replace(setup, ""); + let late = format!("{missing}{setup}"); + let conditional = job.replace(setup, &setup.replace( + "uses: ./.github/actions/setup-lean", + "if: steps.lean-reuse.outputs.reused != 'true'\n uses: ./.github/actions/setup-lean", + )); + let ignored = job.replace( + setup, + &setup.replace( + "uses: ./.github/actions/setup-lean", + "continue-on-error: true\n uses: ./.github/actions/setup-lean", + ), + ); + for changed in [missing, late, conditional, ignored] { + assert!( + validate_lean_reuse_fallback(&changed, fresh).is_err(), + "{name}" + ); + } + } + } + + #[test] + fn fresh_checkout_cannot_skip_actual_pinned_dependency_warning_audit() { + let fresh = tempfile::tempdir().expect("fresh checkout directory"); + let qualification = load_qualification(&crate::root()).expect("maintained qualification"); + assert!(!fresh.path().join("formal/.lake/packages/aeneas").exists()); + assert!(validate_warning_inventory(fresh.path(), &qualification).is_err()); + } + const CI_GATES: &str = r#"uses: ./.github/actions/setup-lean kani-verifier --version 0.67.0 cargo xtask ci preflight @@ -2493,6 +2556,9 @@ needs: [ci-plan, formal-update-gate, repository-preflight] needs.repository-preflight.result == 'success' formal-proof-fast: needs: [ci-plan, formal-update-gate] + - id: lean-setup + name: Prepare pinned Lean dependency audit + uses: ./.github/actions/setup-lean - id: lean-reuse if: github.event_name == 'pull_request' env: @@ -2535,6 +2601,9 @@ cargo xtask ci formal-kani needs: [ci-plan, formal-update-gate, repository-preflight, formal-proof-fast, formal-translation-run] needs.formal-proof-fast.result == 'success' needs.formal-translation-run.result == 'success' + - id: lean-setup + name: Prepare pinned Lean dependency audit + uses: ./.github/actions/setup-lean - id: lean-reuse if: github.event_name == 'pull_request' env: